Week 3 lesson 4 - chop and striate

Continuing on from Week 3 lesson 3 - slice and splice , lets round off our week of work with longer samples, to look at a different way of 'beat slicing', using 'chop' and 'striate'.

Here's the video:

.. and here's the worksheet:

-- Let's take a nice break:
once $ sound "break:8"

-- We can use 'begin' and 'end' to only play part of the sound, in this
-- case the final quarter of it:
d1 $ sound "break:8*4" # begin 0.75 # end 1

-- We can also use 'unit "c"' to change the behaviour of 'speed' so it
-- changes the playback speed to match the cps
d1 $ sound "break:8" # speed 1 # unit "c" # begin 0.75 # end 1

-- Lets play four of those to fill the cycle
d1 $ sound "break:8*4" # speed 1 # unit "c" # begin 0.75 # end 1

-- Then play with the cps to hear it change, fitting the cps perfectly
setcps 0.8

-- Normally, I wouldn't use 'unit', 'begin' and 'end' by hand. Instead
-- I'd use splice / slice from the previous lesson, or 'chop' to cut
-- a sound into bits, and set the length of the loop in cycles with
-- 'loopAt'
d1 $ loopAt 2 $ chop 4 $ sound "break:8"

-- The above sounds pretty continuous, but it is chopped into four parts.
-- We can hear that by reversing the chopped up parts:
d1 $ loopAt 2 $ rev $ chop 4 $ sound "break:8"

-- If we slow the pattern we can hear each part separately:
d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8"

-- Here's a different sample:
d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:9"

-- Now what happens if we put both breaks in the sequence?
d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8 break:9"

-- With 'chop', it will play all the parts of break:8, followed by
-- all the parts of 'break:9'.

-- If we swap 'chop' for its friend 'striate', then parts from the
-- two breaks are instead interlaced:
d1 $ slow 2 $ loopAt 2 $ striate 4 $ sound "break:8 break:9"

-- Play with that striate value for fun:
d1 $ slow 2 $ loopAt 2 $ striate 32 $ sound "break:8 break:9"

-- If you use the *same* loop multiple times with striate, it kind
-- of stretches it:
d1 $ slow 4 $ loopAt 1 $ striate 4 $ sound "break:1*4"

-- Here's what that normally sounds like:
once $ sound "break:1"

-- 'bev' is an even longer sample..
d1 $ loopAt 16 $ striate 32 $ sound "bev"

d1 $ slow 4 $ jux rev $ loopAt 16 $ striate 128 $ sound "bev*4"

Next lesson:
https://club.tidalcycles.org/t/week-4-lesson-1-continuous-patterns-sine-square-tri-saw-and-random-functions/608

10 Likes

Damn. There's so much fun here. Might even do a little live stream later today destroying the hell out of a set of samples. Thanks Alex!

(This is SO cool, am looking forward to doing it on a few of my own samples)

d2
  $ every (irand 3) (degradeBy rand)
  $ slow ((irand 4)+1)
  $ loopAt ((irand 5) +1)
  $ striate (irand 64)
  -- $ slice 16 "0 1 5 4 8 6 1 0"
  $ s "break:10"
    # room 0.5
    # cut 1
    # att rand
    # hold rand
    # rel rand
6 Likes

hello @yaxu. Very interesting functions!!! Would it be possible to modulate the number of cuts? I was trying something like this but doesn't work...

d1 $ slow 2 $ loopAt 2 $ striate (slow 4 $ range 2 32 sine) $ sound "break:8 break:9"

1 Like

Is it possible to just take a subset of a sample and then apply chop to that? For example, I have this subset of the sample:

d5 $ s "bev" # begin 0.3 # end 0.6

And now I want to chop/loop just that bit, but

d5 $ loopAt 2 $ chop 4 $ s "bev" # begin 0.3 # end 0.6

isn't what I want.

Interesting ... this is more what I was going for, but I don't understand exactly why it works. Why do I need to slow the speed to make this work?
d5 $ loopAt 2 $ chop 4 $ s "bev" # begin 0.3 # end 0.6 # speed 0.22

Sorry I missed this question! The problem is that sine returns a pattern of floating point (decimal) numbers, and striate is after a pattern of integers (whole numbers). To change between then you can use round <$>, to round to the nearest integer

slow 2 $ loopAt 2 $ striate (slow 4 $ round <$> range 2 32 sine) $ sound "break:8 break:9"
1 Like

Hm yes, loopAt isn't very clever so to get the smaller bits to fill the cycle properly you'll have to fiddle with the speed. I can't think of a better way around this at the moment..

3 posts were split to a new topic: <$> and overloading