+ Associated example files


NB: An exercise relating to the material covered in this tutorial can be found on the Exercises page.

The chop method is one of the features of slippery chicken that most embodies its structural marrying of computer-generated and instrumental resources. It is essentially a DSP technique applied to conventionally notated musical material, dividing rhythmic content (and its associated pitch-curves and marks) into multiple fragments for further use, much as cutting and splicing of audio is used to create loops and other discontinuities.

The chop method can be used as part of the technique of intra-phrasal looping, a process by which the resulting fragments are assembled into new sequences using the fibonacci-transitions function, as described in the tutorial on intra-phrasal looping.

+ Three levels of chop

The chop method exists for three levels of rhythmic classes, namely rthm-seq-bar, rthm-seq, and rthm-seq-palette. Most users will only need to use and understand the rthm-seq-palette version of the method.

At the lowest level, the method chops a rthm-seq-bar object into fragments, returning a list of new rthm-seq-bar objects, each containing one fragment. At the rthm-seq level, the method returns a list of rthm-seq objects, each of which consists of one of the rthm-seq-bar objects created.

At the rthm-seq-palette level, the chop method returns a new rthm-seq-palette with the same structure as the original, but with a further level of nesting: Each rthm-seq of the original is replaced by a (sub-) rthm-seq-palette consisting of rthm-seq objects, each of which again consists of only one of the rthm-seq-bar objects created by fragmenting the original rthm-seq-palette.

More detail on the various levels of chop can be found in the documentation of the source code for rthm-seq-bar, rthm-seq, and rthm-seq-palette.


+ The chopping unit and chop points

The chop method fragments the source material on the basis of a chopping unit and a collection of chop points. The chopping unit must be a duplet rhythmic value (e.g. 32, 's, 'e etc.) and an even subdivision of the beat basis for the material being chopped (a quarter can be evenly subdivided into two 8ths, four 16ths etc.). It cannot be a tuplet value (e.g. 'te, 'fe, 12 etc.).

The chop points define the start and end points of segments within one beat, each segment being a multiple of the chopping unit. Thus, with a chopping unit of a sixteenth, a beat basis of a quarter can be segmented into durations of four sixteenths, three sixteenths, two sixteenths and one sixteenth. A segment with the duration of four sixteenths spans the entire beat. Segments with the duration of three sixteenths can be found from the first to the third sixteenth of the beat, and again from the second to the fourth, both inclusive. Segments with a duration of two sixteenths can be found from the first to the second sixteenth, the second to the third, and the third to the fourth, all inclusive. The final subdivision, one sixteenth, can be found from the first to the first sixteenth, the second to the second, the third to the third, and the fourth to the fourth inclusive.


The chop points in the image above can be specified as such:

(chop object-to-chop
      '((1 4)                      
        (1 3) (2 4)              ; chop points
        (1 2) (2 3) (3 4) 
        (1 1) (2 2) (3 3) (4 4)) 
      's)) ; chopping unit


+ Chopping the original material

The method then applies this chopping pattern to each beat of the original material. For this reason, the method can only be applied to material whose time signatures have a denominator that is equal to the beat defined by the chop points. For example, if the chop points have been defined to segment a quarter note, that instance of the method can be applied to any x/4 bar, but not to an x/8 bar. An attempt to do so will produce an error.

As the method passes through the original material, it extracts the musical data from each successive segment of the given beat and uses that data to create a new rthm-seq containing one rthm-seq-bar object. Each of these new bars have the same duration as the segment and are assigned a time signature to reflect this duration. Thus, any rthm-seq-bar objects created from segments with a duration of three sixteenths will have a 3/16 time signature, those made from segments of two sixteenths will have a 1/8 time signature etc.

The method only creates sounding notes in the new rthm-seq-bar objects from attacked notes in the original segment. If the original segment contains the sustained portions of notes whose attacks occurred in a previous segment, those sustained portions are translated into rests in the new rthm-seq.

Thus, when the above chop parameters are applied to this original:


…the following ten fragments are created as individual rthm-seq-bar objects:


The method assigns the newly created rthm-seq objects sequential numerical IDs so that they can be easily accessed and manipulated later, as described below.


+ Referencing rthm-seqs in a chopped rthm-seq-palette

The additional level of nesting created by chop when applied to a rthm-seq-palette makes an additional ID necessary in order to reference each rthm-seq object it contains. The method creates consecutive numerical IDs automatically for each of the new nested rthm-seq objects it generates. The new rthm-seq objects can then be accessed using a combination of the ID of the original rthm-seq object from which the fragment objects were created and the new object's own individual ID.

As an example, the first rthm-seq object created from the first fragment of an original rthm-seq object with the ID 1 is accessed using (1 1), the second using (1 2), the third using (1 3), etc. Correspondingly, the first rthm-seq object created from the first fragment of an original rthm-seq object with the ID 2 is accessed using (2 1), and the reference (3 2) would get the second rthm-seq object created from the second fragment of an original rthm-seq object with the ID 3, etc. It is important to note here that while the IDs of the newly created objects are automatically given consecutive numbers, the first ID of these pairs is the ID the user has assigned to the original rthm-seq objects and therefore does not necessarily need to be a number.

This code example uses the nested references described above:

(let* ((orig-palette (make-rsp 'orig
                               '((1 ((((1 4) - s e s - ))
                                     :pitch-seq-palette ((1 2 3))))
                                 (2 ((((1 4) - e. s - ))
                                     :pitch-seq-palette ((1 2))))
                                 (3 ((((1 4) - (e.) s - ))
                                     :pitch-seq-palette ((1)))))))
       (chopped-palette (chop orig-palette
                              '((1 4) 
                                (1 3) (2 4) 
                                (1 2) (2 3) (3 4) 
                                (1 1) (2 2) (3 3) (4 4)) ; chop points  
                              's)) ; chopping unit
         :title "sc chopped example"
         :instrument-palette +slippery-chicken-standard-instrument-palette+
         :ensemble '(((vn (violin :midi-channel 1))))
         :tempo-map '((1 (q 60)))
         :bars-per-system-map '((1 10))
         :set-palette '((1 ((c4 d4 e4))))
         :set-map '((1 (1 1 1 1 1)))
         :rthm-seq-palette chopped-palette
         :rthm-seq-map '((1 ((vn ((1 1) (1 2) (1 3) (2 1) (3 2))))))))) 
  (cmn-display sc-chopped-example :file "/tmp/sc-chopped-example.eps"))

…and produces the following output:



+ re-bar

Since the results of the chop method are generally very short bars with multiple, divergent time signatures, the use of the slippery-chicken class's re-bar method can be very helpful. This method regroups the fragmented musical material into new bars that are close as possible to a specified length. An example of the usage of this method can be found in the tutorial on intra-phrasal looping.

For an example of the chop method used within a piece, see the tutorial on intra-phrasal looping.