Array in

Informazioni su Array

In Common Lisp, come in altri linguaggi, un array è un insieme di elementi accessibili tramite indici interi. I tipi degli elementi possono essere eterogenei. L'array può essere multidimensionale (non solo monodimensionale).

Creazione

make-array permette di creare array. Ha molte opzioni, ma le sue forme più semplici permettono di creare array a N dimensioni con tutti gli elementi inizializzati a un unico valore, oppure con l'array inizializzato ai valori di un'altra sequenza (come una lista). Il suo primo argomento è una lista con la dimensione di ciascuna dimensione.

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

(Nota come gli array a N dimensioni vengono stampati con il numero di dimensioni.)

Gli array si possono creare anche usando lo stesso formato con cui vengono stampati:

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

Accesso agli elementi

Per accedere agli elementi di un vettore usa aref: gli indici partono da zero. Il numero di indici forniti deve corrispondere al rango dell'array.

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

Inoltre gli indici forniti devono essere «nei limiti» delle dimensioni specificate al momento della creazione dell'array. Questo si può verificare con array-in-bounds-p:

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

Un elemento si può accedere anche con row-major-aref, che accetta un singolo intero che specifica l'elemento in ordine row-major. (L'indice row-major si può calcolare dagli indici tramite 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

Predicato

Per determinare se un oggetto è un array si può usare arrayp.

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

Interrogazioni sugli array

Diverse informazioni su un array si possono ottenere con le seguenti funzioni:

• array-rank per ottenere il numero di dimensioni dell'array (detto rango dell'array).
• array-dimensions per ottenere una lista con le dimensioni dell'array.
• array-dimension per ottenere la dimensione di una delle dimensioni.
• array-total-size per ottenere il numero totale di elementi dell'array.

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

Limiti sulla dimensione degli array

Lo standard Common Lisp definisce alcuni limiti sulla dimensione massima degli array. Questi limiti sono disponibili in alcune costanti predefinite:

• array-rank-limit: il numero massimo consentito di dimensioni di un array (definito non inferiore a 8).
• array-dimension-limit: la dimensione massima di una singola dimensione (definita non inferiore a 1024).
• array-total-size-limit: il numero massimo di elementi di un array (definito non inferiore a 1024).