ऐरे में

ऐरे के बारे में

Common Lisp में, दूसरी भाषाओं की तरह, ऐरे एलिमेंट का एक समूह होता है, जिन तक पूर्णांक इंडेक्स की मदद से पहुँचा जाता है। एलिमेंट अलग-अलग टाइप के हो सकते हैं। ऐरे बहु-आयामी भी हो सकता है (सिर्फ एक-आयामी नहीं)।

बनाना

make-array से ऐरे बनाए जा सकते हैं। इसमें कई विकल्प हैं, लेकिन इसके आसान रूपों से आप ऐसे 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 &)))

(ध्यान दीजिए कि N-आयामी ऐरे कैसे आयामों की संख्या के साथ प्रिंट होते हैं।)

ऐरे उसी फॉर्मैट का उपयोग करके भी बनाए जा सकते हैं, जिसमें वे प्रिंट होते हैं:

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

एलिमेंट तक पहुँचना

किसी वेक्टर के एलिमेंट तक पहुँचने के लिए aref का उपयोग कीजिए। इंडेक्स शून्य से शुरू होते हैं। दिए गए इंडेक्स की संख्या ऐरे की रैंक के बराबर होनी चाहिए।

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

साथ ही, दिए गए इंडेक्स उन आयामों की सीमा के अंदर होने चाहिए जो ऐरे बनाते समय दिए गए थे। इसे array-in-bounds-p से जाँचा जा सकता है:

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

किसी एलिमेंट तक row-major-aref से भी पहुँचा जा सकता है, जो एक पूर्णांक लेता है और row-major क्रम में एलिमेंट बताता है। (row-major इंडेक्स को इंडेक्सों से 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

प्रेडिकेट

कोई ऑब्जेक्ट ऐरे है या नहीं, यह जानने के लिए arrayp का उपयोग किया जा सकता है।

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

ऐरे से जुड़ी जानकारियाँ

किसी ऐरे की कई तरह की जानकारियाँ इन फंक्शनों से निकाली जा सकती हैं:

• array-rank से ऐरे के आयामों की संख्या मिलती है (इसे ऐरे की रैंक कहा जाता है)।
• array-dimensions से ऐरे के आयामों के आकारों की लिस्ट मिलती है।
• array-dimension से किसी एक आयाम का आकार मिलता है।
• array-total-size से ऐरे में कुल एलिमेंट की संख्या मिलती है।

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

ऐरे के आकार की सीमाएँ

Common Lisp मानक ऐरे के अधिकतम आकार पर कुछ सीमाएँ तय करता है। ये सीमाएँ कुछ परिभाषित कॉन्स्टेंट में उपलब्ध हैं:

• array-rank-limit: ऐरे के आयामों की अधिकतम अनुमत संख्या (यह 8 से कम नहीं होती)।
• array-dimension-limit: किसी एक आयाम का अधिकतम आकार (यह 1024 से कम नहीं होता)।
• array-total-size-limit: किसी भी ऐरे में एलिमेंट की अधिकतम संख्या (यह 1024 से कम नहीं होती)।