LISP - Tableaux

LISP vous permet de définir des tableaux à une ou plusieurs dimensions à l'aide du make-arrayfonction. Un tableau peut stocker n'importe quel objet LISP comme ses éléments.

Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse correspond au premier élément et l'adresse la plus élevée au dernier élément.

Le nombre de dimensions d'un tableau s'appelle son rang.

Dans LISP, un élément de tableau est spécifié par une séquence d'indices entiers non négatifs. La longueur de la séquence doit être égale au rang du tableau. L'indexation commence à zéro.

Par exemple, pour créer un tableau avec 10 cellules, nommé my-array, nous pouvons écrire -

(setf my-array (make-array '(10)))

La fonction aref permet d'accéder au contenu des cellules. Il prend deux arguments, le nom du tableau et la valeur d'index.

Par exemple, pour accéder au contenu de la dixième cellule, nous écrivons -

(aref my-array 9)

Exemple 1

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (setf my-array (make-array '(10))))
(terpri)
(setf (aref my-array 0) 25)
(setf (aref my-array 1) 23)
(setf (aref my-array 2) 45)
(setf (aref my-array 3) 10)
(setf (aref my-array 4) 20)
(setf (aref my-array 5) 17)
(setf (aref my-array 6) 25)
(setf (aref my-array 7) 19)
(setf (aref my-array 8) 67)
(setf (aref my-array 9) 30)
(write my-array)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
#(25 23 45 10 20 17 25 19 67 30)

Exemple 2

Créons un tableau 3 par 3.

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(setf x (make-array '(3 3) 
   :initial-contents '((0 1 2 ) (3 4 5) (6 7 8)))
)
(write x)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#2A((0 1 2) (3 4 5) (6 7 8))

Exemple 3

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(setq a (make-array '(4 3)))
(dotimes (i 4)
   (dotimes (j 3)
      (setf (aref a i j) (list i 'x j '= (* i j)))
   )
)
(dotimes (i 4)
   (dotimes (j 3)
      (print (aref a i j))
   )
)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

(0 X 0 = 0) 
(0 X 1 = 0) 
(0 X 2 = 0) 
(1 X 0 = 0) 
(1 X 1 = 1) 
(1 X 2 = 2) 
(2 X 0 = 0) 
(2 X 1 = 2) 
(2 X 2 = 4) 
(3 X 0 = 0) 
(3 X 1 = 3) 
(3 X 2 = 6)

Syntaxe complète pour la fonction make-array

La fonction make-array prend de nombreux autres arguments. Regardons la syntaxe complète de cette fonction -

make-array dimensions :element-type :initial-element :initial-contents :adjustable :fill-pointer  :displaced-to :displaced-index-offset

Hormis l' argument dimensions , tous les autres arguments sont des mots-clés. Le tableau suivant fournit une brève description des arguments.

N ° Sr.	Argument et description
1	dimensions Il donne les dimensions du tableau. C'est un nombre pour un tableau unidimensionnel et une liste pour un tableau multidimensionnel.
2	:element-type C'est le spécificateur de type, la valeur par défaut est T, c'est-à-dire tout type
3	:initial-element Valeur des éléments initiaux. Cela créera un tableau avec tous les éléments initialisés à une valeur particulière.
4	:initial-content Contenu initial comme objet.
5	:adjustable Il aide à créer un vecteur redimensionnable (ou ajustable) dont la mémoire sous-jacente peut être redimensionnée. L'argument est une valeur booléenne indiquant si le tableau est ajustable ou non, la valeur par défaut étant NIL.
6	:fill-pointer Il garde une trace du nombre d'éléments réellement stockés dans un vecteur redimensionnable.
sept	:displaced-to Il aide à créer un tableau déplacé ou un tableau partagé qui partage son contenu avec le tableau spécifié. Les deux tableaux doivent avoir le même type d'élément. L'option: déplacé vers ne peut pas être utilisée avec l'option: initial-element ou: initial-contents. Cet argument par défaut est nul.
8	:displaced-index-offset Il donne le décalage d'index du tableau partagé créé.

Exemple 4

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(setq myarray (make-array '(3 2 3) 
   :initial-contents 
   '(((a b c) (1 2 3)) 
      ((d e f) (4 5 6)) 
      ((g h i) (7 8 9)) 
   ))
) 
(setq array2 (make-array 4 :displaced-to myarray :displaced-index-offset 2)) 
(write myarray)
(terpri)
(write array2)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#3A(((A B C) (1 2 3)) ((D E F) (4 5 6)) ((G H I) (7 8 9)))
#(C 1 2 3)

Si le tableau déplacé est bidimensionnel -

(setq myarray (make-array '(3 2 3) 
   :initial-contents 
   '(((a b c) (1 2 3)) 
      ((d e f) (4 5 6)) 
      ((g h i) (7 8 9)) 
   ))
) 
(setq array2 (make-array '(3 2) :displaced-to myarray :displaced-index-offset 2)) 
(write myarray)
(terpri)
(write array2)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#3A(((A B C) (1 2 3)) ((D E F) (4 5 6)) ((G H I) (7 8 9)))
#2A((C 1) (2 3) (D E))

Modifions le décalage d'index déplacé à 5 -

(setq myarray (make-array '(3 2 3) 
   :initial-contents 
   '(((a b c) (1 2 3)) 
      ((d e f) (4 5 6)) 
      ((g h i) (7 8 9)) 
   ))
) 
(setq array2 (make-array '(3 2) :displaced-to myarray :displaced-index-offset 5)) 
(write myarray)
(terpri)
(write array2)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#3A(((A B C) (1 2 3)) ((D E F) (4 5 6)) ((G H I) (7 8 9)))
#2A((3 D) (E F) (4 5))

Exemple 5

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

;a one dimensional array with 5 elements, 
;initail value 5
(write (make-array 5 :initial-element 5))
(terpri)

;two dimensional array, with initial element a
(write (make-array '(2 3) :initial-element 'a))
(terpri)

;an array of capacity 14, but fill pointer 5, is 5
(write(length (make-array 14 :fill-pointer 5)))
(terpri)

;however its length is 14
(write (array-dimensions (make-array 14 :fill-pointer 5)))
(terpri)

; a bit array with all initial elements set to 1
(write(make-array 10 :element-type 'bit :initial-element 1))
(terpri)

; a character array with all initial elements set to a
; is a string actually
(write(make-array 10 :element-type 'character :initial-element #\a)) 
(terpri)

; a two dimensional array with initial values a
(setq myarray (make-array '(2 2) :initial-element 'a :adjustable t))
(write myarray)
(terpri)

;readjusting the array
(adjust-array myarray '(1 3) :initial-element 'b) 
(write myarray)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#(5 5 5 5 5)
#2A((A A A) (A A A))
5
(14)
#*1111111111
"aaaaaaaaaa"
#2A((A A) (A A))
#2A((A A B))