Euclidean rhythms on the Monome Teletype

Earlier this year I did some work on a Euclidean rhythm operator for the Monome Teletype. Here is the pull request¹, the beta firmware, and there is also a thread to discuss it on lines.

Euclidean rhythms

Euclidean rhythms were first described by Godfried Toussaint in his 2005 paper “The Euclidean Algorithm Generates Traditional Musical Rhythms”². From the abstract:

The Euclidean algorithm (which comes down to us from Euclid’s Elements) computes the greatest common divisor of two given integers. It is shown here that the structure of the Euclidean algorithm may be used to generate, very efficiently, a large family of rhythms used as timelines (ostinatos), in sub-Saharan African music in particular, and world music in general. These rhythms, here dubbed Euclidean rhythms, have the property that their onset patterns are distributed as evenly as possible.

Once you’re more familiar with how they work, it’s well worth having a look through the paper. There is plenty of interesting information in there (along with all the maths).

In essence a Euclidean rhythm evenly spreads out a numbers of beats (or fill), along a repeating sequence of a given length. Thus, the Euclidean rhythm fill=4, length=16, is x...x...x...x... (a.k.a. four on the floor at 16^th beats). Given that the rhythm repeats, this is more efficiently given as fill=1, length=4: x.... More interesting examples are in the paper.

On the Teletype

On the Teletype, Euclidean rhythms are implemented with a new operator, ER as follows:

ER fill length step

The operator either returns a 0 (i.e. no beat) or a 1 (a beat) for a given Euclidean rhythm, where fill is the number of played beats and length is the length of a single sequence (as previously described). The 3^rd parameter, step, is the value of the rhythm at a given step. Particular care must be given as step is 0-based like many other operations on the Teletype, i.e. the first step is 0, and the last step in a sequence that has length 16 is 15!

Both fill and length accept values between 1 and 32 inclusive³, where fill ≤ length. Step may be any number—it is modulo (or wrapped) with the length, so that it is always in bounds. Any invalid input results in the operator returning a 0.

Some simple examples

Let’s look at the example of fill=4, length=16, i.e. x...x...x...x.... (These are best entered in LIVE mode.)

• ER 4 16 0 returns a 1 (remember 0 is the first step)
• ER 4 16 1 returns a 0
• ER 4 16 2 returns a 0
• ER 4 16 3 returns a 0
• ER 4 16 4 returns a 1
• ER 4 16 -1 returns a 0 (negative indices can be useful as we’ll see…)
• ER 4 16 -4 returns a 1

Let’s create a simple script that outputs a four on the floor rhythm by using the ER operator. Enter the following scripts as I and SCRIPT 1, and then supply a 16^th note trigger to input 1.

I:

T 0

SCRIPT 1:

IF ER 4 16 T : TR.PULSE A
T ADD 1 T

We’re using T to hold which step we’re on. We can update SCRIPT 1 to add a second output:

SCRIPT 1:

IF ER 4 16 T : TR.PULSE A
IF ER 6 16 T : TR.PULSE B
T ADD 1 T

Onset (or rotation or offset)

You might have noticed while playing with the above example that certain combinations of rhythms can’t be achieved as things stand, for example:

A: x...x...x...x...
B: ..x...x...x...x.

In order to create this rhythm we need to rotate one rhythm against the other. This is sometimes call the offset or the onset. In fact in our example rhythm B is the same A, but rotated 2 steps forwards (or backwards). Let’s modify SCRIPT 1 again:

SCRIPT 1:

IF ER 4 16 T : TR.PULSE A
Y SUB T 2
IF ER 4 16 Y : TR.PULSE B
T ADD 1 T

We’ve had to introduce another variable Y as we can’t fit everything on one line⁴. One thing that might not be obvious initially is that if we want to rotate a rhythm forwards we need to SUB, if we want to rotate a rhythm backwards we need to ADD. Thus if we want to use rotation with our Euclidean rhythms we can use the following:

ER fill length SUB step rotation

where rotation is the number of steps forward we wish to rotate the rhythm.

A four channel Euclidean drum machine

Finally, let’s recreate part of the drum machine from the video at the top of the page. We’re going use the pattern tracker to hold our values for fill, length and rotation for four drum sequences. Input 0 will be reset, and input 1 will be clock. The four trigger outputs A-D will trigger our drum modules.

I: set the time T to 0

T 0

SCRIPT 1: reset the time T to 0

T 0

SCRIPT 2: trigger scripts 3-6, increase T by 1

SCRIPT 3
SCRIPT 4
SCRIPT 5
SCRIPT 6
T ADD 1 T

SCRIPT 3: read fill, length and rotation from the first 3 rows respectively of column 0 of the pattern data

X PN 0 2
Y ER PN 0 0 PN 0 1 SUB T X
IF Y : TR.PULSE A

SCRIPT 4: as script 3, but use column 1

X PN 1 2
Y ER PN 1 0 PN 1 1 SUB T X
IF Y : TR.PULSE B

SCRIPT 5: as script 3, but use column 2

X PN 2 2
Y ER PN 2 0 PN 2 1 SUB T X
IF Y : TR.PULSE C

SCRIPT 6: as scripts 3 but use column 3

X PN 3 2
Y ER PN 3 0 PN 3 1 SUB T X
IF Y : TR.PULSE D

PATTERN: each column contains the fill in the first row, the length in the second and the rotation in the third for the four sequences

0|   4   6   4   9
1|  16  16  16  16
2|   0   2   2   0
3|   .   .   .   .
4|   .   .   .   .
.|
.|
.|

Start your clock and play around with the values on the pattern tracker (you can use the [ and ] keys to increment and decrement the value under the cursor too).