Boss Dr.Beat DB-88

Arbitrary Rhythm Patterns Using The Boss Dr.Beat DB-88 Metronome

Boss Dr.Beat DB-88 Features

Additionally, a "LOOP" mode is available which allows to chain programs together. It has the limitation that it can only play programs 1 - 8 in that order. You can have a program played from 0 to several times, though.

Arbitrary Rhythm Patterns

I use Eddie Harris' "Ambidextrous" riff () to demonstrate the procedure:

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), or graphically, black squares representing onsets:

2. Choose one of the durations identified in the previous step (example: I choose 4).
3. Assign the chosen duration a tempo that is 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 divisible by lcm(3,4,5)/3, i.e. 20. If you chose 4, the tempo should be divisible by lcm(3,4,5)/4, i.e. 15. Finally, if you chose 5, the tempo should be 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 divisible by lcm(3,4,5)/4, i.e. 15)
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).

   program	duration (16ths)	tempo (BPM)	increment
   1	3	120	20
   2	4	90	15
   3	5	72	12
   4	4	90	15

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 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".

Limitations

• Tempos need to be divisible by the distinct durations, thus limiting the choice.
• A program can only be reused if the same duration between onsets occurs adjacently, i.e. in Eddie Harris' "Ambidextrous" example above, the duration 4 occurs twice, but the corresponding program can't be reused because the two 4-durations are not adjacent in the rhyhtm 3-4-5-4.
• Corollary: If all adjacent durations between onsets differ, a pattern with a maximum of 8 onsets can be obtained.

Todo

• This method is not limited to 16th note patterns. It is equally applicable to tuplets.
• Add a javascript program or applet that allows entering durations and tempos at will, constantly updating the tempos of the remaining durations.

You might need to install MathPlayer fort the formulas to display in Internet Explorer.

I use a different example (2, 3, 4) for onset durations than above (3, 4, 5, 4), because in the above example all 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 speed of 120 BPM, we look for 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: 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, so there is a rule how to choose the BPM:
   The BPM we choose for a particular note needs to be divisible by all musical durations except the one we're assigning the BPMs to. (5.1)
   In the example above the BPM we chose for the note of duration 4 needs to be divisible by 2 and 3, thus 6. lcm(2,3) = 6.

   Ouch, here's a counter example:
   I can choose 27 for the last note which according to above text should be divisible by 2 and 3, thus 6.
   Obviously 27 is not divisible by 2. But I can still create numbers in the relationship 2:3:4:
   54 36 27

   BPM(first note) = 27 * md(chosen note) / md(first note) = 27 * 4 / 2 = 54.
   BPM(second note) = 27 * md(chosen note) / md(second note) = 27 * 4 / 3 = 36.
   BPM(chosen note) = 27 * md(chosen note) / md(chosen note) = 27 * 4 / 4 = 27.
   

   The reason is that the BPMs will be multiplied with the duration of the chosen note. Since it is a multiplication it can only increase, never decrease the probability that a certain duration can integer divide the resulting number.

   So let's correct statement (5.1), thus weakening the constraint:
   The BPM we choose for a particular note, multiplied by its duration, needs to be divisible by all other musical durations. (5.2)

   How to rephrase this more compactly to get a tighter mathematical grip?
   Choose a minimal number so that when you multiply it with a given number a it is divisible by a set of some other given numbers?
   The lcm task would be: Choose a minimal number so that it is divisible by a set of given numbers.
   So the lcm task is too constrained, how can we loosen it?

   Proposition:

   Proof:

   Substitution:

   // well known, proven fact

   Since we made the substition , the proof would apply to any number of durations (b, c, d, ...), not just two (b, c) as in the proof.