Opcodes de tableaux
Précédent | Opérations mathématiques | Suivant

## Opcodes de tableaux

Opcodes de tableaux

Liste des opcodes de tableaux (6.12) :

- init initialise un tableau

- fillarray remplit un tableau avec des valeurs

- genarray crée un tableau à partir d'une suite arithmétique

- = crée ou réinitialise un tableau à partir d'un autre tableau

- slicearray prend une partie d'un tableau

- maparray applique une fonction à un tableau

- scalearray pondère les valeurs d'un tableau

- sorta tri un tableau par ordre ascendant

- sortd tri un tableau par ordre descendant

- limit et limit1 limite les valeurs d'un tableau

- reshapearray change les dimensions d'un tableau

- trim ajuste la taille d'un tableau unidimensionnel

- copya2ftab copie un tableau dans une table de fonction

- copyf2array copie une table de fonction dans un tableau

- tab2array copie une partie d'une table de fonction dans un tableau

- dot calcule le produit scalaire de deux tableaux

- interleave entrelace deux tableaux dans un seul

- deinterleave désentrelace un tableau dans deux tableaux

- getrow retourne une ligne d'un tableau bidimensionnel

- getcol retourne une colonne d'un tableau bidimensionnel

- setrow remplit une ligne d'un tableau bidimensionnel

- setcol remplit une colonne d'un tableau bidimensionnel

- lenarray retourne la longueur d'un tableau

- minarray retourne la valeur minimale d'un tableau

- maxarray retourne la valeur maximale d'un tableau

- sumarray retourne la somme des valeurs d'un tableau

- cmp compare deux tableaux

- printarray affiche un tableau

- les fonctions unaires ceil, floor, round, int, frac, powoftwo, abs, log2, log10, log, exp, sqrt, cos, sin, tan, cosinv, sininv, taninv, sinh, cosh, tanh, cbrt, limit1 et les fonctions binaires taninv2, pow, hypot, fmod, fmax, fmin acceptent des tableaux en entrée.

Certaines instructions pour travailler avec des tableaux dans Csound (voir aussi le chapître array dans le Csound FLOSS Manual:)

## Nom de variable

Un tableau doit être créé (via init ou fillarray) sous la forme kNomTableau suivi de crochets. Les crochets déterminent les dimensions du tableau. Ainsi,

    kArr[] init 10

crée un tableau unidimensionnel (un vecteur) de longueur 10, tandis que

    kArr[][] init 10, 10

crée un tableau à deux dimensions avec 10 lignes et 10 colonnes.

Après l'initialisation du tableau, on y fait référence comme un tout sans les crochets. Les crochets ne sont utilisés que pour indexer un élément :

    kArr[]   init 10             ;with brackets because of initialization
    kLen     = lenarray(kArr)    ;without brackets
    kFirstEl = kArr[0]           ;indexing with brackets

On utilise la même syntaxe pour une simple copie via l'opérateur '=' :

    kArr1[] fillarray 1, 2, 3, 4, 5
    kArr2[] = kArr1              ;creates kArr2 as copy of kArr1

## k-rate

Noter que la plupart des opérations sur les tableaux ne se font actuellement qu'au taux-k. Ainsi, comme pour tout autre opcode de taux-k, une opération sur les tableaux sera automatiquement répétée à chaque cycle-k. Par exemple, le code suivant réécrit le tableau avec différentes valeurs aléatoires à chaque cycle-k, tant que l'instrument est actif :

    kArr[] init 10
    kIndx  = 0
    until kIndx == lenarray(kArr) do
      kArr[kIndx] rnd31 10, 0
      kIndx += 1
    od

Pour éviter cela, on doit l'organiser de la manière habituelle, par exemple en utilisant un déclencheur :

    kArr[] init 10
    kTrig metro 1
    if kTrig == 1 then ;do the following once a second
      kIndx  = 0
      until kIndx == lenarray(kArr) do
        kArr[kIndx] rnd31 10, 0
        kIndx += 1
      od
    endif

## Création/initialisation

La manière habituelle de créer un tableau est d'utiliser init :

    kArr[]   init 10     ;creates one-dimensional array with length 10
    kArr[][] init 10, 10 ;creates two-dimensional array

On peut aussi créer un tableau unidimensionnel et le remplir de valeurs distinctes au moyen de l'opcode fillarray. La ligne suivante crée un vecteur de longueur 4 et le remplit avec les nombres [1, 2, 3, 4]:

    kArr[] fillarray 1, 2, 3, 4

## Longueur

La fonction lenarray(kArr) retourne la longueur d'un tableau. Voir l'exemple pour la fonction lenarray.

## Copie d'un tableau vers ou d'une table

    copyf2array kArr, kfn

copie les données d'une table de fonction dans un vecteur.

    copya2ftab kArr, kfn

copie les données d'un vecteur dans une table de fonction.

Voir les exemples pour les opcodes copyf2array and copya2ftab.

## Opérations sur les tableaux : maths

### +, -, *, / avec un nombre

Si les quatre opérateurs de base sont utilisés entre un tableau et un nombre scalaire, l'opération est appliquée à chaque élément. La manière la plus sûre de le faire est de stocker le résultat dans un nouveau tableau :

    kArr1[] fillarray 1, 2, 3
    kArr2[] = kArr1 + 10    ;(kArr2 is now [11, 12, 13])

Voici un exemple des opérations tableau/scalaire. Il utilise le fichier array_scalar_math.csd.

Exemple 3. Exemple des opérations tableau/scalaire

    <CsoundSynthesizer>
    <CsOptions>
    -n -m128
    </CsOptions>
    <CsInstruments>

      instr 1

    ;create array and fill with numbers 1..10
    kArr1[] fillarray 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

    ;print content
            printf  "%s", 1, "\nInitial content:\n"
    kndx    =       0
      until kndx == lenarray(kArr1) do
            printf  "kArr[%d] = %f\n", kndx+1, kndx, kArr1[kndx]
    kndx    +=      1
      od

    ;add 10
    kArr2[] =       kArr1 + 10

    ;print content
            printf  "%s", 1, "\nAfter adding 10:\n"
    kndx    =       0
      until kndx == lenarray(kArr2) do
            printf  "kArr[%d] = %f\n", kndx+1, kndx, kArr2[kndx]
    kndx    +=      1
      od

    ;subtract 5
    kArr3[] =       kArr2 - 5

    ;print content
            printf  "%s", 1, "\nAfter subtracting 5:\n"
    kndx    =       0
      until kndx == lenarray(kArr3) do
            printf  "kArr[%d] = %f\n", kndx+1, kndx, kArr3[kndx]
    kndx    +=      1
      od

    ;multiply by -1.5
    kArr4[] =       kArr3 * -1.5

    ;print content
            printf  "%s", 1, "\nAfter multiplying by -1.5:\n"
    kndx    =       0
      until kndx == lenarray(kArr4) do
            printf  "kArr[%d] = %f\n", kndx+1, kndx, kArr4[kndx]
    kndx    +=      1
      od

    ;divide by -3/2
    kArr5[] =       kArr4 / -(3/2)

    ;print content
            printf  "%s", 1, "\nAfter dividing by -3/2:\n"
    kndx    =       0
      until kndx == lenarray(kArr5) do
            printf  "kArr[%d] = %f\n", kndx+1, kndx, kArr5[kndx]
    kndx    +=      1
      od

    ;turnoff
            turnoff
      endin

    </CsInstruments>
    <CsScore>
    i 1 0 .1
    </CsScore>
    </CsoundSynthesizer>

### +, -, *, / avec un autre tableau

Si les quatre opérateurs de base sont utilisés entre deux tableaux, l'opération est appliquée élément à élément. Le résultat peut être stocké directement dans un nouveau tableau :

    kArr1[] fillarray 1, 2, 3
    kArr2[] fillarray 10, 20, 30
    kArr3[] = kArr1 + kArr2    ;(kArr3 is now [11, 22, 33])

Voici un exemple des opérations de tableau. Il utilise le fichier array_array_math.csd.

Exemple 4. Exemple des opérations de tableau

    <CsoundSynthesizer>
    <CsOptions>
    -n -m128
    </CsOptions>
    <CsInstruments>

      instr 1

    ;create array and fill with numbers 1..10 resp .1..1
    kArr1[] fillarray 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    kArr2[] fillarray 1, 2, 3, 5, 8, 13, 21, 34, 55, 89

    ;print contents
            printf  "%s", 1, "\nkArr1:\n"
    kndx    =       0
      until kndx == lenarray(kArr1) do
            printf  "kArr1[%d] = %f\n", kndx+1, kndx, kArr1[kndx]
    kndx    +=      1
      od
            printf  "%s", 1, "\nkArr2:\n"
    kndx    =       0
      until kndx == lenarray(kArr2) do
            printf  "kArr2[%d] = %f\n", kndx+1, kndx, kArr2[kndx]
    kndx    +=      1
      od

    ;add arrays
    kArr3[] =       kArr1 + kArr2

    ;print content
            printf  "%s", 1, "\nkArr1 + kArr2:\n"
    kndx    =       0
      until kndx == lenarray(kArr3) do
            printf  "kArr3[%d] = %f\n", kndx+1, kndx, kArr3[kndx]
    kndx    +=      1
      od

    ;subtract arrays
    kArr4[] =       kArr1 - kArr2

    ;print content
            printf  "%s", 1, "\nkArr1 - kArr2:\n"
    kndx    =       0
      until kndx == lenarray(kArr4) do
            printf  "kArr4[%d] = %f\n", kndx+1, kndx, kArr4[kndx]
    kndx    +=      1
      od

    ;multiply arrays
    kArr5[] =       kArr1 * kArr2

    ;print content
            printf  "%s", 1, "\nkArr1 * kArr2:\n"
    kndx    =       0
      until kndx == lenarray(kArr5) do
            printf  "kArr5[%d] = %f\n", kndx+1, kndx, kArr5[kndx]
    kndx += 1
      od

    ;divide arrays
    kArr6[] =       kArr1 / kArr2

    ;print content
            printf  "%s", 1, "\nkArr1 / kArr2:\n"
    kndx    =       0
      until kndx == lenarray(kArr6) do
            printf  "kArr5[%d] = %f\n", kndx+1, kndx, kArr6[kndx]
    kndx += 1
      od

    ;turnoff
            turnoff

      endin

    </CsInstruments>
    <CsScore>
    i 1 0 .1
    </CsScore>
    </CsoundSynthesizer>

## Application d'une fonction à un tableau

    kArrRes maparray kArrSrc, "fun"

applique la fonction de taux-k à un argument, définie dans la chaîne de caractères, à chaque élément du vecteur.

Les fonctions utilisables sont par exemple abs, ceil, exp, floor, frac, int, log, log10, round, sqrt. Voici un simple exemple :

    kArrSrc[] fillarray 1, 2, 3, 4, 5
    kArrRes[] init      5
    kArrRes   maparray  kArrSrc, "sqrt"

Voir l'exemple pour l'opcode maparray.

## Opérations sur les tableaux : min, max, sum, scale, slice

### Minimum et maximum

      kMin [,kMinIndx] minarray kArr

retourne la plus petite valeur d'un tableau et facultativement son indice.

      kMax [,kMaxIndx] maxarray kArr

retourne la plus grande valeur d'un tableau et facultativement son indice. Voir les exemples pour les opcodes minarray and maxarray.

### Somme

      kSum sumarray kArr

retourne la somme de toutes les valeurs dans kArr. Voir l'exemple pour l'opcode sumarray.

### Pondération

      scalearray kArr, kMin, kMax

pondère toutes les valeurs dans kArr entre kMin et kMax.

      kArr[] fillarray  1, 3, 9, 5, 6
             scalearray kArr, 1, 3

change kArr en [1, 1.5, 3, 2, 2.25]. Voir l'exemple pour l'opcode scalearray.

### Extrait

      slicearray kArr, iStart, iEnd

retourne un extrait de kArr compris entre l'indice iStart et l'indice iEnd (inclus).

Il faut créer le tableau de destination de l'extrait par avance :

      kArr[]  fillarray  1, 2, 3, 4, 5, 6, 7, 8, 9
      kArr1[] init       5
      kArr2[] init       4
      kArr1   slicearray kArr, 0, 4        ;[1, 2, 3, 4, 5]
      kArr2   slicearray kArr, 5, 8        ;[6, 7, 8, 9]

Voir l'exemple pour l'opcode slicearray.

### Reformatage

utiliser reshapearray pour changer le format d'un tableau sans modifier sa capacité (changer 1D en 2D et vice-versa). Voir l'exemple de l'opcode reshapearray.

## Tableaux dans un UDO

La dimension d'un tableau en entrée doit être déclarée en deux endroits :

- comme k[] ou k[][] dans la liste des types en entrée
- comme kNom[], kNom[][] etc dans la liste xin.

Par exemple :

    opcode FirstEl, k, k[]
    ;returns the first element of vector kArr
    kArr[] xin
           xout   kArr[0]
    endop

Voici un exemple d'un tableau dans un UDO. Il utilise le fichier array_udo.csd.

Exemple 5. Exemple d'un tableau dans un UDO

    <CsoundSynthesizer>
    <CsOptions>
    -nm128
    </CsOptions>
    <CsInstruments>

      opcode FirstEl, k, k[]
      ;returns the first element of vector kArr
    kArr[] xin
    xout kArr[0]
      endop

      instr 1
    kArr[] fillarray 6, 3, 9, 5, 1
    kFirst FirstEl kArr
    printf "kFirst = %d\n", 1, kFirst
    turnoff
      endin

    </CsInstruments>
    <CsScore>
    i 1 0 .1
    </CsScore>
    </CsoundSynthesizer>

A noter que si un opcode (par exemple inrg) modifie les arguments de la liste d'arguments sur sa droite, on ne doit pas utiliser un élément de tableau indicé dans cette liste. Contrairement au variables normales, les tableaux ne sont pas changés par les opcodes.

## Crédits

Cette page du manuel a été écrite par Joachim Heintz.
Juillet 2013

Nouveau dans Csound 6.00

Précédent | Niveau supérieur | Suivant
Opcodes d'algèbre linéaire | Sommaire | Conversion des hauteurs