LISP - Array

LISP consente di definire array a dimensione singola o multipla utilizzando l'estensione make-arrayfunzione. Un array può memorizzare qualsiasi oggetto LISP come suoi elementi.

Tutti gli array sono costituiti da posizioni di memoria contigue. L'indirizzo più basso corrisponde al primo elemento e l'indirizzo più alto all'ultimo elemento.

Il numero di dimensioni di un array è chiamato rango.

In LISP, un elemento array è specificato da una sequenza di indici interi non negativi. La lunghezza della sequenza deve essere uguale al rango dell'array. L'indicizzazione inizia da zero.

Ad esempio, per creare un array con 10 celle, denominato my-array, possiamo scrivere -

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

La funzione aref permette di accedere al contenuto delle celle. Richiede due argomenti, il nome dell'array e il valore dell'indice.

Ad esempio, per accedere al contenuto della decima cella, scriviamo:

(aref my-array 9)

Esempio 1

Crea un nuovo file di codice sorgente denominato main.lisp e digita il codice seguente.

(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)

Quando esegui il codice, restituisce il seguente risultato:

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

Esempio 2

Creiamo un array 3 per 3.

Crea un nuovo file di codice sorgente denominato main.lisp e digita il codice seguente.

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

Quando esegui il codice, restituisce il seguente risultato:

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

Esempio 3

Crea un nuovo file di codice sorgente denominato main.lisp e digita il codice seguente.

(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))
   )
)

Quando esegui il codice, restituisce il seguente risultato:

(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)

Sintassi completa per la funzione make-array

La funzione make-array accetta molti altri argomenti. Esaminiamo la sintassi completa di questa funzione:

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

A parte l' argomento delle dimensioni , tutti gli altri argomenti sono parole chiave. La tabella seguente fornisce una breve descrizione degli argomenti.

Sr.No.	Argomento e descrizione
1	dimensions Fornisce le dimensioni dell'array. È un numero per un array unidimensionale e un elenco per un array multidimensionale.
2	:element-type È l'identificatore del tipo, il valore predefinito è T, ovvero qualsiasi tipo
3	:initial-element Valore degli elementi iniziali. Creerà un array con tutti gli elementi inizializzati su un valore particolare.
4	:initial-content Contenuto iniziale come oggetto.
5	:adjustable Aiuta a creare un vettore ridimensionabile (o regolabile) la cui memoria sottostante può essere ridimensionata. L'argomento è un valore booleano che indica se l'array è regolabile o meno, il valore predefinito è NIL.
6	:fill-pointer Tiene traccia del numero di elementi effettivamente memorizzati in un vettore ridimensionabile.
7	:displaced-to Aiuta a creare un array spostato o un array condiviso che condivide i suoi contenuti con l'array specificato. Entrambi gli array dovrebbero avere lo stesso tipo di elemento. L'opzione: displaced-to non può essere utilizzata con l'opzione: initial-element o: initial-contents. Il valore predefinito di questo argomento è nil.
8	:displaced-index-offset Fornisce l'indice-offset dell'array condiviso creato.

Esempio 4

Crea un nuovo file di codice sorgente denominato main.lisp e digita il codice seguente.

(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)

Quando esegui il codice, restituisce il seguente risultato:

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

Se l'array spostato è bidimensionale -

(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)

Quando esegui il codice, restituisce il seguente risultato:

#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))

Cambiamo l'offset dell'indice spostato su 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)

Quando esegui il codice, restituisce il seguente risultato:

#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))

Esempio 5

Crea un nuovo file di codice sorgente denominato main.lisp e digita il codice seguente.

;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)

Quando esegui il codice, restituisce il seguente risultato:

#(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))