Euclidean rhythms

If you want to draw a line, say, from (0, 0) to (13, 5) by setting values in a pixel buffer (with no anti-aliasing) you have the same problem.

The classical solution (Bresenham's algorithm) is basically to draw pixels in the direction of the longer axis (in this case the X axis), adding a fractional increment of 5/13 to an accumulator to represent the subpixel movement on the shorter axis (in this case the Y axis). When the accumulator exceeds the threshold, you move a pixel on the short axis and subtract 1 from the accumulator.

You can equivalently start the accumulator at 0.5 with threshold of 1, for an accumulator range of [0, 1], or start at 0 with a threshold of 0.5, for a range of [-0.5, 0.5]. Instead of tracking the accumulator directly, you can track the product accumulator*13, which lets you use all-integer arithmetic.

The explanation based on Bjorklund's algorithm seems less intuitive and more convoluted than one based on Bresenham's algorithm.

I also don't really see the connection to Euclid's algorithm.

In one sentence: Most "interesting rhythms" are integer approximations of repeatedly adding a fraction.

[1] https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm

I have an irrational aversion to sequencers so I've been working on rhythm synthesis using oscillators to build a drumming robot. early prototype: https://www.youtube.com/watch?v=zeHJXyyhJ70

Rather than operating on preset sequences, I'm using a series of oscillators in Puredata that can have their frequencies set to various ratios of a primary frequency. The oscillators get added together and a drum hit is triggered on the zero crossing of the result. The patterns can be modulated by changing the amplitude and phase of the oscillators in realtime. The early prototype was made in Puredata but now I'm trying to put all the rhythm synthesis into the robot microcontroller using the Mozzi library.

I'd love be able to initialize the oscillators with these Euclidean patterns and then be able to modulate them using the oscillator controls. I'm curious if any one knows of a way to take an existing drum pattern and calculate a small series of sine waves that would express that pattern. Kind of like FFT but for rhythms. This seems like something someone might have already figured out.

The claim that "almost all of the most important world music rhythms are Euclidean rhythms" requires some serious cherry-picking and arm twisting. I would agree on much weaker claim that all Euclidean rhythms can be recognized in world music, but then most of random arrangements on 8 and 7 grid will sound familiar after couple of repetitions. Humans are just good at recognizing rhythmic patterns.

No good discussion of Eucridian rhythms ends without bringing up the Buchla 252e Polyphonic Rhythm Generator, so here's a demo for the uninitiated: https://youtu.be/iekVNSaXPz8

Buchla had a lot of neat modular instruments along the same lines as this one, definitely a rabbit hole worth falling into if you haven't already. Now I just hope that Uli Behringer hears my prayers and designs some Buchla recreation modules.

The king of Euclidean rhythm hardware sequencer (MIDI/CV) is still the Squarp Pyramid[1] to my knowledge. Some crazy stuff you can do. Sold mine a few years ago as you really need training and muscle memory to get the best out of it though...

[1] https://squarp.net/pyramid/

I never thought I'd see the issue of pulse selection in spallation neutron sources referred to on HN, let alone linked to music theory. In practice, most systems that select a subset of these pulses will select 1 pulse in every 2^n pulses, so fancy patterns aren't needed. But I work at a facility where 1 in every 5 pulses are removed in order to supply another part of the site, and where the particular instrument I work with uses 1 in every 2 or 3 pulses. At the moment, the selection of 1 in 2-3 pulses is accomplished with a spinning disc ('chopper') with a hole in it, to let though the required fraction of pulses. But the spin speed of the disc must generally be constant once set, meaning sometimes it lets though one of the missing 1-in-5 pulses that were already diverted somewhere else. We would need a better switching method to let through arbitrary irregularly spaced patterns of neutrons. I think I worked out once that it could offer the most advantage when running in our 1-in-3 mode.

The article says "they have the property that their onset patterns are distributed as evenly as possible", but their appeal seems to lie in the fact that they cannot be distributed completely evenly, on account of the number of onsets and the number of steps being coprime integers.

This is a cool explanation!

I wrote a Euclidean rhythms plugin for Logic Pro X scripter:

code: https://github.com/stereosteve/ScriptDiddy

demo: https://www.youtube.com/watch?v=cInvIxaeYZ4

of course I copy pasted the actual implementation from here: https://github.com/Lokua/euclidean-sequence/blob/master/inde...

It's pretty fun to use with AUs and VSTs

Euclidean rythms are well supported in the Tidal Cycles family of live programming environments. Here's a demo that you can play with online: https://strudel.tidalcycles.org?fTGy0eTiAUox

Which I took from its examples in the tutorial: https://strudel.tidalcycles.org/tutorial/

Tidal Cycles can be used to generate sound on your computer but it can also sequence MIDI hardware.

Cool - this is sort of reversed for me, it's using the Euclidean algorithm to illuminate the structure of traditional rhythms, but I'm very knowledgeable about the latter and have never studied / have forgotten the former, so I've just learned the Euclidean Algorithm by drumming on the table..

Lua:

function b2n(boo) return boo and 1 or 0 end

function eu(index,length,beats,offset) return b2n((((index + offset) * beats) % length) < beats) end

function euquence(length,beats,offset) local l = {} for i=0,length do local r = eu(i,length,beats,offset) table.insert(l,r) end return table.concat(l,’ ‘) end

I hadn't known of ObservableHQ and see it seems a Javascript notebooks shout-out at what Mathematica started with their Theo Gray notebooks in 1988?

How is Wolfram Research not involved, since it's so clearly Theo Gray's invention?

What is the language used for coding?