Notas sobre los Makegens

por R. Luke DuBois, con algun juicioso plagio a Chris Bailey y Brad Garton.

Algunas notas generales y otras cositas:

makegens son seguido una fuente de confusion en el mundo maravilloso de cmix. Basicamente, son arreglos de numeros que estan dibujados en la memoria, para ser utilizados por los instrumentos de cmix. makegens pueden contener curvas de amplitud, descriptores de formas de onda, datos definidos por el usuario, o justamente acerca de cualquiercosa. Hay un cierto numero de makegens pre-definidos, asi como un makegen que puede leer datos de un archivo de sonidos de entrada o desde una partitura de cmix.

La sintaxis basica para cada uno de los makegen es:

makegen(slot,gen_routine,size,gen_args.........)

slot es determinado por la funcion makegen en el instrumento particular (por ejemplo, cualquiera sea el makegen asignado a la puerta 1 (slot) en una partitura wavetable determina la forma de onda de las notas que lo siguen.). Algunos instrumentos estan fuertemente-conectados para buscar datos especificos en puertas especificas de makegens, este usted o no explicitamente solicitado de declararlas. Las paginas del manual para cada instrumento deben cubrir esta informacion. Este numero es comunmente llamado el numero de generador local.

gen_routine es el tipo de makegen, como descripto abajo.

size es el numero determinado de elementos para el arreglo en el cual makegen pondra sus datos. Mas grande es el arreglo y mas precision se tendra (esto es especialmente verdadero con los makegens que dibujan espectros, por ejemplo).

gen_args son los argumentos para makegen, y estan en un formato determinado por el numero de la rutina_gen.

Una funcion muy util para usar es fplot(slot), donde cmix dibujara sobre el terminal el arreglo definido en el makegen que llena esa puerta.

Gen 2


gen2, el cual es en cierto sentido el mas simple makegen, rellena un arreglo con numeros especificados por el usuario que pueden ser accedidos luego por intermedio de la llamada a sampfunc().

la sintaxis es:

makegen(slot, 2, size, filenumber)

size se refiere al tamaño del arreglo que usted quiere rellenar. filenumber es un numero descriptor de archivo de cmix que se refiere sea al archivo abierto por infile() o, si vale 0, o los numeros ingresados con la linea siguiente.

ejemplo:

makegen(1, 2, 8, 0)
4.3 6.2 60.0 0.3 5.9 7.5 0.24 3.0

note=sampfunc(1,0)

esto quiere decir que los ocho valores que aparecen en la linea siguiente a makegen seran leidas hacia la puerta 1 de gen. El primer valor (0th) en makegen es entonces asignado a la nota variable.

otro ejemplo:


infile("../data/start_times", 3)

makegen(1, 2, 50, 3)
esto abre el archivo "../data/start_times" como archivo de cmix numero 3 y entonces carga los primeros 50 valores del archivo en la puerta 1 de gen.

Gen 5


gen5 dibuja segmentos de linea exponenciales usando la sintaxis de una funcion bpf (break-point-function)(determinada por puntos).
La sintaxis es:

makegen(slot, 5, size, y1, n_locs, y2, n_locs... yn)

este gen toma su primer valor del valor encontrado en y1, despues interpola sobre el numero de puntos determinado por el proximo argumento (p_field) al valor encontrado en y2, asi, hasta encontrar un ultimo valor de y. Notese que la suma de todos los segmentos de linea especificados en los campos n_locs deben sumar hasta el tamaño de gen.

ejemplos:

makegen(2, 5, 1000, 0.1, 500, 1, 500, 0.1)

esto crea una curva que comienza en 0.1, crece exponencialmente a travez de 500 puntos a 1, y despues decae tambien sobre 500 puntos a 0.1. este gen es asignado despues a la puerta 2:

1                                       ---\
                                       /    \
                                     -/      --\
                                  --/           -\
                                -/                -\
                            ---/                    ---\
                         --/                            --\
                    ----/                                  ----\
             ------/                                            ------\
  ----------/                                                          ----------
0 -------------------------------------------------------------------------------

makegen(2, 5, 1000, 0.1, 50, 1, 50, .8, 600, .8, 300, 0.1)

Esto crea una curva estandard ADSR con un ataque de 50 puntos (hasta una altura de 1), un decadencia de 50 puntos (hasta .8), un estado estable de 600 punots, y despues otra decadencia a 0 a travez de 300 puntos.

notese: fplot() no funcionara bien con gen5, debido a la naturaleza de la curva de bpf (un terminal ascii grafico puede realmente solo estimar lineas curvas).

1     \
       \
     |  -\
     |    ------------------------------------------------\
     |                                                     \
     /                                                      -\
    |                                                         -\
    |                                                           --\
    /                                                              --\
   |                                                                  ----\
  -/                                                                       ------
0 -------------------------------------------------------------------------------

Nota: a causa de la naturaleza exponencial de las curvas, el uso de un valor absoluto de 0 en gen5 causara resultados extraños, ya que una curva exponencial nunca interpolara nada correctamente con nada (0).

Gen 7


gen7 traza una serie de segmentos de linea conectados usando la sintaxis de bpf, usando una interpolacion lineal (opuestamente a lo exponencial).

la sintaxis es identica a la de gen5, solo que los segmentos que conectan los valores de y son lineas rectas.

ejemplos:

makegen(2, 5, 1000, 0, 500, 1, 500, 0)

lo mismo que en el primer ejemplo en gen5, solo que con lineas curvas (notese que valores 0 pueden ser usados):
1                                     -------\
                                   --/        --\
                               ---/              ---\
                            --/                      --\
                        ---/                            ---\
                     --/                                    ---\
                 ---/                                           --\
             ---/                                                  ---\
          --/                                                          --\
      ---/                                                                ---\
0 -------------------------------------------------------------------------------
makegen(1, 7, 1000, 0, 1, 1, 498, 1, 1, 0, 1, -1, 498, -1, 1, 0)

esto dibuja una onda cuadrada en la puerta 1 del gen. notese que los todos los valores n_locs se suman hasta el llegar a la dimension total del arreglo:
1  --------------------------------------\
  |                                      | 
  |                                      |
  |                                      |
  |                                      |
  |                                      |
  |                                      |
  |                                      |
  |                                      |
  |                                      |
  |                                      |
0 -------------------------------------------------------------------------------
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
                                         |                                      |
-1                                        --------------------------------------/

Gen 9


gen9 dibuja una forma de onda que puede estar construida con parciales de amplitudes diferentes, valores de fase, y proporciones de armonicos de la fundamental.

la sintaxis es:

makegen(slot, 9, size, harmonic1, amplitude1, phase1, harmonic2, amplitude2, phase2... etc.)

el valor harmonic refiere el multiplo armonico de la forma de onda fundamental, asumiendo que makegen almacena un ciclo completo de la onda. Asi, un valor 2 dibujara una onda con un periodo mitad del tamaño del makegen (por ejemplo dos veces la frecuencia de la fundamental en terminos relativos), y un valor de .5 dibujara solamente la mitad de una onda seno (ya que un periodo completo estaria afuera de los limites del makegen).

amplitude refiere la amplitud relativa del armonico descripto.

phase refiere la desviacion de fase (en grados) del armonico.

ejemplo:

makegen(1, 9, 1000, 1, 1, 0, 2, .5, 90, 3.2, .3, 0)

esto dibuja una forma de onda con una amplitud fundamental 1 sin desplazamiento de fase, y dos parciales, el primero de los cuales es armonico (un multiplo par), con amplitud .5 y 90 grados fuera de fase, y el segundo de los cuales es inarmonico (3.2 veces la frecuencia fundamental) con amplitud .3, y en fase con la fundamental:
1


 
      -----\                   -----\
     /      \                 /      \
    /        -\             -/        \
   /           \           /           \                                        /
  /             \        -/             -\                                     /
                 -\     /                |                                    /
                   ----/                  \                                  /
0 -------------------------------------------------------------------------------
                                            \                               /
                                             -\                            /
                                               \                          |
                                                \                         /
                                                 -\                      |
                                                   --\                   /
                                                      -\                /
                                                        -\             /
                                                          -\          /
                                                            -\       /
-1                                                            ------/

Gen 10


gen10 dibuja una forma de onda restringida a parciales armonicos de amplitudes diferentes.

makegen(slot, 10, size, amp1, amp2... ampn)

los campos amp correponden a las amplitudes relativas de los parciales de la forma de onda.

ejemplo:

makegen(1, 10, 1000, 1)

dibuja una simple onda seno en la puerta gen 1:
1                ----------\
               -/           -\
             -/               -\
           -/                   \
          /                      -\
         /                         \
       -/                           \
      /                              -\
     /                                 \
    /                                   \
0 -------------------------------------------------------------------------------
                                          \                                     -
                                           \                                   /
                                            \                                 /
                                             -\                              /
                                               \                            /
                                                \                         -/
                                                 -\                      /
                                                   \                   -/
                                                    -\               -/
                                                      -\           -/
-1                                                      ----------/

makegen(1, 10, 1000, 1, .5, .3, .2)

dibuja una forma de onda donde la fundamental tiene una amplitud 1, y los susecivos tienen amplitudes .5, .3, y .2, respectivamente:
1       -----\
       /      \
      |        \
      /         -\
     /            \
    |              -------\
    /                      --\
   |                          -\
   /                            -\
  |                               --\
0 -------------------------------------------------------------------------------
                                          -----\
                                                -\                              |
                                                  -\                            /
                                                    -\                         |
                                                      ---\                     /
                                                          ------\             |
                                                                 \            /
                                                                  -\         /
                                                                    \       |
                                                                     -\     /
-1                                                                     ----/

Gen 17


gen17 resuelve un polinomio de chebyshev y lo dibuja en la puerta del gen. este gen es util para transferir funciones como las usadas en waveshaping (modelacion de onda).


sintaxis:

makegen(slot, 17, size, index, harm1... harmn)

donde index es el numero indice del polinomio a ser resuelto, y los argumentos sucesivos definen los armonicos para la funcion.

ejemplo:

makegen(3, 17, 1000, 0.9, 0.3, -0.2, 0.6, -0.7)

resuelve un polinomio de chebyshev con un indice de 0.9 y tres armonicos, dibujando la siguiente funcion y poniendola en la puerta 3 del gen:
1                 ---\
                 /    -\
                /       \
               /         -\
              /            \
             |              \                                        --\
             /               \                                    --/   -\
            |                 \                                  /        \
            /                  \                               -/          \
           |                    \                             /            |
           |                     \                           /              \
0 -------------------------------------------------------------------------------
          |                        \                       /                 |
          |                         \                    -/                  |
          /                          \                  /                     \
         |                            \                /                      |
         |                             -\            -/                        \
         /                               -\        -/                          |
        |                                  -------/                            |
        |                                                                       \
        |                                                                       |
        |                                                                       |
-1      /

Gen 20


gen 20 rellena un gen con numeros aleatorios comprendidos entre 0 y 1 de acuerdo con uno de los 6 algoritmos diferentes de distribucion aleatoria..

sintaxis:

makegen(slot, 20, size, algorithm)

los algoritmos posibles son: 0 (distribucion equilibrada), 1 (distribucion lineal ponderada baja), 2 (distribucion lineal ponderada alta), 3 (distribucion triangular ponderada hacia 0.5), 4 (distribucion gaussiana con media 0.5 y desviacion estandard .166666), y 5 (distribucion de cauchy con una media de 0.5 y un alfa de .00628338).

ejemplo:

makegen(1, 20, 1000, 0)

rellena un makegen con 1000 puntos aleatorios con una distribucion del tipo equilibrado (evenly):
1 
              \        \          \ -\ \  -\                      \          \
             ||     \ ||    \    | / ||| | |    \                ||       \ ||
             ||    || | \  /|   \|   || \| | \ ||    \           /| \ \  | \||
            \||    || | | | |  |||   || || ||| || \ ||  \       | |||||  | |||
  \ \      ||||    || / | | | -/||   || || ||| /||| || ||       | |||| -\| |||  \
  |||      ||| -\  |||   \| ||   /   ||  /  /|| || \|| | --\    | ||||  || ||| |
  |||  \  \| /  |  |||   || ||       ||      || || ||| |    \   / ||||  || ||| |
  || \|| /||     \ | /    / ||       ||      ||  / ||| |    |  /  ||||   / || \|
  || ||||  /     | |        ||       ||       /     /| /    | /   ||||     || ||
   /  / /        | /        ||       ||               /     ||     /||     || ||
1 -------------------------------------------------------------------------------

Gen 20


gen20 rellena un gen con numeros aleatorios de acuerdo con una distribucion de gauss (campana de gauss). El gen tiene dos argumentos para la media y la distribucion estandard.

sintaxis:

makegen(slot, 20, size, mean, standard_deviation)

ejemplo:

makegen(1, 20, 50, 0, 1)

rellena un makegen de 50 puntos con numeros aleatorios con centro alrededor de 0 y con una desviacion estandard de 1 hacia ambos lados:
         |                  |   | -\        |    |    ||    | |   |    | || ||  |
1         -\                |   || |        |    |    ||    | |   |    | || ||  |
           |                |   ||  \       |    | -\ ||    | |   |    | || ||  |
           |                |   ||  |  \    |    || | ||    | |   |    | | -/|  |
           |                |   ||  | ||    |    || | ||    | |   |    | |   |  |
           |                |   ||  | | -\  /    || | ||    | |   |    | |   |  |
           |           -\   |   ||  | |  | |     || | ||    | |   |    | |   |  |
           |          | | -\|   ||  | |  | |     || | ||    | |   |    | |   |  |
           |        \ | || ||   ||  | |  | |     || | ||    | |   |    | |   |  |
           |      -/| | || ||   ||  | |  | |     || | ||   -/ |   |    | |   |  |
           |     |  | |  / ||   ||  | |  | |     || | ||  /    \  /    | |   |  |
0 -------------------------------------------------------------------------------
           |     |  | |             | |  | |     ||    | |      -/     | |   |  |
           |     /   -/             | |  | |     ||    | |             | |   |  /
           |    |                   | |  | |     ||    | |             | |   | |
           |    |                   | |  | |      /    | |             | |   | |
           |    |                   | |  | |           | |             | |   | |
           |  \ |                    -/  | |            -/             | |   | |
            -/| |                        | |                           | |   | |
              | |                        | |                           | |   | |
              | |                        | |                           | |    -/
-1            | |                        | |                           | |
               -/                        | |                           | |

-->

Gen 24


gen 24 crea una serie de segmentos de linea conectados usando la sintaxis de setline. En algunos instrumentos, este gen ha sido reemplazado por una llamada a setline().

sintaxis:

makegen(slot, 24, size, time11, amplitude1, time2, amplitude2... etc.)

donde la linea es dibujada en pares ordenados tiempo/amplitud que son reescalados para completar el tamaño del makegen.

ejemplo:

makegen(2, 24, 1000, 0, 0, 1, 1, 9, 1, 10, 0)

crea una envolvente trapezoidal que crece de 0 a 1, queda en 1 por nueve veces el tiempo de crecimiento, y decae hacia 0 en la misma cantidad de tiempo que necesito para crecer:
1         ---------------------------------------------------------------\
         /                                                                \
        /                                                                  \
       |                                                                    \
       /                                                                    |
      /                                                                      \
     /                                                                        \
    |                                                                         |
    /                                                                          \
   /                                                                            \
0 -------------------------------------------------------------------------------

Gen 25


gen25 rellena la puerta de gen sea con una ventana de analisis fft hanning o hamming.

sintaxis:

makegen(slot, 25, size, window_type)

window_type es o 1 (hanning) o 2 (hamming):
1                                 ---------------\
                               --/                --\
                            --/                      --\
                          -/                            -\
                       --/                                --\
                     -/                                      -\
                   -/                                          -\
                --/                                              --\
              -/                                                    -\
          ---/                                                        ---\
0 -------------------------------------------------------------------------------
(hanning window)

1                                 ---------------\
                              ---/                ---\
                            -/                        --\
                         --/                             -\
                      --/                                  --\
                    -/                                        -\
                 --/                                            --\
               -/                                                  --\
           ---/                                                       --\
     -----/                                                              -----\
0 -------------------------------------------------------------------------------
(hamming window - slightly wider)

por supuesto, hay otros makegens, pero muchos de ellos parecen ser redundantes. gen6, por ejemplo, es otra generador de curvas setline, y gen3 lee una serie de numeros desde un archivo.

buena suerte!