Seems everyone with a modular thingie is using euclidean rhythms these days. They are somewhat limited, though, as by design, they spread out the hits as evenly as possible. So nothing for short bursts with pauses in between. Is there a possibility to, based on the original idea, change that?

*This idea is provided under a cc-by license.*

## Description and Example

First of all, a definition:

*A burst, in the context of this text, is a subsequence of more than one “1”s enclosed by at least one “0” on either side in a finite binary series.*

Note that a burst does not change the underlying pulse; if we’re thinking in 16th notes, the bursts are sequences of 16th notes. If you want trap hihats, you need to do that in 32nds.

So what I want to achive is to have a rhythm with bursts with periods of silence in between them. To make as big a burst as possible is trivial; for the introductory example in Touissant’s paper in chapter 2 (with n=13, k=5, i.e. E(5,13) this would be:

[1 1 1 1 1 0 0 0 0 0 0 0 0]

So for this to be interesting, we need to make several shorter bursts. For this, we need an additional parameter.

There are two possible options: a maximum burst length, or a minimum number of bursts. They lead to the same result if chosen properly. I’ll stick with a maximum burst length (and call it m) now.

So if I choose m=3 and apply this, to the n=13, k=5 example from above, the suggested approach is as follows:

- Find out how many bursts (I call that b) of which length you get based on parameters m and k.
- Then space out the resulting bursts using Björklund’s algorithm.

## Find out the bursts

In our example, m=3 and k=5. We simply start to make the first burst until its length has reached m, then we make the second one and so on, until all ks are used up. Thus, we get two bursts, of length 3 and 2. Our b=2.

The number of bursts and their size follow rules which formally are a bit tricky to describe without thinking too hard, but easy to understand:

- if k<m, there is one burst of length k (and b=1),
- if k>=m, there is at least one burst of length m and none or one burst of length <m.

Following that, for simplicity, I suggest to simply use the bursts in the order “full length, then shorter”.

## Spread out the bursts

With b=2, we now can put our result back into Touissant’s algorithm, with each burst counting as one step. n is now the original eight 0s and our two bursts, so n=10. The k for the algorithm is our b=2.

This is a trivial case:

[1 0 0 0 0 1 0 0 0 0]

## Put it together

Now I know how many 0s are after each burst. I now start to replace the 1s with full-length bursts, and once I run out of them, use the single shorter burst.

Resulting in:

[1 1 1 0 0 0 0 1 1 0 0 0 0]

## So what to do with it? Is it any good?

Yesterday, I tried to manually program some of those, both against normally programmed (EDM) rhythms and against Euclidean ones. It seems to work nicely. If it’s any good for you is for you to decide, however, programming them manually is not fun, so…

## Potential for implementations

As of today, there are many implementations of the Björklund algorithm in things Eurorack. From the modules I personally use, I can think of Hermod, Disting, DistingEX, o_C Hemisphere and Grids. There are also dedicated modules for it e.g. by 2hp or VPME. I’m pretty sure there’s many more, though.

I would go as far as to claim that any device that can run an Euclidean algorithm and would somehow allow for an additional parameter could also run this algorithm. In fact, if you set m=1, the algorithm reverts to a normal Euclidean one.

So **developers out there: why don’t you implement this? Feel free to contact me if you feel like it!**