Vorige: Einführung in Arrays, Nach oben: Arrays [Inhalt][Index]
Erzeugt ein \(n\)-dimensionales Array. Das Array kann bis zu 5 Dimensionen haben. Die Indizes der \(i\)-ten Dimension sind ganze Zahlen in einem Bereich von 0 bis einschließlich dim_i.
array(name, dim_1, ..., dim_n) erzeugt ein Array,
dessen Elemente einen beliebigen Typ haben und auch Symbole oder Ausdrücke
sein können.
array(name, type, dim_1, ..., dim_n) erzeugt
ein Array mit Elementen, die vom Typ type sind. Das Argument type
kann fixnum für ganze Zahlen oder flonum für Gleitkommazahlen
sein.
array([name_1, ..., name_m], dim_1, ..., dim_n)
erzeugt \(m\) Arrays, die alle die gleiche Dimension haben. Wie oben kann
weiterhin der Typ der Arrays durch Angabe des Argumentes type als
fixnum oder flonum festgelegt werden.
Mit der Funktion array können nicht-deklarierte Arrays in ein
deklariertes Array umgewandelt werden. Wenn das deklarierte einen Typ erhalten
soll, müssen alle Elemente des nicht-deklarierten Arrays von diesem Typ sein.
Siehe auch die Funktion make_array, um ein Lisp-Array zu erzeugen,
sowie die Optionsvariable use_fast_arrays.
Beispiele:
Es werden zwei verschiedene Arrays definiert. Im ersten Fall erhält das Array
keinen Typ. Elemente, denen noch kein Wert zugewiesen wurde, werden mit dem
Symbol ##### initialisiert. Im zweiten Fall ist das Array vom Typ
fixnum. Jetzt wird das Array mit dem Wert 0 initialisiert.
(%i1) array(a, 2, 2); (%o1) a (%i2) a[0,0]: 0; a[1,1]:11; a[2,2]:22; (%o2) 0 (%o3) 11 (%o4) 22 (%i5) listarray(a); (%o5) [0, #####, #####, #####, 11, #####, #####, #####, 22] (%i6) array(b, fixnum, 2, 2); (%o6) b (%i7) b[0,0]: 0; b[1,1]:11; b[2,2]:22; (%o7) 0 (%o8) 11 (%o9) 22 (%i10) listarray(b); (%o10) [0, 0, 0, 0, 11, 0, 0, 0, 22]
Ein nicht-deklariertes Array kann in ein deklariertes Array umgewandelt werden.
(%i1) a[1,1]:11; (%o1) 11 (%i2) a[2,2]:22; (%o2) 22 (%i3) arrayinfo(a); (%o3) [hashed, 2, [1, 1], [2, 2]] (%i4) array(a, fixnum, 2, 2); (%o4) a (%i5) arrayinfo(a); (%o5) [complete, 2, [2, 2]]
Wertet A[i_1, ... , i_n] aus, wobei A ein Array
und i_1, …, i_n die Indizes eines Array-Elementes sind.
Siehe auch die Funktion subvar, die die gleiche Funktionalität hat,
sowie die Funktion arraymake, die die Referenz auf das Array-Element
nicht auswertet.
Beispiele:
Die Funktion arrayapply wertet die Referenz auf ein Array-Element aus.
Im Unterschied dazu wertet die Funktion arraymake die Referenz nicht aus.
Die Funktion subvar hat die gleiche Funktionalität wie
arrayapply.
(%i1) a[1,2]: 12;
(%o1) 12
(%i2) a[x,y]: x^y;
y
(%o2) x
(%i3) arrayapply(a, [1, 2]);
(%o3) 12
(%i4) arrayapply(a, [x, y]);
y
(%o4) x
(%i5) arraymake(a, [x,y]);
(%o5) a
x, y
(%i6) subvar(a, x, y);
y
(%o6) x
Gibt Informationen über das Array A zurück. Das Argument A kann ein deklariertes oder ein nicht-deklariertes Array sowie eine Array-Funktion oder eine indizierte Funktion sein.
Für ein deklarierte Array gibt arrayinfo eine Liste zurück, die
declared, die Zahl der Dimensionen und die Größe der Dimensionen
enthält. Die Elemente des Arrays werden von der Funktion listarray
zurückgegeben.
Für ein nicht-deklariertes Array (Hashed-Array) gibt arrayinfo eine
Liste zurück, die hashed, die Zahl der Indizes und die Indizes
enthält, deren Elemente einen Wert haben. Die Werte der Elemente werden mit
der Funktion listarray zurückgegeben.
Für Array-Funktionen gibt arrayinfo eine Liste zurück, die
hashed die Zahl der Indizes und die Indizes enthält, für die
Funktionen im Array enthalten sind. Die Funktionen werden mit der Funktion
listarray angezeigt.
Für indizierte Funktionen gibt arrayinfo eine Liste zurück, die
hashed, die Zahl der Indizes und die Indizes enthält, für die
Lambda-Ausdrücke vorhanden sind. Die lambda-Ausdrücke werden von der
Funktion listarray angezeigt.
Die Funktion arrayinfo kann auch für Lisp-Arrays angewendet werden,
die mit der Funktion make_array erzeugt werden.
Beispiele:
arrayinfo und listarray angewendet auf ein deklariertes Array.
(%i1) array(aa, 2, 3); (%o1) aa
(%i2) aa[2, 3] : %pi; (%o2) %pi
(%i3) aa[1, 2] : %e; (%o3) %e
(%i4) arrayinfo(aa); (%o4) [declared, 2, [2, 3]]
(%i5) listarray(aa);
(%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
#####, #####, #####, %pi]
arrayinfo und listarray angewendet auf ein nicht-deklariertes
Array.
(%i1) bb [FOO] : (a + b)^2;
2
(%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3;
3
(%o2) (c - d)
(%i3) arrayinfo (bb); (%o3) [hashed, 1, [BAR], [FOO]]
(%i4) listarray (bb);
3 2
(%o4) [(c - d) , (b + a) ]
arrayinfo und listarray angewendet auf eine Array-Funktion.
(%i1) cc [x, y] := y / x;
y
(%o1) cc := -
x, y x
(%i2) cc [u, v];
v
(%o2) -
u
(%i3) cc [4, z];
z
(%o3) -
4
(%i4) arrayinfo (cc); (%o4) [hashed, 2, [4, z], [u, v]]
(%i5) listarray (cc);
z v
(%o5) [-, -]
4 u
arrayinfo und listarray angewendet auf eine indizierte Funktion.
(%i1) dd [x] (y) := y ^ x;
x
(%o1) dd (y) := y
x
(%i2) dd [a + b];
b + a
(%o2) lambda([y], y )
(%i3) dd [v - u];
v - u
(%o3) lambda([y], y )
(%i4) arrayinfo (dd); (%o4) [hashed, 1, [b + a], [v - u]]
(%i5) listarray (dd);
b + a v - u
(%o5) [lambda([y], y ), lambda([y], y )]
Gibt den Ausdruck A[i_1, ..., i_n] zurück. Das
Ergebnis ist eine nicht ausgewertete Referenz auf ein Element des Arrays
A. arraymake ist vergleichbar mit der Funktion funmake.
Ist das Array A ein Lisp-Array, wie es mit der Funktion
make_array erzeugt wird, dann gibt arraymake einen Lisp-Fehler
zurück. Das ist ein Programmfehler.
Siehe auch die Funktionen arrayapply und subvar, die die
Referenz auswerten.
Beispiele:
(%i1) arraymake (A, [1]);
(%o1) A
1
(%i2) arraymake (A, [k]);
(%o2) A
k
(%i3) arraymake (A, [i, j, 3]);
(%o3) A
i, j, 3
(%i4) array (A, fixnum, 10); (%o4) A
(%i5) fillarray (A, makelist (i^2, i, 1, 11)); (%o5) A
(%i6) arraymake (A, [5]);
(%o6) A
5
(%i7) ''%; (%o7) 36
(%i8) L : [a, b, c, d, e]; (%o8) [a, b, c, d, e]
(%i9) arraymake ('L, [n]);
(%o9) L
n
(%i10) ''%, n = 3; (%o10) c
(%i11) A2 : make_array (fixnum, 10);
(%o11) {Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o12) {Array: #(1 2 3 4 5 6 7 8 9 10)}
(%i13) arraymake ('A2, [8]);
(%o13) A2
8
(%i14) ''%; (%o14) 9
Standardwert: []
arrays ist eine Informationsliste infolists der vom Nutzer
definierten Arrays. Die Liste enthält deklarierte Arrays, nicht-deklarierte
Arrays und Array-Funktionen, die der Nutzer mit dem Operator := oder der
Funktion define definiert hat. Dagegen sind Arrays, die mit
make_array definiert sind, nicht in der Liste enthalten.
Siehe auch die Funktion array, um ein Array zu definieren.
Beispiele:
(%i1) array (aa, 5, 7); (%o1) aa
(%i2) bb [FOO] : (a + b)^2;
2
(%o2) (b + a)
(%i3) cc [x] := x/100;
x
(%o3) cc := ---
x 100
(%i4) dd : make_array ('any, 7);
(%o4) {Array: #(NIL NIL NIL NIL NIL NIL NIL)}
(%i5) arrays; (%o5) [aa, bb, cc]
Füllt das Array A mit den Werten aus B. Das Argument B ist eine Liste oder ein Array.
Hat das Array A einen Typ, dann kann es nur mit Elementen gefüllt werden, die den gleichen Typ haben.
Sind die Dimensionen von A und B verschieden, werden zunächst die Zeilen des Arrays A aufgefüllt. Hat die Liste oder das Array B nicht genügend Elemente, um das Array A aufzufüllen, werden die restlichen Elemente mit dem letzten Wert von B aufgefüllt. Überzählige Elemente in B werden ignoriert.
fillarray gibt das erste Argument zurück.
Siehe die Funktionen array und make_array, um ein Array
zu definieren.
Beispiele:
Erzeuge ein Array mit 9 Elementen und fülle es mit den Elementen einer Liste.
(%i1) array (a1, fixnum, 8); (%o1) a1
(%i2) listarray (a1); (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0]
(%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]); (%o3) a1
(%i4) listarray (a1); (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9]
Sind zu wenige Elemente vorhanden, um das Array aufzufüllen, wird das Array mit dem letzten Element aufgefüllt. Überzählige Elemente werden ignoriert.
(%i1) a2 : make_array (fixnum, 8);
(%o1) {Array: #(0 0 0 0 0 0 0 0)}
(%i2) fillarray (a2, [1, 2, 3, 4, 5]);
(%o2) {Array: #(1 2 3 4 5 5 5 5)}
(%i3) fillarray (a2, [4]);
(%o3) {Array: #(4 4 4 4 4 4 4 4)}
(%i4) fillarray (a2, makelist (i, i, 1, 100));
(%o4) {Array: #(1 2 3 4 5 6 7 8)}
Arrays werden zeilenweise aufgefüllt.
(%i1) a3 : make_array (fixnum, 2, 5);
(%o1) {Array: #2A((0 0 0 0 0) (0 0 0 0 0))}
(%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o2) {Array: #2A((1 2 3 4 5) (6 7 8 9 10))}
(%i3) a4 : make_array (fixnum, 5, 2);
(%o3) {Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
(%i4) fillarray (a4, a3);
(%o4) {Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))}
Gibt eine Liste mit den Elementen des Arrays A zurück. Das Argument A kann ein deklariertes, nicht-deklariertes, eine Array-Funktion oder eine indizierte Funktion sein.
Die Elemente werden zeilenweise ausgegeben. Für nicht-deklarierte Arrays mit
Indizes, die keine ganze Zahlen sind, wird die Sortierung von der
Aussagefunktion orderlessp bestimmt.
Für nicht-deklarierte Arrays, Array-Funktionen und indizierte Funktionen
werden die Elemente in der Reihenfolge wie von der Funktion
arrayinfo zurückgegeben.
Elemente von deklarierten Arrays, denen noch kein Wert zugewiesen wurde und die
keinen Typ haben, werden als ##### zurückgegeben. Elemente von
deklarierten Arrays mit einem Typ, geben den Wert 0 für den Typ fixnum
und 0.0 für den Typ flonum zurück.
Ist das Argument A ein Lisp-Array, wie es von der Funktion
make_array erzeugt wird, generiert Maxima einen Lisp-Fehler. Das ist ein
Programmfehler.
Beispiele:
Anwendung der Funktionen listarray und arrayinfo für ein
deklariertes Array.
(%i1) array (aa, 2, 3); (%o1) aa
(%i2) aa [2, 3] : %pi; (%o2) %pi
(%i3) aa [1, 2] : %e; (%o3) %e
(%i4) listarray (aa);
(%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
#####, #####, #####, %pi]
(%i5) arrayinfo (aa); (%o5) [declared, 2, [2, 3]]
Anwendung der Funktionen listarray und arrayinfo für ein
nicht-deklariertes Array.
(%i1) bb [FOO] : (a + b)^2;
2
(%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3;
3
(%o2) (c - d)
(%i3) listarray (bb);
3 2
(%o3) [(c - d) , (b + a) ]
(%i4) arrayinfo (bb); (%o4) [hashed, 1, [BAR], [FOO]]
Anwendung der Funktionen listarray und arrayinfo für eine
Array-Funktion.
(%i1) cc [x, y] := y / x;
y
(%o1) cc := -
x, y x
(%i2) cc [u, v];
v
(%o2) -
u
(%i3) cc [4, z];
z
(%o3) -
4
(%i4) listarray (cc);
z v
(%o4) [-, -]
4 u
(%i5) arrayinfo (cc); (%o5) [hashed, 2, [4, z], [u, v]]
Anwendung der Funktionen listarray und arrayinfo für ein
indizierte Funktion.
(%i1) dd [x] (y) := y ^ x;
x
(%o1) dd (y) := y
x
(%i2) dd [a + b];
b + a
(%o2) lambda([y], y )
(%i3) dd [v - u];
v - u
(%o3) lambda([y], y )
(%i4) listarray (dd);
b + a v - u
(%o4) [lambda([y], y ), lambda([y], y )]
(%i5) arrayinfo (dd); (%o5) [hashed, 1, [b + a], [v - u]]
Gibt ein Lisp-Array zurück. Das Argument type kann die Werte
any, flonum, fixnum oder hashed haben. Das Array
hat \(i\) Dimensionen und der Index \(i\) läuft von 0 bis
einschließlich dim_i-1.
Die meisten Funktionen, die auf ein Array angewendet werden können, das mit
der Funktion array definiert wurde, können auch auf Lisp-Arrays
angewendet werden. Einige Funktionalitäten stehen jedoch nicht zur
Verfügung. Dies ist auf eine unzureichende Implementation der Lisp-Arrays
zurückzuführen und kann als Programmfehler betrachtet werden. Hinweise auf
Einschränkungen sind bei den einzelnen Funktionen für Arrays zu finden.
Erhält die Optionsvariable use_fast_arrays den Wert true,
erzeugt Maxima ausschließlich Lisp-Arrays. Dies trifft auch auf die
Funktion array zu. Wie bereits oben erläutert, ist in diesem Fall
jedoch mit einer eingeschränkten Funktionalität zu rechnen.
Beispiele:
(%i1) A1 : make_array (fixnum, 10);
(%o1) {Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i2) A1 [8] : 1729; (%o2) 1729
(%i3) A1;
(%o3) {Array: #(0 0 0 0 0 0 0 0 1729 0)}
(%i4) A2 : make_array (flonum, 10);
(%o4) {Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i5) A2 [2] : 2.718281828; (%o5) 2.718281828
(%i6) A2;
(%o6)
{Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i7) A3 : make_array (any, 10);
(%o7) {Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
(%i8) A3 [4] : x - y - z; (%o8) - z - y + x
(%i9) A3;
(%o9) {Array: #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
-1 $Y) ((MTIMES SIMP) -1 $Z))
NIL NIL NIL NIL NIL)}
(%i10) A4 : make_array (fixnum, 2, 3, 5);
(%o10) {Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
(%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
(%o11) {Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))}
(%i12) A4 [0, 2, 1]; (%o12) 12
Die Funktion rearray erlaubt es, ein Array A zu vergrößern
oder auch zu verkleinern. Die Anzahl der Dimensionen n sowie der Typ
eines Arrays können nicht geändert werden.
Das neue Array wird zeilenweise mit den Werten des alten Arrays aufgefüllt.
Hat das alte Array nicht genügend Elemente werden die restlichen Elemente
entsprechend dem Typ des Arrays mit false, 0.0 oder 0
aufgefüllt.
Siehe die Funktionen array und make_array, um ein Array
zu definieren.
Beispiel:
In diesem Beispiel wird das Array A verkleinert. Der Rückgabewert von
rearray ist ein internes Lisp-Array auch für den Fall, dass das Array
selbst kein Lisp-Array ist.
(%i1) array(A, fixnum, 2, 2);
(%o1) A
(%i2) listarray(A);
(%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0]
(%i3) rearray(A, 1, 1);
(%o3) {Array: #2A((0 0) (0 0))}
(%i4) listarray(A);
(%o4) [0, 0, 0, 0]
Entfernt Arrays und Array-Funktionen. Der vom Array belegte Speicher wird freigegeben. Die Argumente können deklarierte und nicht-deklarierte Arrays sowie Array-Funktionen und indizierte Funktionen sein.
remarray(all) entfernt alle Arrays, die in der Informationsliste
arrays enthalten sind.
remarray gibt eine Liste der Arrays zurück, die entfernt wurden.
remarray wertet die Argumente nicht aus.
Wertet den indizierten Ausdruck x[i_1, i_2, ...] aus.
subvar wertet die Argumente aus.
Siehe die Funktion arrayapply, die dieselbe Funktionalität hat, und
die Funktion arraymake, die eine Referenz auf das Array-Element
zurückgibt, ohne diese auszuwerten.
Beispiele:
(%i1) x : foo $ (%i2) i : 3 $
(%i3) subvar (x, i);
(%o3) foo
3
(%i4) foo : [aa, bb, cc, dd, ee]$
(%i5) subvar (x, i); (%o5) cc
(%i6) arraymake (x, [i]);
(%o6) foo
3
(%i7) ''%; (%o7) cc
Gibt true zurück, wenn expr eine indizierte Variable wie zum
Beispiel a[i] ist.
Standardwert: false
Erhält die Optionsvariable use_fast_arrays den Wert true,
erzeugt Maxima ausschließlich Lisp-Arrays, wie sie auch von der Funktion
make_array erzeugt werden. Dies trifft auch auf die Funktion
array zu. Der Vorteil der Lisp-Arrays ist, dass diese effizienter sind.
Die Implementation der Lisp-Arrays ist jedoch nicht vollständig ausgeführt, so dass es zu einer eingeschränkten Funktionalität kommt. Dies ist ein Programmfehler. Hinweise auf einzelne Einschränkungen sind bei den einzelnen Funktionen zu finden.
Siehe die Funktion make_array für weitere Ausführungen zu
Lisp-Arrays.
Vorige: Einführung in Arrays, Nach oben: Arrays [Inhalt][Index]