[LAU] [OT] Textual explanation of dx7 algorithms

[Sean Bolton]

Hi Julien!

On Mar 19, 2011, at 11:05 AM, Julien Claassen wrote:
>   I'm looking for a completely textual (no even ascii art0  
> representation of the DX7 algorithms. I've search the web a bit and  
> the best I found was one of those ASCII art representations, but I  
> couldn't get much sense out of them. so does anyone know, or for  
> their wn convenience have, such an overview of the algorithms?

Attached below is the best I have at the moment. It's C code, out of  
the hexter sources, but cleaned up a bit.

Each of the six operators are represented by functions, car() for  
carriers and mod() for modulators.  The first argument to these  
functions is the operator number, here OP_1 to OP_6.  The second  
argument to these functions is the modulation source, usually either  
0, or another operator as a mod() function.

The output of each algorithm is defined as the sum of one to six  
carrier functions.  Stacks of modulators appear as nested second  
arguments.

Each algorithm will also have one function, either car_sfb() or  
mod_sfb() -- this is the operator that is the source of feedback.   
The destination of the feedback appears as 'feedback' in an  
operator's second argument.  With only a few exceptions, the source  
and destination of feedback will be the same operator.

Also, in some algorithms, one operator serves as modulator to more  
than one carrier.  In these cases, the output of the modulator is  
saved in the temporary variable 'i', which then appears in the second  
(modulation) argument of the carrier functions.

Hopefully this is useful to you,

-Sean

algorithm 1:

         output = (
               car(OP_3, mod(OP_4, mod(OP_5, mod_sfb(OP_6,  
feedback)))) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 2:

         output = (
               car(OP_3, mod(OP_4, mod(OP_5, mod(OP_6, 0)))) +
               car(OP_1, mod_sfb(OP_2, feedback))
              );

algorithm 3:

         output = (
               car(OP_4, mod(OP_5, mod_sfb(OP_6, feedback))) +
               car(OP_1, mod(OP_2, mod(OP_3, 0)))
              );

algorithm 4:

         output = (
               car_sfb(OP_4, mod(OP_5, mod(OP_6, feedback))) +
               car(OP_1, mod(OP_2, mod(OP_3, 0)))
              );

algorithm 5:

         output = (
               car(OP_5, mod_sfb(OP_6, feedback)) +
               car(OP_3, mod(OP_4, 0)) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 6:

         output = (
               car_sfb(OP_5, mod(OP_6, feedback)) +
               car(OP_3, mod(OP_4, 0)) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 7:

         output = (
               car(OP_3, mod(OP_5, mod_sfb(OP_6, feedback)) +
                 mod(OP_4, 0)) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 8:

         output = (
               car(OP_3, mod(OP_5, mod(OP_6, 0)) +
                 mod_sfb(OP_4, feedback)) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 9:

         output = (
               car(OP_3, mod(OP_5, mod(OP_6, 0)) +
                 mod(OP_4, 0)) +
               car(OP_1, mod_sfb(OP_2, feedback))
              );

algorithm 10:

         output = (
               car(OP_4, mod(OP_6, 0) +
                 mod(OP_5, 0)) +
               car(OP_1, mod(OP_2, mod_sfb(OP_3, feedback)))
              );

algorithm 11:

         output = (
               car(OP_4, mod_sfb(OP_6, feedback) +
                 mod(OP_5, 0)) +
               car(OP_1, mod(OP_2, mod(OP_3, 0)))
              );

algorithm 12:

         output = (
               car(OP_3, mod(OP_6, 0) +
                 mod(OP_5, 0) +
                 mod(OP_4, 0)) +
               car(OP_1, mod_sfb(OP_2, feedback))
              );

algorithm 13:

         output = (
               car(OP_3, mod_sfb(OP_6, feedback) +
                 mod(OP_5, 0) +
                 mod(OP_4, 0)) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 14:

         output = (
               car(OP_3, mod(OP_4, mod_sfb(OP_6, feedback) +
                       mod(OP_5, 0))) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 15:

         output = (
               car(OP_3, mod(OP_4, mod(OP_6, 0) +
                       mod(OP_5, 0))) +
               car(OP_1, mod_sfb(OP_2, feedback))
              );

algorithm 16:

         output = car(OP_1, mod(OP_5, mod_sfb(OP_6, feedback)) +
                    mod(OP_3, mod(OP_4, 0)) +
                    mod(OP_2, 0));

algorithm 17:

         output = car(OP_1, mod(OP_5, mod(OP_6, 0)) +
                    mod(OP_3, mod(OP_4, 0)) +
                    mod_sfb(OP_2, feedback));

algorithm 18:

         output = car(OP_1, mod(OP_4, mod(OP_5, mod(OP_6, 0))) +
                    mod_sfb(OP_3, feedback) +
                    mod(OP_2, 0));

algorithm 19:

         i = mod_sfb(OP_6, feedback);
         output = (
               car(OP_5, i) +
               car(OP_4, i) +
               car(OP_1, mod(OP_2, mod(OP_3, 0)))
              );

algorithm 20:

         i = mod_sfb(OP_3, feedback);
         output = (
               car(OP_4, mod(OP_6, 0) +
                 mod(OP_5, 0)) +
               car(OP_2, i) +
               car(OP_1, i)
              );

algorithm 21:

         i = mod(OP_6, 0);
         output = car(OP_5, i) +
              car(OP_4, i);
         i = mod_sfb(OP_3, feedback);
         output += car(OP_2, i) +
               car(OP_1, i);

algorithm 22:

         i = mod_sfb(OP_6, feedback);
         output = (
               car(OP_5, i) +
               car(OP_4, i) +
               car(OP_3, i) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 23:

         i = mod_sfb(OP_6, feedback);
         output = (
               car(OP_5, i) +
               car(OP_4, i) +
               car(OP_2, mod(OP_3, 0)) +
               car(OP_1, 0)
              );

algorithm 24:

         i = mod_sfb(OP_6, feedback);
         output = (
               car(OP_5, i) +
               car(OP_4, i) +
               car(OP_3, i) +
               car(OP_2, 0) +
               car(OP_1, 0)
              );

algorithm 25:

         i = mod_sfb(OP_6, feedback);
         output = (
               car(OP_5, i) +
               car(OP_4, i) +
               car(OP_3, 0) +
               car(OP_2, 0) +
               car(OP_1, 0)
              );

algorithm 26:

         output = (
               car(OP_4, mod_sfb(OP_6, feedback) +
                 mod(OP_5, 0)) +
               car(OP_2, mod(OP_3, 0)) +
               car(OP_1, 0)
              );

algorithm 27:

         output = (
               car(OP_4, mod(OP_6, 0) +
                 mod(OP_5, 0)) +
               car(OP_2, mod_sfb(OP_3, feedback)) +
               car(OP_1, 0)
              );

algorithm 28:

         output = (
               car(OP_6, 0) +
               car(OP_3, mod(OP_4, mod_sfb(OP_5, feedback))) +
               car(OP_1, mod(OP_2, 0))
              );

algorithm 29:

         output = (
               car(OP_5, mod_sfb(OP_6, feedback)) +
               car(OP_3, mod(OP_4, 0)) +
               car(OP_2, 0) +
               car(OP_1, 0)
              );

algorithm 30:

         output = (
               car(OP_6, 0) +
               car(OP_3, mod(OP_4, mod_sfb(OP_5, feedback))) +
               car(OP_2, 0) +
               car(OP_1, 0)
              );

algorithm 31:

         output = (
               car(OP_5, mod_sfb(OP_6, feedback)) +
               car(OP_4, 0) +
               car(OP_3, 0) +
               car(OP_2, 0) +
               car(OP_1, 0)
              );

algorithm 32:

         output = (
               car_sfb(OP_6, feedback) +
               car(OP_5, 0) +
               car(OP_4, 0) +
               car(OP_3, 0) +
               car(OP_2, 0) +
               car(OP_1, 0)
              );