Creating Non-Isochronous Rhythm Patterns Using The Boss Dr.Beat DB-88 Metronome

image source: bosscorp

Features used

1. Identify the durations between onsets of the given pattern in 16th notes (i.e. dotted 8th = 3, 16th + dotted 8th rest = 4, 16th + 4th (crotchet) rest = 5, 4th = 4), resulting in the timeline 3-4-5-4. Or graphically, black squares representing onsets (aka TUBS):

2. Choose the duration that comes closest to a quarter note among those identified in the previous step (example: I choose 4.).
3. Assign the chosen duration a tempo that is integer divisible by the least common multiple of all durations divided by the chosen duration. (Why?)
   I.e. if you chose duration 3, the tempo assigned should be integer divisible by lcm(3,4,5)/3, i.e. 20. If you chose 4, the tempo should be integer divisible by lcm(3,4,5)/4, i.e. 15. Finally, if you chose 5, the tempo should be integer divisible by lcm(3,4,5)/5, i.e. 12.
   I call these required divisors increments, since they dictate the amount to increment a valid BPM to remain a valid BPM candidate. (In the example I assigned 90 BPM to the chosen duration 4: 90 is integer divisible by lcm(3,4,5)/4 = 15.
   Remark: Since 3, 4, and 5 are prime to each other, the increment for duration 3 is lcm(3,4,5)/3 = lcm(4,5) = 4 * 5, and likewise for the increments of the durations 4 and 5.
4. Determine the multiplier of the increment (15) to reach the tempo chosen in the previous step (example: 90/15 = 6).
5. Multiplying the remaining durations' (3 and 5) increments (20 and 12, respectively) with the multiplier (6) determined in the previous step will yield the tempo that represents the respective duration (example: 20 * 6 = 120, 12 * 6 = 72).

   Rhythm			DB-88
   duration (16ths)	increment		program	beat 1 count	beat 2 count	tempo (BPM)	LOOP count
   3	lcm(3,4,5)/3 = 20		1	1	0	120	1
   4	lcm(3,4,5)/4 = 15		2	1	0	90	1
   5	lcm(3,4,5)/5 = 12		3	1	0	72	1
   4	lcm(3,4,5)/4 = 15		4	1	0	90	1
   n/a	n/a		5	irrelevant	irrelevant	irrelevant	OFF
   n/a	n/a		6	irrelevant	irrelevant	irrelevant	OFF
   n/a	n/a		7	irrelevant	irrelevant	irrelevant	OFF
   n/a	n/a		8	irrelevant	irrelevant	irrelevant	OFF

6. The Boss Dr.Beat DB-88 "LOOP" mode has the limitation that it can only play programs 1 - 8 in that order. You can have a program played from 0 (="OFF") to several times, though. We have 4 note onsets, so we need 4 programs. So we program them all to 1 beat, no subdivision accents (as they will sound totally off when using this method), tempos as given in the table above. Then switch to "LOOP" mode and configure programs 1 - 4 to be played each once ("1"), and programs 5 - 8 to "OFF".
7. Press "START/STOP".

BPM Calculator Tool

• This method is not limited to 16th note patterns. It is equally applicable to tuplets.

I use a different example (2, 3, 4) for onset durations than "Ambidextrous" (3, 4, 5, 4), because in the "Ambidextrous" example all unique durations are prime to each other.

Converting BPMs (musical) to seconds (physical)
BPM2s : 60 / BPM = s
s2BPM : 60 / s = BPM
Remark: Conversion between BPM and seconds is an involution.

1. We need to create physical durations ("pd") that are in integer relation according to the musical durations ("md") of the given rhythm. e.g. 2, 3, 4

2. We can't enter seconds but only BPMs. If we want to have the approximate tempo of 120 BPM, we choose a duration that is closest to a quarter note in our rhythm, and assign it 120 BPM.

   2, 3, 4 -> the last note is 4 sixteenths which is a quarter note, so the last note gets 120 BPM.

   pd(chosen note) thus is BPM2s(120) = 60 / 120 = 1/2 s.
   pd(note x) = pd(chosen note) / md(note x), so
   pd(first note) = pd(chosen note) / md(first note) = 1/2 / 2 = 1/4 s.
   pd(second note) = pd(chosen note) / md(second note) = 1/2 / 3 = 1/6 s.

   What would happen if we chose to assign 120 BPM to the 2nd note (md(second note) == 3)?
   pd(note x) = 60 / BPM(note x) // no matter what md(note x) is!
   pd(note y) = pd(note x) * (md(note y) / md(note x)) // simple arithmetic for physical durations
   BPM(note y) = 60 / [ pd(note x) * (md(note y) / md(note x)) ]
   BPM(note y) = 60 / [ (60 / BPM(note x)) * (md(note y) / md(note x)) ]
   BPM(note y) = BPM(chosen note) * md(chosen note) / md(note y).

3. Generalize:

   (3.1) BPM(note x) = BPM(chosen note) * md(chosen note) / md(note x)

   Now, convert these back to BPMs:
   BPM(note x) = BPM(chosen note) * md(chosen note) / md(note x)
   BPM(first note) = 120 * md(chosen note) / md(first note) = 120 * 4 / 2 = 240.
   BPM(second note) = 120 * md(chosen note) / md(second note) = 120 * 4 / 3 = 160.
   BPM(chosen note) = 120 * md(chosen note) / md(chosen note) = 120 * 4 / 4 = 120.
   

4. Integer numbers
   We're dealing with integer numbers, since the Boss metronome only allows to configure integer BPMs. Following (3.1), the BPM for a chosen note in a given rhythm is constrained: The BPM, multiplied by the musical duration of the chosen note, needs to be divisible by the musical durations of all other notes. So we need to solve the following integer mathematics problem:

   (4.1) find a minimal integer i, that, multiplied with a given integer d, is integer divisible by integers b, c.

   The lcm task would be: Find a minimal integer i', so that it's integer divisible by a set of given integers b, c.
   If i' is divisible by b, c, then certainly so is i'*d. However, if d shares divisors with i', then i may be less than i', hence less than lcm(b, c). Finding the divisors of d and i' is gcd's job:

   

   Expand the fraction with d:

   
   

   Using fact we get:

   
   

   Reducing the fraction by , then substituting i', finally using fact we get:

   
   

   Since we made the substitution , the method applies to any number of durations {b, c, e, f, ...}, not just two {b, c} as in the proof. Thus, finally:

   (4.2) The BPM we choose for a particular musical note duration d needs to be integer divisible by the increment i = lcm(all durations including d)/d.