slippery chicken documentation - chop

## chop

### + Associated example files

- chop-examples.lsp

close

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`.

close

### + 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

close

### + 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.

close

### + 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
           (sc-chopped-example
            (make-slippery-chicken
             '+sc-chopped-example+
             :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:

close

### + 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.

close