Funktionen und Variablen für Arrays (Maxima Manual)

Vorige: Einführung in Arrays, Nach oben: Arrays [Inhalt][Index]

#### 5.5.2 Funktionen und Variablen für Arrays

Funktion: array (name, dim_1, …, dim_n) ¶
Funktion: array (name, type, dim_1, …, dim_n) ¶
Funktion: array ([name_1, …, name_m], dim_1, …, dim_n) ¶
Funktion: array ([name_1, …, name_m], type, dim_1, …, dim_n) ¶

  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]]

Funktion: arrayapply (A, [i_1, …, i_n]) ¶

  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

Funktion: arrayinfo (A) ¶

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

Funktion: arraymake (A, [i_1, …, i_n]) ¶

  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

Systemvariable: arrays ¶

  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]

Funktion: fillarray (A, B) ¶

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

Funktion: listarray (A) ¶

  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]]

Funktion: make_array (type, dim_1, …, dim_n) ¶

  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

Funktion: rearray (A, dim_1, …, dim_n) ¶

  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]

Funktion: remarray (A_1, …, A_n) ¶
Funktion: remarray (all) ¶

  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.

Funktion: subvar (x, i_1, x_2, …) ¶

  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

Funktion: subvarp (expr) ¶

  Gibt `true` zurück, wenn expr eine indizierte Variable wie zum Beispiel `a[i]` ist.

Optionsvariable: use_fast_arrays ¶

  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]