jitterbug

(aka four views of a rhythmic-structural procedure based on iterated proportions of 6:3:5:4)

jitterbug is a four-movement four-channel work/album for computer, with or without improvising musicians. It was created with my slippery chicken algorithmic composition software and premiered at Museum Siam, Bangkok, on November 29th 2015 as part of the As((ear))n exhibition of curated sounds from throughout South-East Asia. On this occasion it was presented with improvised contributions from Karin Schistek (keyboard) and Anant Narkkong (various SE Asian instruments including marimba and saw duang, a Thai soprano fiddle). The version without improvisors is available as an album download.

The four movements—taking one of the proportions 6:3:5:4, in that order—have a total duration of 40:30. Movements 1 & 2 and 3 & 4 overlap, making for two equal halves separated by silence. The titles of the movements are:

1(6): stuffed animals and licorice

2(3): my father’s hazards

3(5): zero to ten

4(4): shiny metal mixing bowl

Matt Sumell – Making Nice

The title jitterbug comes from the name of the main rhythmic generative algorithm (see below). The movement titles come from Matt Sumell’s 2015 novel Making Nice. I was reading this at the time my father was dying of cancer in the first half of 2015. In the novel the protagonist’s mother is dying of cancer. When taken out of context the titles themselves are particularly strong and colourful, though not particularly clear. In the context of the larger text they take on different but generally very clear meanings, some rather prosaic, like various aspects of the process of dying:

“I bought her stuffed animals and licorice and long straws so she could drink her juice in bed.”

“…there was a lot of blood, but it [a puppy] kept breathing for a few minutes before it stopped and died in the on-and-off orange of my father’s hazards.”

“How are you on a scale of zero to ten, zero being no pain and ten being the worst pain you’ve ever felt?”

“When she finally looked up from washing a shiny metal mixing bowl and saw me there waiting to order my favourite sandwich–the Tuscany, it’s Italian–she turned off the faucet and yelled, ‘Vaness! Vanessa! Come out front and help this lady'”.”

sound sources

Many different sounds were used in the mix. Some were longer sound files, treated acousmatically, such as rain in Montreal, interviews I recorded with my dad before he died, or the evening call to prayer in Yogyakarta; some were vocal statements or sung animal-like sounds; others were many and various short sounds, used as samples and driven by various outputs of the jitterbug algorithm: prepared piano samples, piano samples, many gong and bell samples made from my own instruments sourced in Bangkok. These were either fed into slippery chicken’s clm-play method to generate sound files or, as was the case with several widely available keyboard and machine noise sample libraries created for the sforzando sampler in the SFZ open standard format, driven within the Reaper DAW environment by MIDI files created from slippery chicken. Many animal sounds I cut, edited, and polished from recordings sourced online at the Macaulay Library of Cornell University. I used recordings of Jaguar sex by Gustav Peters; elephant seals by Thomas Sander; and red deer by Bob McGuire.

As in a lot of my recent pieces involving computer generated and/or processed sound, I also made significant use of my favourite analogue synthesiser modelling software, Montreal-based Applied Acoustics’s Ultra Analog. This was used for sustained harmonies and drones as well as for more active jitterbug-generated voices. The output was mixed with similarly generated sample-based files and granular synthesis of bells, gongs, and cello multiphonics.  The granular synthesis approach used a new algorithm which scans folders of any number of sound files, looking for files with the closest pitches to those of the desired harmonies. These are then fine-tuned, granulated, and narrowly bandpass filtered so as to clearly extract the harmony’s pitches.

pexpand

As with most of my pieces since about 2000, jitterbug was made with slippery chicken. The pexpand algorithm was used as the fundamental structure generator here. This takes simple integer proportions and expands them iteratively outwards to create an arbitrary number of ever-larger sections, subsections, and sub-subsections, etc. Take for example a simple 3:2 proportion expanded over one generation. This creates blocks of five units (3+2), three in the first section (A), and two in the second (B). The Lisp results look like this:

(pexpand 1 3 2) →
(25 (((A) 15) ((A A) 5) ((A B) 5) ((A C) 5)) (((B) 10) ((B A) 5) ((B B) 5)))

Expand these proportions over two generations and we’re now working with the above 25-unit block instead of a five unit block. So section A has three 25-unit blocks and B has two, hence 75:50:

(pexpand 2 3 2) →
(125
(((A) 75)
  (((A A) 25) (((A A A) 15) ((A A A A) 5) ((A A A B) 5) ((A A A C) 5))
   (((A A B) 10) ((A A B A) 5) ((A A B B) 5)))
  (((A B) 25) (((A B A) 15) ((A B A A) 5) ((A B A B) 5) ((A B A C) 5))
   (((A B B) 10) ((A B B A) 5) ((A B B B) 5)))
  (((A C) 25) (((A C A) 15) ((A C A A) 5) ((A C A B) 5) ((A C A C) 5))
   (((A C B) 10) ((A C B A) 5) ((A C B B) 5))))
(((B) 50)
  (((B A) 25) (((B A A) 15) ((B A A A) 5) ((B A A B) 5) ((B A A C) 5))
   (((B A B) 10) ((B A B A) 5) ((B A B B) 5)))
  (((B B) 25) (((B B A) 15) ((B B A A) 5) ((B B A B) 5) ((B B A C) 5))
   (((B B B) 10) ((B B B A) 5) ((B B B B) 5)))))

The proportions used in jitterbug were 6:3:5:4. These were expanded over two generations then used for the durational structure of the piece. If you take a look at the detailed output of the call, you can see that pexpand returns 5832. This number was interpreted as beats rather than bars or seconds, perhaps. At a basic tempo of 144BPM—sometimes audible, more often in the background—this will result in a total duration of 40:30. Given the 6:3:5:4 overall proportions this makes for four movement durations of 13:30, 6:45, 11:15, and 9:00. Each fundamental 18-beat unit is 7.5 seconds long; each 324-beat (18*18) block is 2:15; and so there are, of course, six such blocks in the first movement, three in the second, five in the third, and four in the fourth.

rhythms

The rhythmic technique used in jitterbug was documented in my blog post Keep it Simple: Complex Rhythmic Notation in Common Lisp. Always with a view to creating structural integrity at various levels of the compositional design, I used the basic 6:3:5:4 proportions as seed data in RQQ notation for the rhythm-generating algorithm. This—the jitterbug algorithm itself—was the fundamental rhythmic procedure used in each of the four movements. Essentially the jitterbug algorithm creates rhythm sequences by producing various RQQ structures from permutated sequences of integer proportions. For each permutation the bar duration is divided into parts proportionally equally to the integers but omitting the first; we then further subdivide each part into a number of divisions determined by the basic proportions starting with the previously omitted first integer. Any given permutation of the four integers will thus result in three groups of divisions. (If we were to consistently use all four integers, whether in permutation or not, the results would be far too similar between each of the generated rhythm sequences.) Put another way, the bar is filled by a division into three, where the first integer determines the number of divisions of the group whose relative duration is specified by the second integer; then the second integer determines the number of divisions of the group whose duration is specified by the third integer; and finally the third integer determines the number of divisions of the group whose duration is specified by the fourth integer:

the first argument is the bar duration in quarter notes (so 3/4 meter here)
(jitterbug 3 '(6 3 5 4)) -->
(4 3 5 6): ((((3 4)
                  so 4 divisions of 3 then 3 divisions of 5 then 5
                  divisions of 6
              (3 ((3 (1 1 1 1)) (5 (1 (1) 1)) (6 (1 (1) 1 (1) 1)))))))
(5 6 4 3): ((((3 4)
              (3 ((6 (1 1 1 1 1)) (4 (1 1 (1) 1 1 1)) (3 (1 (1) 1 1)))))))
(3 6 5 4): ((((3 4)
              (3
               ((6 (1 1 1)) (5 (1 (1) (1) (1) 1 1))
                (4 (1 (1) 1 (1) 1)))))))
etc.

pitch structure

As is common with the standard use of slippery chicken, pitches are first of all conceived as sets (or harmonies) and horizontal lines. (I hesitate to use the term ‘melodic line’ as this most often does not apply.) But whichever way you look at it, the lines are created via my pitch-curve methods.

The harmonies themselves though are created via a ring modulation procedure that creates difference and sum tones from partials of a single given tone. An example call with a few of the results is given below. What the procedure does is to treat the given tone both as a fundamental and as the highest partial (from a user-given maximum) of an invented fundamental; it then gets the partials of the given tone and the invented fundamental, and from those all the possible pairs of the two; before finally ring modulating each pair separately. The ring modulation process itself treats each frequency in a pair as a separate fundamental, each with its respective partials also.

(limit-shift-octave
           (remove-similar
            (set-palette-from-ring-mod
             'c4 'test :force-chromatic t :remove-octaves t
             :start-id 0 :warn-no-bass nil :min-bass-notes 3
             :ring-mod-bass-octave 2
             :partials '(1 2 3 4 5 6))
            :threshold 0.6)
           :upper '(0 g6 100 c5))

automatic chord sequencing

The chords generated with the ring-modulation technique are then filtered to remove similar chords using my chord similarity test method; limited to be within a specified range (which can change, via an envelope, over the course of the generation process); then automatically sequenced according to envelopes which specify transitions of dissonance and pitch height. The sequence however is not run through from beginning to end, rather it’s run gradually forwards and backwards a little at a time until we get to the end, as documented in the procession algorithm. The auto-sequence process is documented in a separate blog post. For a detailed description of a set/chord’s dissonance or spectral centroid see that post and/or the online slippery chicken documentation of calculate-spectral-centroid and/or calculate-dissonance.