Arrays in

Über Arrays

In Common Lisp ist ein Array, wie in anderen Sprachen, eine Menge von Elementen, auf die man über ganzzahlige Indizes zugreift. Die Typen der Elemente können unterschiedlich sein. Das Array kann mehrdimensional sein (nicht nur 1-dimensional).

Erzeugen

Mit make-array kannst du Arrays erzeugen. Es hat viele Optionen, aber in seinen einfacheren Formen kannst du damit N-dimensionale Arrays erzeugen, bei denen alle Elemente mit einem einzigen Wert initialisiert werden, oder das Array mit den Werten aus einer anderen Sequenz (etwa einer Liste) initialisieren. Sein erstes Argument ist eine Liste der Größe jeder Dimension.

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

(Beachte, dass die N-dimensionalen Arrays mit der Anzahl der Dimensionen ausgegeben werden.)

Arrays kannst du auch erzeugen, indem du dasselbe Format verwendest, in dem sie ausgegeben werden:

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

Zugriff auf Elemente

Um auf Elemente eines Vektors zuzugreifen, verwendest du aref; die Indizes beginnen bei null. Die Anzahl der angegebenen Indizes muss dem Rang des Arrays entsprechen.

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

Außerdem müssen die angegebenen Indizes innerhalb der Grenzen liegen, die durch die Dimensionen vorgegeben sind, mit denen das Array erzeugt wurde. Das kannst du mit array-in-bounds-p prüfen:

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

Auf ein Element kannst du auch mit row-major-aref zugreifen, das eine einzelne Ganzzahl entgegennimmt, die das Element in Row-Major-Reihenfolge angibt. (Der Row-Major-Index lässt sich mit array-row-major-index aus den Indizes berechnen.)

(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

Prädikat

Um festzustellen, ob ein Objekt ein Array ist, kannst du arrayp verwenden.

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

Abfragen zu Arrays

Verschiedene Informationen über ein Array erhältst du mit den folgenden Funktionen:

• array-rank für die Anzahl der Dimensionen des Arrays (der Rang des Arrays).
• array-dimensions für eine Liste der Größen der Dimensionen des Arrays.
• array-dimension für die Größe einer der Dimensionen.
• array-total-size für die Gesamtzahl der Elemente im 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)

Grenzen für die Größe von Arrays

Der Common Lisp Standard definiert einige Grenzen für die maximale Größe von Arrays. Diese Grenzen stehen in einigen definierten Konstanten zur Verfügung:

• array-rank-limit: die maximal erlaubte Anzahl an Dimensionen eines Arrays (definiert als nicht kleiner als 8).
• array-dimension-limit: die maximale Größe einer einzelnen Dimension (definiert als nicht kleiner als 1024).
• array-total-size-limit: die maximale Anzahl von Elementen eines Arrays (definiert als nicht kleiner als 1024).