Tableaux en

À propos de Tableaux

En Common Lisp, comme dans d'autres langages, un tableau est un ensemble d'éléments auxquels on accède par des indices entiers. Les types des éléments peuvent être hétérogènes. Un tableau peut être multidimensionnel (et pas simplement à une dimension).

Création

make-array permet de créer des tableaux. Elle propose de nombreuses options, mais ses formes les plus simples permettent de créer des tableaux à N dimensions soit en initialisant tous les éléments à une même valeur, soit en initialisant le tableau avec les valeurs d'une autre séquence (comme une liste). Son premier argument est une liste donnant la taille de chaque dimension.

(make-array '(4) :initial-element 3)    ; => #(3 3 3 3)
(make-array '(2 2) :initial-element 'x) ; => #2A((X X) (X X))
(make-array '(3 3 3) 
  :initial-contents '(((a b c) (d e f) (g h i)) 
                      ((j k l) (m n o) (p q r)) 
                      ((s t u) (v w x) (y z &))))
                                        ; => #3A(((A B C) (D E F) (G H I))
                                                 ((J K L) (M N O) (P Q R))
                                                 ((S T U) (V W X) (Y Z &)))

(On remarque que les tableaux à N dimensions sont affichés avec leur nombre de dimensions.)

On peut aussi créer des tableaux en utilisant le même format que celui dans lequel ils sont affichés :

#(x y z)         ; => #(X Y Z)
#2A((1 2) (3 4)) ; => #2A((1 2) (3 4))

Accéder aux éléments

Pour accéder aux éléments d'un vecteur, utilise aref ; les indices commencent à zéro. Le nombre d'indices fournis doit correspondre au rang du tableau.

(aref #2A((1 2 3) (3 4 5)) 1 0) ; => 3
(aref #3A(((a b) (c d)) 
          ((e f) (g h)) 
          ((t u) (v w))) 
      2 0 1)                    ; => U
(aref #2A((1) (2)) 0)           ; => ERROR (because not enough indexes provided)

De plus, les indices fournis doivent être « in bounds » compte tenu des dimensions données lors de la création du tableau. On peut le vérifier avec array-in-bounds-p :

(array-in-bounds-p #2A((1) (2)) 0 0) ; => T
(array-in-bounds-p #2A((1) (2)) 2 0) ; => NIL

On peut aussi accéder à un élément avec row-major-aref, qui prend un seul entier désignant l'élément dans l'ordre row-major. (L'indice row-major peut être calculé à partir des indices avec array-row-major-index.)

(array-row-major-index #2A((1 2 3) (4 5 6)) 1 1 ) ; => 4
(row-major-aref #2A((1 2 3) (4 5 6)) 4)           ; => 5

Prédicat

Pour déterminer si un objet est un tableau, on peut utiliser arrayp.

(arrayp #(1 2 3))            ; => T
(arrayp #2((1 2 3) (4 5 6))) ; => T
(arrayp (list 1 2 3))        ; => NIL

Interroger les tableaux

On peut obtenir diverses informations sur un tableau avec les fonctions suivantes :

• array-rank pour obtenir le nombre de dimensions du tableau (appelé rang du tableau).
• array-dimensions pour obtenir la liste des tailles des dimensions du tableau.
• array-dimension pour obtenir la taille d'une des dimensions.
• array-total-size pour obtenir le nombre total d'éléments du tableau.

(let ((array #3A(((0 1) (2 3) (4 5)) 
                 ((6 7) (8 9) (A B)) 
                 ((C D) (E F) (G H))
                 ((I J) (K L) (M N)))))
  (list (array-rank array)
        (array-dimensions array)
        (array-dimension array 1)
        (array-total-size array))) ; => (3 (4 3 2) 2 24)

Limites de taille des tableaux

La norme Common Lisp définit certaines limites sur la taille maximale des tableaux. Ces limites sont disponibles dans des constantes définies :

• array-rank-limit : le nombre maximal de dimensions autorisé pour un tableau (défini comme étant au moins 8).
• array-dimension-limit : la taille maximale d'une dimension (définie comme étant au moins 1024).
• array-total-size-limit : le nombre maximal d'éléments d'un tableau (défini comme étant au moins 1024).