Arrays en

Acerca de Arrays

En Common Lisp, igual que en otros lenguajes, un array es un conjunto de elementos a los que se accede mediante índices enteros. Los tipos de los elementos pueden ser heterogéneos. El array puede ser multidimensional (no solo unidimensional).

Creación

make-array permite crear arrays. Tiene muchas opciones, pero sus formas más simples permiten crear arrays N-dimensionales con todos los elementos inicializados a un mismo valor, o bien inicializar el array con los valores de otra secuencia (como una lista). Su primer argumento es una lista con el tamaño de cada dimensión.

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

(Fíjate en cómo los arrays N-dimensionales se imprimen con el número de dimensiones.)

Los arrays también se pueden crear usando el mismo formato con el que se imprimen:

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

Acceso a los elementos

Para acceder a los elementos de un vector usa aref; los índices empiezan en cero. El número de índices proporcionados debe coincidir con el rango del 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)

Además, los índices proporcionados deben estar dentro de los límites marcados por las dimensiones con las que se creó el array. Esto se puede comprobar 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

También se puede acceder a un elemento con row-major-aref, que toma un único número entero que especifica el elemento en el orden por filas. (El índice de orden por filas se puede calcular a partir de los índices con 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

Predicado

Para determinar si un objeto es un array se puede usar arrayp.

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

Consultas sobre arrays

Se puede obtener diversa información sobre un array con las siguientes funciones:

• array-rank para obtener el número de dimensiones del array (lo que se conoce como el rango del array).
• array-dimensions para obtener una lista con los tamaños de las dimensiones del array.
• array-dimension para obtener el tamaño de una de las dimensiones.
• array-total-size para obtener el número total de elementos del 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)

Límites en el tamaño de los arrays

El estándar de Common Lisp define algunos límites en el tamaño máximo de los arrays. Estos límites están disponibles en algunas constantes definidas:

• array-rank-limit: el número máximo permitido de dimensiones de un array (definido como no inferior a 8).
• array-dimension-limit: el tamaño máximo de una dimensión cualquiera (definido como no inferior a 1024).
• array-total-size-limit: el número máximo de elementos de un array cualquiera (definido como no inferior a 1024).