Tömbök ebben a kurzusban:

A(z) Tömbök fogalomról

A Common Lispben, mint más nyelvekben, a tömb elemek gyűjteménye, amelyek egész indexekkel érhetők el. Az elemek típusai heterogének lehetnek. A tömb lehet többdimenziós (nem csupán egydimenziós).

Létrehozás

A make-array segítségével tömböket hozhatsz létre. Sok opciója van, de az egyszerűbb formái lehetővé teszik N-dimenziós tömbök létrehozását úgy, hogy minden elem egyetlen értékre van beállítva, vagy a tömb egy másik sorozat (például lista) értékeivel van inicializálva. Az első argumentuma az egyes dimenziók méretét tartalmazó lista.

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

(Figyeld meg, hogy az N-dimenziós tömbök a dimenziók számával együtt íródnak ki.)

A tömbök ugyanabban a formátumban is létrehozhatók, ahogyan kiíródnak:

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

Elemek elérése

Egy vektor elemeinek eléréséhez az aref-et használd; az indexek nullától indulnak. A megadott indexek számának meg kell egyeznie a tömb rangjával.

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

A megadott indexeknek emellett a tömb létrehozásakor megadott dimenziókon belül kell lenniük. Ezt az array-in-bounds-p-vel ellenőrizheted:

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

Egy elem a row-major-aref-fel is elérhető, amely egyetlen egész számot vár, és megadja az elemet sorfolytonos sorrend szerint. (A sorfolytonos index az indexekből az array-row-major-index segítségével számítható ki.)

(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

Predikátum

Annak megállapítására, hogy egy objektum tömb-e, használhatod az arrayp-t.

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

Lekérdezések a tömbökről

Egy tömb különféle információi a következő függvényekkel kérdezhetők le:

• array-rank: a tömb dimenzióinak számát adja meg (ezt a tömb rangjának nevezzük).
• array-dimensions: a tömb egyes dimenzióinak méreteit tartalmazó listát adja vissza.
• array-dimension: az egyik dimenzió méretét adja meg.
• array-total-size: a tömbben lévő elemek teljes számát adja meg.

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

A tömbök méretének korlátai

A Common Lisp szabvány korlátokat határoz meg a tömbök maximális méretére. Ezek a korlátok néhány definiált konstansban érhetők el:

• array-rank-limit: a tömb megengedett maximális dimenziószáma (definíció szerint legalább 8).
• array-dimension-limit: bármely dimenzió maximális mérete (definíció szerint legalább 1024).
• array-total-size-limit: bármely tömb elemeinek maximális száma (definíció szerint legalább 1024).