LISP: matrices

LISP le permite definir matrices de una o varias dimensiones utilizando el make-arrayfunción. Una matriz puede almacenar cualquier objeto LISP como sus elementos.

Todas las matrices constan de ubicaciones de memoria contiguas. La dirección más baja corresponde al primer elemento y la dirección más alta al último elemento.

El número de dimensiones de una matriz se denomina rango.

En LISP, un elemento de matriz se especifica mediante una secuencia de índices enteros no negativos. La longitud de la secuencia debe ser igual al rango de la matriz. La indexación comienza desde cero.

Por ejemplo, para crear una matriz con 10 celdas, llamada my-array, podemos escribir:

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

La función aref permite acceder al contenido de las celdas. Toma dos argumentos, el nombre de la matriz y el valor del índice.

Por ejemplo, para acceder al contenido de la décima celda, escribimos:

(aref my-array 9)

Ejemplo 1

Cree un nuevo archivo de código fuente llamado main.lisp y escriba el siguiente código en él.

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

Cuando ejecuta el código, devuelve el siguiente resultado:

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

Ejemplo 2

Creemos una matriz de 3 por 3.

Cree un nuevo archivo de código fuente llamado main.lisp y escriba el siguiente código en él.

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

Cuando ejecuta el código, devuelve el siguiente resultado:

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

Ejemplo 3

Cree un nuevo archivo de código fuente llamado main.lisp y escriba el siguiente código en él.

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

Cuando ejecuta el código, devuelve el siguiente resultado:

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

Sintaxis completa para la función make-array

La función make-array toma muchos otros argumentos. Veamos la sintaxis completa de esta función:

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

Aparte del argumento de las dimensiones , todos los demás argumentos son palabras clave. La siguiente tabla proporciona una breve descripción de los argumentos.

No Señor.	Argumento y descripción
1	dimensions Da las dimensiones de la matriz. Es un número para una matriz unidimensional y una lista para una matriz multidimensional.
2	:element-type Es el especificador de tipo, el valor predeterminado es T, es decir, cualquier tipo
3	:initial-element Valor de los elementos iniciales. Hará una matriz con todos los elementos inicializados a un valor particular.
4	:initial-content Contenido inicial como objeto.
5	:adjustable Ayuda a crear un vector redimensionable (o ajustable) cuya memoria subyacente puede redimensionarse. El argumento es un valor booleano que indica si la matriz es ajustable o no, siendo el valor predeterminado NIL.
6	:fill-pointer Realiza un seguimiento del número de elementos realmente almacenados en un vector redimensionable.
7	:displaced-to Ayuda a crear una matriz desplazada o compartida que comparte su contenido con la matriz especificada. Ambas matrices deben tener el mismo tipo de elemento. La opción: desplazado a no se puede utilizar con la opción: elemento-inicial o: contenido-inicial. Este argumento tiene el valor predeterminado de cero.
8	:displaced-index-offset Proporciona el índice de desplazamiento de la matriz compartida creada.

Ejemplo 4

Cree un nuevo archivo de código fuente llamado main.lisp y escriba el siguiente código en él.

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

Cuando ejecuta el código, devuelve el siguiente resultado:

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

Si la matriz desplazada es bidimensional -

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

Cuando ejecuta el código, devuelve el siguiente resultado:

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

Cambiemos el desplazamiento del índice desplazado a 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)

Cuando ejecuta el código, devuelve el siguiente resultado:

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

Ejemplo 5

Cree un nuevo archivo de código fuente llamado main.lisp y escriba el siguiente código en él.

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

Cuando ejecuta el código, devuelve el siguiente resultado:

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