Maxima Manual: 5. Datentypen und Strukturen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 5. Datentypen und Strukturen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.1 Zahlen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.1.1 Einführung in Zahlen

### Ganze und rationale Zahlen

Arithmetische Rechnungen mit ganzen oder rationalen Zahlen sind exakt. Prinzipiell können die ganzen und rationalen Zahlen eine beliebige Anzahl an Stellen haben. Eine Obergrenze ist allein der zur Verfügung stehende Speicherplatz.

    (%i1) 1/3+5/4+3;
                                   55
    (%o1)                          --
                                   12
    (%i2) 100!;
    (%o2) 9332621544394415268169923885626670049071596826438162146859\
    2963895217599993229915608941463976156518286253697920827223758251\
    185210916864000000000000000000000000
    (%i3) 100!/101!;
                                    1
    (%o3)                          ---
                                   101

Funktionen für ganze und rationale Zahlen:

       integerp       numberp       nonnegintegerp
       oddp           evenp
       ratnump        rationalize

### Gleitkommazahlen

Maxima rechnet mit Gleitkommazahlen in doppelter Genauigkeit. Weiterhin kann Maxima mit großen Gleitkommazahlen rechnen, die prinzipiell eine beliebige Genauigkeit haben.

Gleitkommazahlen werden mit einem Dezimalpunkt eingegeben. Der Exponent kann mit "f", "e" oder "d" angegeben werden. Intern rechnet Maxima ausschließlich mit Gleitkommazahlen in doppelter Genauigkeit, die immer mit "e" für den Exponenten angezeigt werden. Große Gleitkommazahlen werden mit dem Exponenten "b" bezeichnet. Groß- und Kleinschreibung werden bei der Schreibweise des Exponenten nicht unterschieden.

    (%i1) [2.0,1f10,1,e10,1d10,1d300];
    (%o1)        [2.0, 1.e+10, 1, e10, 1.e+10, 1.e+300]
    (%i2) [2.0b0,1b10,1b300];
    (%o2)               [2.0b0, 1.0b10, 1.0b300]

Ist mindestens eine Zahl in einer Rechnung eine Gleitkommazahl, werden die Argumente in Gleitkommazahlen umgewandelt und eine Gleitkommazahl als Ergebnis zurückgegeben. Dies wird auch für große Gleitkommazahlen ausgeführt.

    (%i1) 2.0+1/2+3;
    (%o1)                                 5.5
    (%i2) 2.0b0+1/2+3;
    (%o2)                                5.5b0

Mit den Funktionen `float` und `bfloat` werden Zahlen in Gleitkommazahlen und große Gleitkommazahlen umgewandelt:

    (%i1) float([2,1/2,1/3,2.0b0]);
    (%o1)          [2.0, 0.5, .3333333333333333, 2.0]
    (%i2) bfloat([2,1/2,1/3,2.0b0]);
    (%o2)     [2.0b0, 5.0b-1, 3.333333333333333b-1, 2.0b0]

Funktionen und Variablen für Gleitkommazahlen:

       float        floatnump
       bfloat       bfloatp       fpprec
       float2bf     bftorat       ratepsilon

       number_pbranch
       m1pbranch

### Komplexe Zahlen

Maxima kennt keinen eigenen Typ für komplexe Zahlen. Komplexe Zahlen werden von Maxima intern als die Addition von Realteil und dem mit der Imaginären Einheit `%i` multiplizierten Imaginärteil dargestellt. Zum Beispiel sind die komplexen Zahlen `2 + 3*%i` und `2 - 3*%i` die Wurzeln der Gleichung `x^2 - 4*x + 13 = 0`.

Maxima vereinfacht Produkte, Quotienten, Wurzeln und andere Ausdrücke mit komplexen Zahlen nicht automatisch zu einer komplexen Zahl. Um Produkte mit komplexen Zahlen zu vereinfachen, kann der Ausdruck mit der Funktion `expand` expandiert werden.

Funktionen für komplexe Zahlen:

       realpart     imagpart      rectform     polarform
       cabs         carg          conjugate    csign

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.1.2 Funktionen und Variablen für Zahlen

Funktion: bfloat (expr)

  Konvertiert alle Zahlen im Ausdruck expr in große Gleitkommazahlen. Die Anzahl der Stellen wird durch die Optionsvariable `fpprec` spezifiziert.

  Hat die Optionsvariable `float2bf` den Wert `false`, gibt Maxima eine Warnung aus, wenn eine Gleitkommazahl mit doppelter Genauigkeit in eine große Gleitkommazahl umgewandelt wird.

  Siehe auch die Funktion und den Auswertungsschalter `float` sowie die Optionsvariable `numer` für die Umwandlung von Zahlen in Gleitkommazahlen mit doppelter Genauigkeit.

  Beispiele:

      (%i1) bfloat([2, 3/2, 1.5]);
      (%o1)                 [2.0b0, 1.5b0, 1.5b0]
      (%i2) bfloat(sin(1/2));
      (%o2)                  4.79425538604203b-1
      (%i3) bfloat(%pi),fpprec:45;
      (%o3)    3.1415926535897932384626433832795028841971694b0

Funktion: bfloatp (number)

  Gibt den Wert `true` zurück, wenn das Argument number eine große Gleitkommazahl ist, ansonsten den Wert `false`.

  Siehe auch die Funktionen `numberp`, `floatnump`, `ratnump` und `integerp`.

  Beispiele:

      (%i1) bfloatp(1.5b0);
      (%o1)                         true
      (%i2) a:bfloat(%e);
      (%o2)                  2.718281828459045b0
      (%i3) bfloatp(a);
      (%o3)                         true
      (%i4) bfloatp(1.5);
      (%o4)                         false

Optionsvariable: bftorat

  Standardwert: `false`

  Die Optionsvariable `bftorat` kontrolliert die Umwandlung von großen Gleitkommazahlen in rationale Zahlen. Hat `bftorat` den Wert `false`, wird die Genauigkeit der Umwandlung von der Optionsvariablen `ratepsilon` kontrolliert. Hat dagegen `bftorat` den Wert `true`, wird die große Gleitkommazahl exakt durch die rationale Zahl repräsentiert.

  Hinweis: `bftorat` hat keinen Einfluss auf die Umwandlung in rationale Zahlen mit der Funktion `rationalize`.

  Beispiel:

      (%i1) ratepsilon:1e-4;
      (%o1)                         1.e-4
      (%i2) rat(bfloat(11111/111111)), bftorat:false;
      `rat' replaced 9.99990999991B-2 by 1/10 = 1.0B-1
                                     1
      (%o2)/R/                       --
                                     10
      (%i3) rat(bfloat(11111/111111)), bftorat:true;
      `rat' replaced 9.99990999991B-2 by 11111/111111 = 9.99990999991B-2
                                   11111
      (%o3)/R/                     ------
                                   111111

Optionsvariable: bftrunc

  Standardwert: `true`

  Hat die Optionsvariable `bftrunc` den Wert `true`, werden bei der Ausgabe einer großen Gleitkommazahl nachfolgende Nullen nicht angezeigt.

  Beispiele:

      (%i1) bftrunc:true;
      (%o1)                         true
      (%i2) bfloat(1);
      (%o2)                         1.0b0
      (%i3) bftrunc:false;
      (%o3)                         false
      (%i4) bfloat(1);
      (%o4)                  1.000000000000000b0

Funktion: evenp (expr)

  Ist das Argument expr eine gerade ganze Zahl, wird `true` zurückgegeben. In allen anderen Fällen wird `false` zurückgegeben.

  `evenp` gibt für Symbole oder Ausdrücke immer den Wert `false` zurück, auch wenn das Symbol als gerade ganze Zahl deklariert ist oder der Ausdruck eine gerade ganze Zahl repräsentiert. Siehe die Funktion `featurep`, um zu testen, ob ein Symbol oder Ausdruck eine gerade ganze Zahl repräsentiert.

  Beispiele:

      (%i1) evenp(2);
      (%o1)                         true
      (%i2) evenp(3);
      (%o2)                         false
      (%i3) declare(n, even);
      (%o3)                         done
      (%i4) evenp(n);
      (%o4)                         false
      (%i5) featurep(n, even);
      (%o5)                         true

Funktion: float (expr)
Optionsvariable: float

  Die Funktion `float` konvertiert ganze, rationale und große Gleitkommazahlen, die im Argument expr enthalten sind, in Gleitkommazahlen mit doppelter Genauigkeit.

  `float` ist auch eine Optionsvariable mit dem Standardwert `false` und ein Auswertungsschalter für die Funktion `ev`. Erhält die Optionsvariable `float` den Wert `true`, werden rationale und große Gleitkommazahlen sofort in Gleitkommazahlen umgewandelt. Als Auswertungsschalter der Funktion `ev` hat `float` denselben Effekt, ohne dass die Optionsvariable `float` ihren Wert ändert. Im Unterschied zur Funktion `float` werden durch das Setzen der Optionsvariablen oder bei Verwendung als Auswertungsschalter keine ganze Zahlen in Gleitkommazahlen umgewandelt. Daher können die beiden Kommandos `ev(expr, float)` und `float(expr)` ein unterschiedliches Ergebnis haben.

  Siehe auch die Optionsvariable `numer`.

  Beispiele:

  In den ersten zwei Beispielen werden die Zahlen `1/2` und `1` in eine Gleitkommazahl umgewandelt. Die Sinusfunktion vereinfacht sodann zu einem numerischen Wert. Das Auswertungsschalter `float` wandelt ganze Zahlen nicht in eine Gleitkommazahl um. Daher wird `sin(1)` nicht zu einem numerischen Wert vereinfacht.

      (%i1) float(sin(1/2));
      (%o1)                   0.479425538604203
      (%i2) float(sin(1));
      (%o2)                   .8414709848078965
      (%i3) sin(1/2),float;
      (%o3)                   0.479425538604203
      (%i4) sin(1),float;
      (%o4)                        sin(1)

Optionsvariable: float2bf

  Standardwert: `true`

  Hat die Optionsvariable `float2bf` den Wert `false`, wird eine Warnung ausgegeben, wenn eine Gleitkommazahl in eine große Gleitkommazahl umgewandelt wird, da die Umwandlung zu einem Verlust an Genauigkeit führen kann.

  Beispiele:

      (%i1) float2bf:true;
      (%o1)                         true
      (%i2) bfloat(1.5);
      (%o2)                         1.5b0
      (%i3) float2bf:false;
      (%o3)                         false
      (%i4) bfloat(1.5);
      bfloat: converting float 1.5 to bigfloat.
      (%o4)                         1.5b0

Funktion: floatnump (number)

  Gibt den Wert `true` zurück, wenn das Argument number eine Gleitkommazahl ist. Ansonsten wird `false` zurückgegeben. Auch wenn number eine große Gleitkommazahl ist, ist das Ergebnis `false`.

  Siehe auch die Funktionen `numberp`, `bfloatp`, `ratnump` und `integerp`.

  Beispiele:

      (%i1) floatnump(1.5);
      (%o1)                         true
      (%i2) floatnump(1.5b0);
      (%o2)                         false

Optionsvariable: fpprec

  Standardwert: 16

  `ffprec` ist die Zahl der Stellen für das Rechnen mit großen Gleitkommazahlen. `ffprec` hat keinen Einfluß auf das Rechnen mit Gleitkommazahlen in doppelter Genauigkeit. Siehe auch `bfloat` und `fpprintprec`.

  Beispiele:

      (%i1) fpprec:16;
      (%o1)                          16
      (%i2) bfloat(%pi);
      (%o2)                  3.141592653589793b0
      (%i3) fpprec:45;
      (%o3)                          45
      (%i4) bfloat(%pi);
      (%o4)    3.1415926535897932384626433832795028841971694b0
      (%i5) sin(1.5b0);
      (%o5)   9.97494986604054430941723371141487322706651426b-1

Optionsvariable: fpprintprec

  Standardwert: 0

  `fpprintprec` ist die Anzahl der Stellen, die angezeigt werden, wenn eine Gleitkommazahl ausgegeben wird.

  Hat `fpprintprec` einen Wert zwischen 2 und 16, ist die Anzahl der angezeigten Stellen für einfache Gleitkommazahlen gleich dem Wert von `fpprintprec`. Hat `fpprintprec` den Wert 0 oder ist größer als 16 werden 16 Stellen angezeigt.

  Hat für große Gleitkommazahlen `fpprintprec` einen Wert zwischen 2 und `fpprec`, ist die Anzahl der angezeigten Stellen gleich `fpprintprec`. Ist der Wert von `fpprintprec` gleich 0 oder größer als `fpprec` werden `fpprec` Stellen angezeigt.

  `fpprintprec` kann nicht den Wert 1 erhalten.

  Beispiele:

      (%i1) fpprec:16;
      (%o1)                          16
      (%i2) fpprintprec:5;
      (%o2)                           5
      (%i3) float(%pi);
      (%o3)                        3.1416
      (%i4) bfloat(%pi);
      (%o4)                       3.1415b0
      (%i5) fpprintprec:25;
      (%o5)                          25
      (%i6) bfloat(%pi);
      (%o6)                  3.141592653589793b0
      (%i7) bfloat(%pi);
      (%o7)                  3.141592653589793b0
      (%i8) fpprec:45;
      (%o8)                          45
      (%i9) bfloat(%pi);
      (%o9)             3.141592653589793238462643b0
      (%i10) fpprintprec:45;
      (%o10)                         45
      (%i11) bfloat(%pi);
      (%o11)   3.1415926535897932384626433832795028841971694b0

Funktion: integerp (number)

  Hat den Rückgabewert `true`, wenn das Argument number eine ganze Zahl ist. In allen anderen Fällen gibt `integerp` den Wert `false` zurück.

  `integerp` gibt für Symbole oder Ausdrücke immer den Wert `false` zurück, auch wenn das Symbol als ganze Zahl deklariert ist oder der Ausdruck eine ganze Zahl repräsentiert. Siehe die Funktion `featurep`, um zu testen, ob ein Symbol oder Ausdruck eine ganze Zahl repräsentiert.

  Beispiele:

      (%i1) integerp (1);
      (%o1)                         true
      (%i2) integerp (1.0);
      (%o2)                         false
      (%i3) integerp (%pi);
      (%o3)                         false
      (%i4) declare (n, integer)$
      (%i5) integerp (n);
      (%o5)                         false

Optionsvariable: m1pbranch

  Standardwert: `false`

  Die Optionsvariable `m1pbranch` kontrolliert die Vereinfachung der Exponentiation von `-1` für den Fall, dass die Optionsvariable `domain` den Wert `complex` hat. Hat `m1pbranch` für diesen Fall den Wert `true`, wird die Exponentiation von `-1` zu einem Ausdruck vereinfacht, der dem Hauptwert entspricht. Die Auswirkung der Optionsvariable `m1pbranch` ist in der folgenden Tabelle gezeigt.

                    domain:real

      (-1)^(1/3):      -1
      (-1)^(1/4):   (-1)^(1/4)

                   domain:complex

      m1pbranch:false          m1pbranch:true
      (-1)^(1/3)               1/2+%i*sqrt(3)/2
      (-1)^(1/4)              sqrt(2)/2+%i*sqrt(2)/2

  Siehe auch die Optionsvariable `numer_pbranch`.

Funktion: nonnegintegerp (number)

  Gibt den Wert `true` zurück, wenn `number` eine ganze positive Zahl oder Null ist. Siehe auch `integerp`.

  Beispiele:

      (%i1) nonnegintegerp(2);
      (%o1)                         true
      (%i2) nonnegintegerp(-2);
      (%o2)                         false

Funktion: numberp (number)

  Hat das Ergebnis `true`, wenn number eine ganze, rationale, eine Gleitkommazahl oder eine große Gleitkommazahl ist. Ansonsten ist das Ergebnis `false`.

  `numberp` gibt für ein Symbol immer das Ergebnis `false` zurück. Dies ist auch dann der Fall, wenn das Symbol eine numerische Konstante wie `%pi` ist oder wenn das Symbol mit der Funktion `declare` eine Eigenschaft wie `integer`, `real` oder `complex` erhalten hat.

  Beispiele:

      (%i1) numberp (42);
      (%o1)                         true
      (%i2) numberp (-13/19);
      (%o2)                         true
      (%i3) numberp (3.14159);
      (%o3)                         true
      (%i4) numberp (-1729b-4);
      (%o4)                         true
      (%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
      (%o5)      [false, false, false, false, false, false]
      (%i6) declare(a,even, b,odd, c,integer, d,rational, e,real);
      (%o6)                         done
      (%i7) map (numberp, [a, b, c, d, e]);
      (%o7) [false, false, false, false, false]

Optionsvariable: numer

  Standardwert: `false`

  Hat die Optionsvariable `numer` den Wert `true`, werden rationale Zahlen und große Gleitkommazahlen in Gleitkommazahlen umgewandelt. Weiterhin werden Konstante wie zum Beispiel `%pi`, die einen numerischen Wert haben, durch diesen ersetzt. Mathematische Funktionen mit numerischen Argumenten vereinfachen zu einer Gleitkommazahl. Wird die Optionsvariable `numer` gesetzt, erhält die Optionsvariable `float` denselben Wert. Im Unterschied zur Optionsvariablen `float` vereinfachen auch mathematische Funktionen mit einem ganzzahligen Wert wie zum Beispiel `sin(1)` zu einem numerischen Wert.

  `numer` ist auch ein Auswertungsschalter der Funktion `ev`. Der Auswertungsschalter hat die gleiche Funktionsweise wie die Optionsvariable, ohne dass die Optionsvariable ihren Wert ändert.

  Siehe auch `float` und `%enumer`.

  Beispiele:

  Erhält `numer` den Wert `true`, werden rationale Zahlen, Konstante mit einem numerischen Wert und mathematische Funktionen mit numerischen Argumenten zu einer Gleitkommazahl ausgewertet oder vereinfacht.

      (%i1) numer:false;
      (%o1)                         false
      (%i2) [1, 1/3, %pi, sin(1)];
                                 1
      (%o2)                  [1, -, %pi, sin(1)]
                                 3
      (%i3) numer:true;
      (%o3)                         true
      (%i4) [1, 1/3, %pi, sin(1)];
      (%o4) [1, .3333333333333333, 3.141592653589793,
                                                     .8414709848078965]

  `numer` ist auch ein Auswertungsschalter der Funktion `ev`. Hier wird die Kurzschreibweise der Funktion `ev` verwendet.

      (%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))];
                                              1
      (%o1)            [sqrt(2), sin(1), -----------]
                                         sqrt(3) + 1

      (%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer;
      (%o2) [1.414213562373095, .8414709848078965, .3660254037844387]

Optionsvariable: numer_pbranch

  Standardwert: `false`

  Die Optionsvariable `numer_pbranch` kontrolliert die Vereinfachung der Exponentiation einer negativen ganzen, rationalen oder Gleitkommazahl. Hat `numer_pbranch` den Wert `true` und ist der Exponent eine Gleitkommazahl oder hat die Optionsvariable `numer` den Wert `true`, dann berechnet Maxima den Hauptwert der Exponentiation. Ansonsten wird ein vereinfachter Ausdruck, aber nicht numerischer Wert zurückgegeben. Siehe auch die Optionsvariable `m1pbranch`.

  Beispiele:

      (%i1) (-2)^0.75;
      (%o1) (-2)^0.75

      (%i2) (-2)^0.75,numer_pbranch:true;
      (%o2) 1.189207115002721*%i-1.189207115002721

      (%i3) (-2)^(3/4);
      (%o3) (-1)^(3/4)*2^(3/4)

      (%i4) (-2)^(3/4),numer;
      (%o4) 1.681792830507429*(-1)^0.75

      (%i5) (-2)^(3/4),numer,numer_pbranch:true;
      (%o5) 1.189207115002721*%i-1.189207115002721

Funktion: numerval (x_1, val_1, …, var_n, val_n)

  Die Variablen x_1, …, x_n erhalten die numerischen Werte val_1, …, `val_n`. Die numerischen Werte werden immer dann für die Variablen in Ausdrücke eingesetzt, wenn die Optionsvariable `numer` den Wert `true` hat. Siehe auch `ev`.

  Die Argumente val_1, …, val_n können auch beliebige Ausdrücke sein, die wie numerische Werte für Variablen eingesetzt werden.

  Beispiele:

      (%i1) numerval(a, 123, b, x^2)$

      (%i2) [a, b];
      (%o2)                        [a, b]
      (%i3) numer:true;
      (%o3)                         true
      (%i4) [a, b];
                                         2
      (%o4)                       [123, x ]

Funktion: oddp (expr)

  Gibt `true` zurück, wenn das Argument expr eine ungerade ganze Zahl ist. In allen anderen Fällen wird `false` zurückgegeben.

  `oddp` gibt für Symbole oder Ausdrücke immer den Wert `false` zurück, auch wenn das Symbol als ungerade ganze Zahl deklariert ist oder der Ausdruck eine ungerade ganze Zahl repräsentiert. Siehe die Funktion `featurep`, um zu testen, ob ein Symbol oder Ausdruck eine ungerade ganze Zahl repräsentiert.

  Beispiele:

      (%i1) oddp(3);
      (%o1)                         true
      (%i2) oddp(2);
      (%o2)                         false
      (%i3) declare(n,odd);
      (%o3)                         done
      (%i4) oddp(n);
      (%o4)                         false
      (%i5) featurep(n,odd);
      (%o5)                         true

Optionsvariable: ratepsilon

  Standardwert: `2.0e-15`

  Die Optionsvariable `ratepsilon` kontrolliert die Genauigkeit, mit der Gleitkommazahlen in rationale Zahlen umgewandelt werden, wenn die Optionsvariable `bftorat` den Wert `false` hat. Für ein Beispiel siehe die Optionsvariable `bftorat`.

Funktion: rationalize (expr)

  Konvertiert alle Gleitkommazahlen einschließlich großer Gleitkommazahlen, die in dem Ausdruck expr auftreten, in rationale Zahlen.

  Es mag überraschend sein, dass `rationalize(0.1)` nicht das Ergebnis `1/10` hat. Dies ist nicht speziell für Maxima. Ursache ist, dass die gebrochene Zahl `1/10` in der internen Darstellung als binäre Zahl keine endliche Darstellung hat.

  Siehe auch die Funktionen `float` und `bfloat` sowie die Auswertungsschalter `float` und `numer`, um eine rationale Zahl in eine Gleitkommazahl umzuwandeln.

  Beispiele:

      (%i1) rationalize (0.5);
                                      1
      (%o1)                           -
                                      2
      (%i2) rationalize (0.1);
                              3602879701896397
      (%o2)                   -----------------
                              36028797018963968
      (%i3) fpprec : 5$
      (%i4) rationalize (0.1b0);
                                   209715
      (%o4)                        -------
                                   2097152
      (%i5) fpprec : 20$
      (%i6) rationalize (0.1b0);
                           236118324143482260685
      (%o6)                ----------------------
                           2361183241434822606848
      (%i7) rationalize (sin (0.1*x + 5.6));
                     3602879701896397 x   3152519739159347
      (%o7)      sin(------------------ + ----------------)
                     36028797018963968    562949953421312
      (%i8) float(%);
      (%o8)                          sin(0.1 x + 5.6)

Funktion: ratnump (number)

  Gibt `true` zurück, wenn number eine ganze oder rationale Zahl ist. In allen anderen Fällen ist das Ergebnis `false`.

  Siehe auch die Funktionen `numberp`, `integerp`, `floatnump` und `bfloatp`.

  Beispiele:

      (%i1) ratnump(1/2);
      (%o1)                         true
      (%i2) ratnump(3);
      (%o2)                         true
      (%i3) ratnump(3.0);
      (%o3)                         false

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.2 Zeichenketten

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.2.1 Einführung in Zeichenketten

Zeichenketten werden bei der Eingabe in Anführungszeichen gesetzt. Sie werden standardmäßig ohne Anführungszeichen ausgegeben. Hat die Optionsvariable `stringdisp` den Wert `true`, werden Zeichenketten mit Anführungszeichen dargestellt.

Zeichenketten können jedes Zeichen einschließlich Tabulator-, Zeilenvorschub- oder Wagenrücklauf-Zeichen enthalten. Das Anführungszeichen wird innerhalb einer Zeichenkette durch `\"` und der Backslash durch `\\` dargestellt. Ein Backslash am Ende einer Eingabezeile erlaubt die Fortsetzung einer Zeichenkette in der nächsten Zeile. Maxima kennt keine weiteren Kombinationen mit einem Backslash. Daher wird der Backslash an anderer Stelle ignoriert. Maxima kennt keine andere Möglichkeit, als spezielle Zeichen wie ein Tabulator-, Zeilenvorschub- oder Wagenrücklaufzeichen in einer Zeichenkette darzustellen.

Maxima hat keinen Typ für ein einzelnes Zeichen. Einzelne Zeichen werden daher als eine Zeichenkette mit einem Zeichen dargestellt. Folgende Funktionen und Variablen arbeiten mit Zeichenketten:

       concat   sconcat   string   stringdisp

Das Zusatzpaket `stringproc` enthält eine umfangreiche Bibliothek an Funktionen für Zeichenketten. Siehe stringproc.

Beispiele:

    (%i1) s_1 : "This is a string.";
    (%o1)               This is a string.
    (%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
    (%o2) Embedded "double quotes" and backslash \ characters.
    (%i3) s_3 : "Embedded line termination
    in this string.";
    (%o3) Embedded line termination
    in this string.
    (%i4) s_4 : "Ignore the \
    line termination \
    characters in \
    this string.";
    (%o4) Ignore the line termination characters in this string.
    (%i5) stringdisp : false;
    (%o5)                         false
    (%i6) s_1;
    (%o6)                   This is a string.
    (%i7) stringdisp : true;
    (%o7)                         true
    (%i8) s_1;
    (%o8)                  "This is a string."

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.2.2 Funktionen und Variablen für Zeichenketten

Funktion: concat (arg_1, arg_2, …)

  Verkettet die Argumente arg_1, arg_2, … zu einer Zeichenkette oder einem Symbol. Die Argumente müssen sich zu einem Atom auswerten lassen. Der Rückgabewert ist ein Symbol, wenn das erste Argument ein Symbol ist. Ansonsten wird eine Zeichenkette zurückgegeben.

  `concat` wertet die Argumente aus. Der Quote-Operator `'` verhindert die Auswertung. Siehe auch die Funktion `sconcat`.

  Beispiele:

      (%i1) y: 7$
      (%i2) z: 88$
      (%i3) stringdisp:true$
      (%i4) concat(y, z/2);
      (%o4)                         "744"
      (%i5) concat('y, z/2);
      (%o5)                          y44

  Einem Symbol, das mit `concat` konstruiert wird, kann ein Wert zugewiesen werden und es kann in Ausdrücken auftreten.

      (%i6) a: concat ('y, z/2);
      (%o6)                          y44
      (%i7) a:: 123;
      (%o7)                          123
      (%i8) y44;
      (%o8)                          123
      (%i9) b^a;
                                     y44
      (%o9)                         b
      (%i10) %, numer;
                                      123
      (%o11)                         b

  `concat(1, 2)` gibt eine Zeichenkette als Ergebnis zurück.

      (%i12) concat (1, 2) + 3;
      (%o12)                       "12" + 3

Funktion: sconcat (arg_1, arg_2, …)

  Verkettet die Argumente arg_1, arg_2, … zu einer Zeichenkette. Im Unterschied zu der Funktion `concat` müssen die Argumente nicht Atome sein. Der Rückgabewert ist eine Zeichenkette.

  Beispiel:

      (%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
      (%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3

Funktion: string (expr)

  Konvertiert das Argument `expr` in eine lineare Darstellung, wie sie auch vom Parser von der Eingabe eingelesen wird. Die Rückgabe von `string` ist eine Zeichenkette. Diese kann nicht als Eingabe für eine Berechnung genutzt werden.

  Beispiele:

  Die hier verwendete Funktion `stringp` ist im Paket `stringproc` definiert und wird automatisch geladen.

      (%i1) stringdisp:true;
      (%o1)                         true
      (%i2) string(expand((a+b)^2));
      (%o2)                    "b^2+2*a*b+a^2"
      (%i3) stringp(%);
      (%o3)                         true

Optionsvariable: stringdisp

  Standardwert: `false`

  Hat `stringdisp` den Wert `true`, werden Zeichenketten mit Anführungszeichen ausgegeben. Ansonsten werden keine Anführungszeichen ausgegeben.

  Wird die Definition einer Funktion ausgegeben, werden enthaltene Zeichenketten unabhängig vom Wert der Optionsvariablen `stringdisp` immer mit Anführungszeichen ausgegeben.

  Beispiele:

      (%i1) stringdisp: false$
      (%i2) "This is an example string.";
      (%o2)              This is an example string.
      (%i3) foo () :=
            print ("This is a string in a function definition.");
      (%o3) foo() :=
                    print("This is a string in a function definition.")
      (%i4) stringdisp: true$
      (%i5) "This is an example string.";
      (%o5)             "This is an example string."

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.3 Funktionen und Variablen für Konstante

Konstante: %e

  `%e` ist die Basis des natürlichen Logarithmus, auch Eulersche Zahl genannt. Der numerische Wert der Konstanten als Gleitkommazahl mit doppelter Genauigkeit ist 2.718281828459045d0.

  Die Funktion `bfloat` kann `%e` mit einer beliebigen Genauigkeit berechnen.

  Hat die Optionsvariable `numer` den Wert `true`, wird `%e` durch den numerischen Wert ersetzt, aber nicht, wenn `%e` die Basis der Exponentiation mit einem symbolischen Exponenten ist. Hat zusätzlich die Optionsvariable `%enumer` den Wert `true`, dann wird `%e` in einem Ausdruck immer durch den numerischen Wert ersetzt.

  Beispiel:

  Berechnung von `%e` auf 48 Stellen.

      (%i1) fpprec: 48$
      (%i2) bfloat(%e);
      (%o2)  2.7182818284590452353602874713526624977572470937b0

  Die Wirkung der Optionsvariablen `numer` und `%enumer` auf das Ersetzen von `%e` durch den numerischen Wert.

      (%i1) %e, numer;
      (%o1)                   2.718281828459045
      (%i2) %e^x, numer;
                                       x
      (%o2)                          %e
      (%i3) %e^x, numer, %enumer;
                                              x
      (%o3)                  2.718281828459045

  Im ersten Beispiel vereinfacht die Reihe zu `%e`. Für die Vereinfachung der Reihe wird die Funktion `simplify_sum` geladen. Im zweiten Beispiel ist `%e` der Grenzwert.

      (%i1) load(simplify_sum)$

      (%i2) sum(1/n!, n, 0, inf);
                                  inf
                                  ====
                                  \     1
      (%o2)                        >    --
                                  /     n!
                                  ====
                                  n = 0
      (%i3) simplify_sum(%);

      (%o3)                          %e

      (%i4) limit((1+x)^(1/x), x, 0);
      (%o4)                          %e

Konstante: %i

  `%i` ist die imaginäre Einheit.

  Maxima kennt keinen eigenen Typ für komplexe Zahlen. Komplexe Zahlen werden von Maxima intern als die Addition von Realteil und dem mit der imaginären Einheit `%i` multiplizierten Imaginärteil dargestellt. Zum Beispiel sind die komplexen Zahlen `2 + 3*%i` und `2 - 3*%i` die Wurzeln der Gleichung `x^2 - 4*x + 13 = 0`. Siehe auch das Kapitel Zahlen.

  Beispiele:

  Einige Beispiele für das Rechnen mit der imaginären Einheit.

      (%i1) sqrt(-1);
      (%o1)                          %i
      (%i2) %i^2;
      (%o2)                          - 1
      (%i3) exp(%i*%pi/2);
      (%o3)                          %i
      (%i4) sin(%i*x);
      (%o4)                      %i sinh(x)

Konstante: false

  Repräsentiert den logischen Wert `falsch`. `false` wird intern von Maxima durch die Lisp-Konstante `NIL` dargestellt.

  Siehe auch `true` für den logischen Wert `wahr`.

Konstante: %gamma

  Die Euler-Mascheroni-Konstante mit dem Wert `0.5772156649015329` als Gleitkommazahl in doppelter Genauigkeit.

  Die Funktion `bfloat` kann `%gamma` mit einer beliebigen Genauigkeit berechnen.

  Hat die Optionsvariable `numer` den Wert `true`, wird die Konstante `%gamma` durch ihren numerischen Wert ersetzt.

  Beispiele:

  Numerische Werte für `%gamma`.

      (%i1) %gamma, numer;
      (%o1)                   .5772156649015329
      (%i2) bfloat(%gamma), fpprec: 48;
      (%o2)  5.7721566490153286060651209008240243104215933594b-1

  Bestimmte Integrale, die `%gamma` als Ergebnis haben.

      (%i1) -integrate(exp(-t)*log(t), t, 0, inf);
      (%o1)                        %gamma
      (%i2) -integrate(log(log(1/t)),t, 0,1);
      (%o2)                        %gamma

Konstante: ind

  `ind` repräsentiert ein unbestimmtes Ergebnis. Siehe auch `und` und die Funktion `limit`.

  Beispiel:

      (%i1) limit(sin(1/x), x, 0);
      (%o1)                          ind

Konstante: inf

  `inf` repräsentiert einen positiven unendlich großen Wert. Siehe auch `minf` und `infinity`.

  Die unendlichen Größen, aber auch die unbestimmten Größen `ind` und `und`, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten `limit`, bestimmten Integralen `integrate` oder Reihen `sum` verwendet werden.

Konstante: infinity

  `infinity` repräsentiert einen komplexen unendlichen Wert. Siehe auch `inf` und `minf`.

  Die unendlichen Größen, aber auch die unbestimmten Größen `ind` und `und`, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten `limit`, bestimmten Integralen `integrate` oder Reihen `sum` verwendet werden.

Konstante: minf

  `minf` repräsentiert einen negativen unendlichen Wert. Siehe auch `inf` und `infinity`.

  Die unendlichen Größen, aber auch die unbestimmten Größen `ind` und `und`, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten `limit`, bestimmten Integralen `integrate` oder Reihen `sum` verwendet werden.

Konstante: %phi

  `%phi` repräsentiert die Goldene Zahl (1 + sqrt(5))/2. Der Wert als Gleitkommazahl in doppelter Genauigkeit ist 1.618033988749895d0.

  Die Funktion `fibtophi` drückt Fibonacci-Zahlen `fib(n)` durch die Goldene Zahl `%phi` aus. Standardmäßig kennt Maxima keine algebraischen Eigenschaften der Konstanten `%phi`. Mit den Eingaben `tellrat(%phi^2-%phi-1)` und `algebraic: true` kann die Funktion `ratsimp` einige Vereinfachungen ausführen.

  Die Funktion `bfloat` kann `%phi` mit einer beliebigen Genauigkeit berechnen. Hat die Optionsvariable `numer` den Wert `true`, wird die Konstante `%phi` durch ihren numerischen Wert ersetzt.

  Beispiele:

  Numerische Werte für `%phi`.

      (%i1) %phi, numer;
      (%o1)                   1.618033988749895
      (%i2) bfloat(%phi), fpprec: 48;
      (%o2)  1.61803398874989484820458683436563811772030917981b0

  `fibtophi` drückt Fibonacci-Zahlen `fib(n)` durch `%phi` aus.

      (%i1) fibtophi (fib (n));
                                 n             n
                             %phi  - (1 - %phi)
      (%o1)                  -------------------
                                 2 %phi - 1
      (%i2) fib (n-1) + fib (n) - fib (n+1);
      (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
      (%i3) fibtophi (%);
                  n + 1             n + 1       n             n
              %phi      - (1 - %phi)        %phi  - (1 - %phi)
      (%o3) - --------------------------- + -------------------
                      2 %phi - 1                2 %phi - 1
                                                n - 1             n - 1
                                            %phi      - (1 - %phi)
                                          + ---------------------------
                                                    2 %phi - 1
      (%i4) ratsimp (%);
      (%o4)                           0

  Mit den Eingaben `tellrat(%phi^2-%phi-1)` und `algebraic:true` kann die Funktion `ratsimp` einige Vereinfachungen für Ausdrücke ausführen, die `%phi` enthalten.

      (%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                       2                      2
      (%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
      (%i2) ratsimp (e);
                        2                     2
      (%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
      (%i3) tellrat (%phi^2 - %phi - 1);
                                  2
      (%o3)                  [%phi  - %phi - 1]
      (%i4) algebraic : true;
      (%o4)                         true
      (%i5) ratsimp (e);
      (%o5)                           0

Konstante: %pi

  `%pi` repräsentiert die Kreiszahl. Der numerische Wert als Gleitkommazahl in doppelter Genauigkeit ist `3.141592653589793d0`.

  Die Funktion `bfloat` kann `%pi` mit einer beliebigen Genauigkeit berechnen. Hat die Optionsvariable `numer` den Wert `true`, wird die Konstante `%pi` durch ihren numerischen Wert ersetzt.

  Beispiele:

  Numerische Werte für `%pi`.

      (%i1) %pi, numer;
      (%o1)                   3.141592653589793
      (%i2) bfloat(%pi), fpprec:48;
      (%o2)  3.14159265358979323846264338327950288419716939938b0

  Grenzwert und bestimmte Integrale, die `%pi` als Ergebnis haben.

      (%i1) 'limit(n!^2*(n+1)^(2*n^2+n)/(2*n^(2*n^2+3*n+1)),n,inf);
                              2                     2
                         - 2 n  - 3 n - 1        2 n  + n   2
               limit    n                 (n + 1)         n!
               n -> inf
      (%o1)    ----------------------------------------------
                                     2
      (%i2) %, nouns;
      (%o2)                          %pi
      (%i3) 'integrate(4*sqrt(1-t^2),t,0,1);
                               1
                              /
                              [            2
      (%o3)                 4 I  sqrt(1 - t ) dt
                              ]
                              /
                               0
      (%i4) %, nouns;
      (%o4)                          %pi
      (%i5) 'integrate(2*exp(-t^2),t,0,inf);
                                 inf
                                /         2
                                [      - t
      (%o5)                   2 I    %e     dt
                                ]
                                /
                                 0
      (%i6) %, nouns;
      (%o6)                       sqrt(%pi)

Konstante: true

  `true` repräsentiert den logischen Wert `wahr`. Intern ist `true` als die Lisp-Konstante `T` implementiert.

  Siehe auch `false` für den logischen Wert `falsch`.

Konstante: und

  `und` repräsentiert ein nicht definiertes Ergebnis. Siehe auch `ind` und die Funktion `limit`.

  Beispiel:

      (%i1) limit (x*sin(x), x, inf);
      (%o1)                          und

Konstante: zeroa

  `zeroa` repräsentiert eine positive unendlich kleine Zahl. `zeroa` kann in Ausdrücken benutzt werden. Die Funktion `limit` vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

  Siehe auch `zerob` und `limit`.

  Beispiele:

  `limit` vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

      (%i1) limit(zeroa);
      (%o1)                           0
      (%i2) limit(x+zeroa);
      (%o2)                           x

Konstante: zerob

  `zerob` repräsentiert eine negative unendlich kleine Zahl. `zerob` kann in Ausdrücken benutzt werden. Die Funktion `limit` vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

  Siehe auch `zeroa` und `limit`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.4 Listen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.4.1 Einführung in Listen

Listen werden in Maxima mit eckigen Klammern eingegeben und angezeigt:

    [a, b, c, ...]

Die Elemente einer Liste können Zahlen, Symbole, Ausdrücke und auch Listen sein, wodurch verschachtelte Listen entstehen:

    (%i1) [1, 1/2, a, a+b, sin(x), [log(y)^2, y]];
                     1                        2
    (%o1)        [1, -, a, b + a, sin(x), [log (y), y]]
                     2

Mit den Funktionen `makelist` und `create_list` können Listen aus Ausdrücken generiert werden. Die Funktion `copylist` erzeugt eine Kopie einer Liste. Auf einzelne Elemente oder Teile von Listen kann mit den Funktionen `first`, `rest` oder `last` zugegriffen werden. Mit der Aussagefunktion `listp` kann getestet werden, ob eine Liste vorliegt. Für das Arbeiten mit Listen kennt Maxima die folgenden Funktionen:

       append        assoc     cons      copylist
       create_list   delete    eighth    endcons
       fifth         first     fourth    join
       last          length    listp     makelist
       member        ninth     pop       push
       rest          reverse   second    seventh
       sixth         sort      sublist   sublist_indices
       tenth         third

Da Maxima intern alle Ausdrücke als Listen darstellt, können viele der oben aufgeführten Funktionen nicht nur auf Maxima-Listen, sondern auch auf allgemeine Ausdrücke angewendet werden. So wird zum Beispiel die Addition der drei Symbole `a`, `b`, `c` von Maxima intern folgendermaßen als eine Lisp-Liste dargestellt:

       ((MPLUS) $A $B $C)

Der Operator der Addition ist `MPLUS` und die Symbole `$A`, `$B` und `$C` sind die Argumente des Operators. Alle Funktionen für Listen, die nur auf die Argumente wirken, können auch auf allgemeine Ausdrücke angewendet werden. Im folgenden werden zum Beispiel die Funktionen `first`, `last`, `cons` und `delete` auf eine Addition angewendet:

    (%i1) expr: a + b + c;
    (%o1)                       c + b + a
    (%i2) first(expr);
    (%o2)                           c
    (%i3) last(expr);
    (%o3)                           a
    (%i4) cons(2*x, expr);
    (%o4)                    2 x + c + b + a
    (%i5) delete(b, expr);
    (%o5)                         c + a

Weitere Beispiele für die Anwendung der Funktionen für Listen auf allgemeine Ausdrücke sind bei den einzelnen Funktionen angegeben. Eine ausführliche Beschreibung der internen Darstellung von Maxima-Ausdrücken ist in Ausdrücke enthalten.

Auf die einzelnen Elemente einer Liste kann direkt über einen Index zugegriffen werden. Bezeichnet der Index kein Element der Liste, gibt Maxima eine Fehlermeldung aus. Im Folgenden werden Beispiele gezeigt:

    (%i1) list : [a,b,c];
    (%o1)                       [a, b, c]
    (%i2) list[1];
    (%o2)                           a
    (%i3) list[2];
    (%o3)                           b
    (%i4) list[3];
    (%o4)                           c
    (%i5) list[1]: sin(x);
    (%o5)                        sin(x)
    (%i6) list[2]: cos(x);
    (%o6)                        cos(x)
    (%i7) list[3]: tan(x);
    (%o7)                        tan(x)
    (%i8) list;
    (%o8)               [sin(x), cos(x), tan(x)]

Listen können auch als Argument einer Funktion auftreten. Hat die Funktion die Eigenschaft `distribute_over`, dann wird die Funktion auf die Elemente der Liste angewendet. Dies funktioniert auch für Funktionen mit mehreren Argumenten.

    (%i1) sin([x,y,z]);
    (%o1)               [sin(x), sin(y), sin(z)]
    (%i2) mod([x,y],3);
    (%o2)                [mod(x, 3), mod(y, 3)]
    (%i3) mod([x,y],[5,7]);
    (%o3)   [[mod(x, 5), mod(x, 7)], [mod(y, 5), mod(y, 7)]]

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.4.2 Funktionen und Variablen für Listen

Operator: [
Operator: ]

  Die Operatoren `[` und `]` markieren den Anfang und das Ende einer Liste.

  `[` und `]` schließen auch die Indizes von Symbolen, Arrays, Hash-Arrays oder Array-Funktionen ein.

  Beispiele:

      (%i1) x: [a, b, c];
      (%o1)                       [a, b, c]
      (%i2) x[3];
      (%o2)                           c
      (%i3) array (y, fixnum, 3);
      (%o3)                           y
      (%i4) y[2]: %pi;
      (%o4)                          %pi
      (%i5) y[2];
      (%o5)                          %pi
      (%i6) z['foo]: 'bar;
      (%o6)                          bar
      (%i7) z['foo];
      (%o7)                          bar
      (%i8) g[k] := 1/(k^2+1);
                                        1
      (%o8)                     g  := ------
                                 k     2
                                      k  + 1
      (%i9) g[10];
                                      1
      (%o9)                          ---
                                     101

Funktion: append (list_1, …, list_n)

  Gibt eine Liste mit den Elementen der Listen list_1, …, list_n zurück. Ist eines der Argumente list_1, …, list_n keine Liste meldet Maxima einen Fehler.

  `append` kann auch für allgemeine Ausdrücke genutzt werden. So hat zum Beispiel `append(f(a,b), f(c,d,e))` das Ergebnis `f(a,b,c,d,e)`. In diesem Fall muss der Operator, der hier `f` ist, für beide Ausdrücke identisch sein, ansonsten meldet Maxima einen Fehler.

  Siehe auch die Funktionen `cons` und `endcons`, um ein Element einer Liste hinzuzufügen.

  Beispiele:

  In den ersten Beispielen werden jeweils Listen mit verschiedenen Elementen zusammengefügt. Im letzten Beispiel wird `append` genutzt, um zwei Additionen zusammenzusetzen.

      (%i1) append([a,b], [x,y,z], [1]);
      (%o1)                  [a, b, x, y, z, 1]
      (%i2) append([x+y, 0, -3.2], [2.5e+20, x]);
      (%o2)             [y + x, 0, - 3.2, 2.5e+20, x]
      (%i3) append([2*a+b], [x+y]);
      (%o3)                   [b + 2 a, y + x]
      (%i4) append(2*a+b, x+y);
      (%o4)                    y + x + b + 2 a

Funktion: assoc (key, list, default)
Funktion: assoc (key, list)

  Ist das Argument `list` eine Liste mit paarweisen Elementen der Form `[[key_1, value_1], [key_2, value_2], ...]`, wobei key_i ein Schlüssel und value_i der dazugehörige Wert ist, dann gibt die Funktion `assoc` den zum Schlüssel key gehörenden Wert `value` zurück. Wird der Schlüssel nicht gefunden, wird das Argument `default` zurückgegeben, wenn es vorhanden ist, oder der Wert `false`.

  Anstatt Paare `[key_i, value_i]` können auch allgemeine Ausdrücke in der Liste enthalten sein, die zwei Argumente haben. Zum Beispiel sind Einträge der Form `x=1` oder `a^b` möglich. Im ersten Fall ist `x` der Schlüssel und im zweiten Fall `a`. Die Werte sind jeweils `1` und `b`.

  Beispiele:

      (%i1) l : [[info, 10], [warn, 20], [err, 30]];
      (%o1)          [[info, 10], [warn, 20], [err, 30]]
      (%i2) assoc(info, l);
      (%o2)                          10
      (%i3) assoc(warn, l);
      (%o3)                          20
      (%i4) assoc(err, l);
      (%o4)                          30
      (%i5) l : [x+y, a^(2*b), sin(x) = 0.5];
                                  2 b
      (%o5)              [y + x, a   , sin(x) = 0.5]
      (%i6) assoc(x, l);
      (%o6)                           y
      (%i7) assoc(y, l);
      (%o7)                         false
      (%i8) assoc(a, l);
      (%o8)                          2 b
      (%i9) assoc(sin(x), l);
      (%o9)                          0.5

Funktion: cons (expr, list)

  Fügt den Ausdruck expr als erstes Element der Liste list hinzu.

  `cons` arbeitet auch mit allgemeinen Ausdrücken als Argument list. In diesem Fall wird dem Hauptoperator des Arguments list der Ausdruck expr als erstes Argument hinzugefügt.

  Siehe auch die Funktion `endcons`, um ein Element an das Ende einer Liste anzuhängen sowie die Funktion `append`, um zwei Listen zusammenzufügen.

  Beispiele:

      (%i1) cons(x, [a, b, c]);
      (%o1)                     [x, a, b, c]
      (%i2) cons(x^2+1, [a, b, c]);
                                2
      (%o2)                   [x  + 1, a, b, c]
      (%i3) cons(x^2+1, a+b+c);
                              2
      (%o3)                  x  + c + b + a + 1
      (%i4) cons(x^2+1, f(a,b,c));
                                2
      (%o4)                  f(x  + 1, a, b, c)

Funktion: copylist (list)

  Gibt eine Kopie der Liste list zurück.

  Im Unterschied zur Funktion `copylist` wird mit dem Zuweisungsoperator `:` keine Kopie, sondern eine Referenz auf das Original zugewiesen. Das folgende Beispiel zeigt den Unterschied für den Fall, dass das Original modifiziert wird.

      (%i1) list : [x,y,z];
      (%o1)                       [x, y, z]
      (%i2) a: list;
      (%o2)                       [x, y, z]
      (%i3) b: copylist(list);
      (%o3)                       [x, y, z]
      (%i4) list[2]:99;
      (%o4)                          99
      (%i5) list;
      (%o5)                      [x, 99, z]
      (%i6) a;
      (%o6)                      [x, 99, z]
      (%i7) b;
      (%o7)                       [x, y, z]

Funktion: create_list (expr, x_1, list_1, …, x_n, list_n)

  Erzeugt eine Liste, indem der Ausdruck expr zunächst für die Variable x_1 ausgewertet wird. Der Variablen x_1 werden für die Auswertung nacheinander die Werte der Liste list_1 zugewiesen. Dann wird der Ausdruck expr für die Variable x_2 mit den Werten der Liste list_2 ausgewertet u.s.w. Die Anzahl der Elemente der Ergebnisliste ist das Produkt der Anzahl der Elemente der einzelnen Listen list_i. Die Variablen x_i müssen Symbole sein, die nicht ausgewertet werden. Die Elemente der Listen list_i werden vor der Iteration ausgewertet.

  Anstatt einer Liste list_i mit den Elementen für die Iteration kann auch eine untere und obere Grenze angegeben werden. Die Grenzen können ganze Zahlen oder Gleitkommazahlen sowie Ausdrücke sein, die zu einer Zahl auswerten. Die Schrittweite ist immer 1. Siehe auch das Beispiel weiter unten.

  Beispiele:

      (%i1) create_list(x^i, i, [1, 3, 7]);
                       3   7
      (%o1)       [x, x , x ]

  In diesem Beispiel wird für zwei Listen iteriert.

      (%i1) create_list([i, j], i, [a, b], j, [e, f, h]);
      (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]

  Anstatt einer Liste list_i können auch zwei Argumente übergeben werden, die jedes zu einer Nummer auswerten. Diese Werte sind die untere und die obere Grenze für die Iteration.

      (%i1) create_list([i,j],i,[1,2,3],j,1,i);
      (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]

Funktion: delete (expr, list)
Funktion: delete (expr, list, n)

  `delete(expr, list)` entfernt aus der Liste list die Elemente, die gleich dem Ausdruck expr sind. Mit dem Argument n kann die Anzahl der Elemente spezifiziert werden, die aus der Liste entfernt werden sollen. `delete` gibt eine neue Liste zurück. Das Argument list wird nicht modifiziert.

  Die Gleichheit wird mit dem Operator `=` geprüft. Daher werden nur Ausdrücke als gleich erkannt, die syntaktisch übereinstimmen. Äquivalente Ausdrücke, die syntaktisch voneinander verschieden sind, werden nicht aus der Liste entfernt. Zum Beispiel sind die Ausdrücke `x^2-1` und `(x+1)*(x-1)` äquivalent, aber syntaktisch verschieden.

  Das zweite Argument list kann auch ein allgemeiner Ausdruck sein. In diesem Fall werden die Argumente des Hauptoperators als die Elemente einer Liste angenommen.

  Beispiele:

  Entferne Elemente einer Liste.

      (%i1) delete (y, [w, x, y, z, z, y, x, w]);
      (%o1)                  [w, x, z, z, x, w]

  Entferne Terme einer Summe.

      (%i1) delete (sin(x), x + sin(x) + y);
      (%o1)                         y + x

  Entferne Faktoren eines Produkts.

      (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
      (%o1)                (u - w) (u - y) (u - z)

  Entferne Argumente einer Funktion.

      (%i1) delete (a, f(a, b, c, d, a));
      (%o1)                     f(b, c, d)

  Das Element `a` tritt mehrfach auf. Es werden zwei Elemente entfernt.

      (%i1) delete (a, f(a, b, a, c, d, a), 2);
      (%o1)                    f(b, c, d, a)

  Die Gleichheit wird mit dem Operator `=` geprüft.

      (%i1) [is(equal (0, 0)), is(equal (0, 0.0)), is(equal (0, 0b0))];

      `rat' replaced 0.0 by 0/1 = 0.0
      `rat' replaced 0.0B0 by 0/1 = 0.0B0
      (%o1)                  [true, true, true]
      (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
      (%o2)                 [true, false, false]
      (%i3) delete (0, [0, 0.0, 0b0]);
      (%o3)                     [0.0, 0.0b0]
      (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
      (%o4)                         true
      (%i5) is ((x + y)*(x - y) = x^2 - y^2);
      (%o5)                         false
      (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
                                    2    2
      (%o6)                       [x  - y ]

Funktion: endcons (expr, list)

  Fügt den Ausdruck expr als letztes Element der Liste list hinzu.

  `endcons` arbeitet auch mit allgemeinen Ausdrücken als Argument list. In diesem Fall wird dem Hauptoperator des Arguments list der Ausdruck expr als letztes Argument hinzugefügt.

  Siehe auch die Funktion `cons`, um ein Element am Anfang einer Liste einzufügen sowie die Funktion `append`, um zwei Listen zusammenzufügen.

  Beispiele:

      (%i1) endcons(x, [a, b, c]);
      (%o1)                     [a, b, c, x]
      (%i2) endcons(x^2+1, [a, b, c]);
                                         2
      (%o2)                   [a, b, c, x  + 1]
      (%i3) endcons(x^2+1, a+b+c);
                              2
      (%o3)                  x  + c + b + a + 1
      (%i4) endcons(x^2+1, f(a,b,c));
                                         2
      (%o4)                  f(a, b, c, x  + 1)

Funktion: first (list)

  Gibt das erste Element der Liste list zurück.

  Das Argument list kann auch ein allgemeiner Ausdruck wie zum Beispiel der Term einer Summe, der Faktor eines Produktes oder die erste Spalte einer Matrix sein. Die Funktion `first` und verwandte Funktionen wie `last` oder `rest` arbeiten mit der externen Darstellung eines Ausdrucks, wie sie in der Anzeige erscheint. Dies kann mit der Optionsvariablen `inflag` kontrolliert werden. Hat die Optionsvariable `inflag` den Wert `true`, wird von diesen Funktionen die interne Darstellung betrachtet.

  Die Funktionen `second` bis `tenth` geben jeweils das 2. bis 10. Element zurück.

  Beispiele:

      (%i1) l: [a,b,c];
      (%o1)                       [a, b, c]
      (%i2) first(l);
      (%o2)                           a
      (%i3) first(x + y);
      (%o3)                           y
      (%i4) first(x * y);
      (%o4)                           x
      (%i5) first(f(x, y, z));
      (%o5)                           x

Funktion: join (list_1, list_2)

  Erzeugt eine neue Liste aus den Elementen der Listen list_1 und list_2, wobei die Elemente abwechselnd übernommen werden. Das Ergebnis hat die Form `[list_1[1], list_2[1], list_1[2], list_2[2], ...]`.

  Haben die Listen verschiedene Längen, werden die zusätzlichen Elemente der längeren Liste ignoriert.

  Sind list_1 oder list_2 keine Listen, gibt Maxima einen Fehler aus.

  Beispiele:

      (%i1) L1: [a, sin(b), c!, d - 1];
      (%o1)                [a, sin(b), c!, d - 1]
      (%i2) join (L1, [1, 2, 3, 4]);
      (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
      (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
      (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]

Funktion: last (list)

  Gibt das letzte Element der Liste list zurück.

  Das Argument list kann auch ein allgemeiner Ausdruck sein. Siehe `first` für weitere Erläuterungen.

  Beispiele:

      (%i1) l: [a,b,c];
      (%o1)                       [a, b, c]
      (%i2) last(x + y);
      (%o2)                           x
      (%i3) last(x * y);
      (%o3)                           y
      (%i4) last(f(x, y, z));
      (%o4)                           z

Funktion: length (list)

  Gibt die Anzahl der Elemente der Liste list zurück.

  Das Argument list kann auch ein allgemeiner Ausdruck sein. Wie bei anderen Funktionen für Listen wird auch von der Funktion `length` die externe Darstellung eines Ausdrucks betrachtet, wie sie für die Ausgabe vorliegt. Die Optionsvariable `inflag` hat daher Einfluss auf das Ergebnis der Funktion `length`.

  Beispiele:

      (%i1) length([a, x^2, sin(x), y+3]);
      (%o1)                           4
      (%i2) length(a/(b*x));
      (%o2)                           2
      (%i3) length(a/(b*x)),inflag:true;
      (%o3)                           3

Optionsvariable: listarith

  Standardwert: `true`

  Hat die Optionsvariable `listarith` den Wert `true`, werden Rechenoperationen mit Matrizen und Listen elementweise ausgeführt. Das Ergebnis von Rechnungen mit Listen und Matrizen sind wieder Listen und Matrizen. Hat die Optionsvariable `listarith` den Wert `false`, wird die elementweise Ausführung der Rechenoperationen unterdrückt.

  Beispiele:

      (%i1) listarith: true;
      (%o1)                         true
      (%i2) 2 + [a, b, c];
      (%o2)                 [a + 2, b + 2, c + 2]
      (%i3) 2^[a, b, c];
                                  a   b   c
      (%o3)                     [2 , 2 , 2 ]
      (%i4) [1, 2, 3] + [a, b, c];
      (%o4)                 [a + 1, b + 2, c + 3]
      (%i5) listarith: false;
      (%o5)                         false
      (%i6) 2 + [a, b, c];
      (%o6)                     [a, b, c] + 2
      (%i7) 2^[a, b, c];
                                  [a, b, c]
      (%o7)                      2
      (%i8) [1, 2, 3] + [a, b, c];
      (%o8)                 [a, b, c] + [1, 2, 3]

Funktion: listp (expr)

  Gibt `true` zurück, wenn expr eine Liste ist. Ansonsten ist der Rückgabewert `false`.

Funktion: makelist (expr, i, i_0, i_1)
Funktion: makelist (expr, x, list)

  Erzeugt eine Liste, indem der Ausdruck expr für die Variable i ausgewertet wird. Die Variable i nimmt nacheinander die Werte von i_0 bis i_1 an, wobei die Schrittweite 1 ist. Alternativ kann eine Liste list als Argument übergeben werden. In diesem Fall nimmt die Variable i nacheinander die Werte der Liste list an.

  Siehe auch die Funktion `create_list`, um eine Liste zu generieren.

  Beispiele:

      (%i1) makelist(concat(x, i), i, 1, 6);
      (%o1)               [x1, x2, x3, x4, x5, x6]
      (%i2) makelist(x = y, y, [a, b, c]);
      (%o2)                 [x = a, x = b, x = c]

Funktion: member (expr, list)

  Gibt `true` zurück, wenn der Ausdruck expr gleich einem Element in der Liste list ist. Die Gleichheit wird dem Operator `=` festgestellt.

  Die Gleichheit wird mit dem Operator `=` geprüft. Daher werden nur Ausdrücke als gleich erkannt, die syntaktisch übereinstimmen. Äquivalente Ausdrücke, die syntaktisch voneinander verschieden sind, werden nicht aus der Liste entfernt. Zum Beispiel sind die Ausdrücke `x^2-1` und `(x+1)*(x-1)` äquivalent, aber syntaktisch verschieden.

  Das Argument list kann auch ein allgemeiner Ausdruck sein. Dabei werden die Argumente des Hauptoperators betrachtet.

  Siehe auch die Funktion `elementp`.

  Beispiele:

      (%i1) member (8, [8, 8.0, 8b0]);
      (%o1)                         true
      (%i2) member (8, [8.0, 8b0]);
      (%o2)                         false
      (%i3) member (b, [a, b, c]);
      (%o3)                         true
      (%i4) member (b, [[a, b], [b, c]]);
      (%o4)                         false
      (%i5) member ([b, c], [[a, b], [b, c]]);
      (%o5)                         true
      (%i6) F (1, 1/2, 1/4, 1/8);
                                     1  1  1
      (%o6)                     F(1, -, -, -)
                                     2  4  8
      (%i7) member (1/8, %);
      (%o7)                         true
      (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
      (%o8)                         true

Funktion: pop (list)

  Die Funktion `pop` entfernt das erste Element der Liste list und gibt dieses Element zurück. list muss ein Symbol sein, dem eine Liste zugewiesen wurde, und kann nicht selbst eine Liste sein.

  Ist dem Argument list keine Liste zugewiesen, gibt Maxima eine Fehlermeldung aus.

  Siehe auch die Funktion `push` für Beispiele.

  Mit dem Kommando `load(basic)` wird die Funktion geladen.

Funktion: push (item, list)

  Die Funktion `push` fügt das Argument item als erstes Element der Liste list hinzu und gibt die neue Liste zurück. Das Argument list muss ein Symbol sein, dem eine Liste zugewiesen wurde, und kann nicht selbst eine Liste sein. Das Argument item kann ein beliebiger Ausdruck sein.

  Ist dem Argument list keine Liste zugewiesen, gibt Maxima eine Fehlermeldung aus.

  Siehe auch die Funktion `pop`, um das erste Element einer Liste zu entfernen.

  Mit dem Kommando `load(basic)` wird die Funktion geladen.

  Beispiele:

      (%i1) ll:[];
      (%o1)                          []
      (%i2) push(x,ll);
      (%o2)                          [x]
      (%i3) push(x^2+y,ll);
                                       2
      (%o3)                      [y + x , x]
      (%i4) a:push("string",ll);
                                           2
      (%o4)                  [string, y + x , x]
      (%i5) pop(ll);
      (%o5)                        string
      (%i6) pop(ll);
                                        2
      (%o6)                        y + x
      (%i7) pop(ll);
      (%o7)                           x
      (%i8) ll;
      (%o8)                          []
      (%i9) a;
                                           2
      (%o9)                  [string, y + x , x]

Funktion: rest (list, n)
Funktion: rest (list)

  Entfernt das erste Element oder, wenn n eine positive ganze Zahl ist, die ersten n Elemente der Liste list und gibt den Rest der Liste als Ergebnis zurück. Ist n eine negative Zahl, werden die letzten n Elemente von der Liste entfernt und der Rest als Ergebnis zurückgegeben.

  Das Argument list kann auch ein allgemeiner Ausdruck sein.

  Siehe auch die Funktionen `first` und `last`.

  Beispiele:

      (%i1) rest([a,b,c]);
      (%o1)                        [b, c]
      (%i2) rest(a+b+c);
      (%o2)                         b + a

Funktion: reverse (list)

  Kehrt die Anordnung der Elemente einer Liste list um und gibt die Ergebnisliste zurück. Das Argument list kann auch ein allgemeiner Ausdruck sein.

  Beispiele:

      (%i1) reverse([a, b, c]);
      (%o1)                       [c, b, a]
      (%i2) reverse(sin(x)=2*x^2+1);
                                 2
      (%o2)                   2 x  + 1 = sin(x)

Funktion: second (list)
Funktion: third (list)
Funktion: fourth (list)
Funktion: fifth (list)
Funktion: sixth (list)
Funktion: seventh (list)
Funktion: eighth (list)
Funktion: ninth (list)
Funktion: tenth (list)

  Die Funktionen `second` bis `tenth` geben das 2. bis 10. Element eines Ausdrucks oder einer Liste list zurück. Siehe `first`.

Funktion: sort (L, P)
Funktion: sort (L)

  Sortiert eine Liste L und gibt die sortierte Liste zurück. Das optionale Argument P ist eine Aussagefunktion mit zwei Argumenten, die eine Ordnung der Elemente definiert. Die Aussagefunktion kann eine Funktion, ein binärer Operator oder ein Lambda-Ausdruck sein. Wird kein Argument P angegeben, werden die Elemente der Liste mit der Aussagefunktion `orderlessp` geordnet.

  Die Aussagefunktion `orderlessp` sortiert eine List aufsteigend. Mit der Aussagefunktion `ordergreatp` kann die Liste absteigend sortiert werden. Die Aussagefunktion `ordermagnitudep` sortiert Maxima Zahlen, Konstante oder Ausdrücke, die zu einer Zahl oder Konstanten ausgewertet werden können, nach der Größe. Mit dem Operator `<` kann auch nach der Größe sortiert werden. Im Unterschied zur Aussagefunktion `ordermagnitudep` ist die Ordnung nicht vollständig, wenn einzelne Elemente der Liste nicht vergleichbar unter dem Operator `<` sind.

  Beispiele:

      (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
            19 - 3 * x]);
                     5
      (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
                     2
      (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
            ordergreatp);
                                                         5
      (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                         2
      (%i3) sort ([%pi, 3, 4, %e, %gamma]);
      (%o3)                [3, 4, %e, %gamma, %pi]
      (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
      (%o4)                [%gamma, %e, 3, %pi, 4]
      (%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
      (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
      (%i6) sort (my_list);
      (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
      (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
            reverse (b))));
      (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]

  Ordne Maxima Zahlen, Konstante und konstante Ausdrücke nach der Größe. Alle anderen Elemente werden aufsteigend sortiert.

      (%i8) sort([%i,1+%i,2*x,minf,inf,%e,sin(1),0,1,2,3,1.0,1.0b0],
                 ordermagnitudep);
      (%o8) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
                                                           %i + 1, 2 x]

Funktion: sublist (L, P)

  Gibt die Elemente der Liste L als eine Liste zurück, für die die Aussagefunktion `P` das Ergebnis `true` hat. `P` ist eine Funktion mit einem Argument wie zum Beispiel die Funktion `integerp`. Siehe auch die Funktion `sublist_indices`.

  Beispiele:

      (%i1) L: [1, 2, 3, 4, 5, 6];
      (%o1)                  [1, 2, 3, 4, 5, 6]
      (%i2) sublist (L, evenp);
      (%o2)                       [2, 4, 6]

Funktion: sublist_indices (L, P)

  Gibt die Indizes der Elemente der Liste L zurück, für die die Aussagefunktion `P` das Ergebnis `true` hat. `P` ist eine Funktion mit einem Argument wie zum Beispiel die Funktion `integerp`. Siehe auch die Funktion `sublist`.

  Beispiele:

      (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
                             lambda ([x], x='b));
      (%o1)                     [2, 3, 7, 9]
      (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
      (%o2)                  [1, 2, 3, 4, 7, 9]
      (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
                             identity);
      (%o3)                       [1, 4, 5]
      (%i4) assume (x < -1);
      (%o4)                       [x < - 1]
      (%i5) map (maybe, [x > 0, x < 0, x < -2]);
      (%o5)                [false, true, unknown]
      (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
      (%o6)                          [2]

Funktion: unique (L)

  Gibt eine Liste mit den Elementen der Liste L zurück, die sich voneinander unterscheiden. Sind alle Elemente der Liste L verschieden, gibt `unique` eine Kopie der Liste L und nicht die Liste selbst zurück. Ist L keine Liste, gibt `unique` den Ausdruck L zurück.

  Beispiel:

      (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
      (%o1)              [1, 2, %e, %pi, [1], b + a]

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.5 Arrays

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.5.1 Einführung in Arrays

Am flexibelsten sind Arrays, die nicht deklariert werden, diese werden auch Hashed-Arrays genannt und entstehen dadurch, dass einer indizierten Variablen ein Wert zugewiesen wird. Die Indizes brauchen keine ganze Zahlen zu sein, es sind auch Symbole und Ausdrücke als Index möglich. Nicht-deklarierte Arrays wachsen dynamisch mit der Zuweisung von Werten an die Elemente. Im Folgenden wird ein nicht-deklariertes Array `a` durch Zuweisung von Werten erzeugt. Die Elemente des Arrays werden mit der Funktion `listarray` angezeigt.

    (%i1) a[1,2]: 99;
    (%o1)                          99
    (%i2) a[x,y]: x^y;
                                    y
    (%o2)                          x
    (%i3) listarray(a);
                                      y
    (%o3)                       [99, x ]

Von den nicht-deklarierten Arrays sind deklarierte Arrays zu unterscheiden. Diese haben bis zu 5 Dimensionen und können einen Typ wie `fixnum` oder `flonum` erhalten. Maxima unterscheidet zunächst zwei verschiedene Arten von deklarierten Arrays. Zum einen kann ein Symbol mit der Funktion `array` als ein deklariertes Array definiert werden. Eine andere Möglichkeit ist, mit der Funktion `make_array` ein Lisp-Array zu deklarieren, dass einem Symbol zugewiesen wird.

Das erste Beispiel zeigt die Deklaration eines Symbols `a` als ein Array. Im zweiten Beispiel wird ein Lisp-Array erzeugt, das dem Symbol `b` zugewiesen wird.

    (%i1) array(a, fixnum, 2, 2);
    (%o1)                           a
    (%i2) b: make_array(fixnum, 2, 2);
    (%o2)              {Array:  #2A((0 0) (0 0))}

Erhält die Optionsvariable `use_fast_arrays` den Wert `true`, werden ausschließlich Lisp-Arrays erzeugt. Im Folgenden wird auch von der Funktion `array` ein Lisp-Array erzeugt, dass dem Symbol `c` zugewiesen wird. Die Implementation der Funktionalität der Funktion `array` ist jedoch nicht vollständig, wenn Lisp-Arrays genutzt werden. So kann in diesem Beispiel nicht wie oben ein Array mit dem Typ `fixnum` definiert werden. Das ist ein Programmfehler.

    (%i3) use_fast_arrays: true;
    (%o3)                         true
    (%i4) array(c, 2, 2);
    (%o4)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
    (%i5) c;
    (%o5)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
    (%i6) array(c, fixnum, 2, 2);

    make_array: dimensions must be integers; found [fixnum + 1, 3, 3]
     -- an error. To debug this try: debugmode(true);

Maxima kennt weiterhin Array-Funktionen, die Funktionswerte speichern können, und indizierte Funktionen. Die hier beschriebenen Funktionen können auch auf diese Arrays angewendet werden. Siehe Array-Funktionen für eine Beschreibung.

Weitere Ausführungen sind bei der Beschreibung der einzelnen Funktionen zu finden. Maxima kennt folgende Funktionen und Symbole für das Arbeiten mit Arrays:

       array         arrayapply     arrayinfo
       arraymake     arrays         fillarray
       listarray     make_array     rearray
       remarray      subvar         subvarp
       use_fast_arrays

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 5.6 Strukturen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.6.1 Einführung in Strukturen

Maxima bietet eine einfache Möglichkeit, Daten in eine Struktur zusammenzufassen. Eine Struktur ist ein Ausdruck, in der die Argumente mit ihren Feldnamen bezeichnet werden und die Struktur als Ganzes mit dem Namen des Operators bezeichnet wird. Der Wert eines Feldes kann ein beliebiger Ausdruck sein.

Eine Struktur wird mit der Funktion `defstruct` definiert. Die Informationsliste `structures` enthält die vom Nutzer definierten Strukturen. Die Funktion `new` generiert eine neue Instanz einer Struktur. Mit dem Operator `@` wird auf die Felder einer Struktur zugegriffen. Mit dem Kommando `kill(S)` wird die Definition der Struktur `S` gelöscht. Mit dem Kommando `kill(x@a)` wird das Feld a der Instanz x einer Struktur gelöscht.

In der 2D-Anzeige werden die Felder von Instanzen einer Struktur als eine Gleichung angezeigt. Die linke Seite der Gleichung ist der Feldname und die rechte Seite der Gleichung ist der Wert des Feldes. Die Gleichungen werden nur in der Anzeige gezeigt und werden nicht als Teil der Struktur gespeichert. In der 1D-Anzeige und bei der Ausgabe mit der Funktion `grind` werden nur die Werte der Felder ausgegeben.

Ein Feldname kann nicht als der Name einer Funktion verwendet werden. Jedoch kann ein Feld einen Lambda-Ausdruck enthalten. Auch können die Felder nicht auf bestimmte Datentypen eingeschränkt werden. Einem Feld kann immer ein beliebiger Ausdruck zugewiesen werden. Weiterhin sind die Felder einer Struktur immer sichtbar. Der Zugriff auf ein Feld kann nicht eingeschränkt werden.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 5.6.2 Funktionen und Variablen für Strukturen

Systemvariable: structures

  `structures` ist eine Informationsliste, die die vom Benutzer mit der Funktion `defstruct` definierten Strukturen enthält.

Funktion: defstruct (S(a_1, …, a_n))
Funktion: defstruct (S(a_1 = v_1, …, a_n = v_n))

  Definiert eine Struktur, als eine Liste mit den Feldnamen a_1, …, a_n und dem Namen S für die Struktur. Eine Instanz einer Struktur ist ein Ausdruck mit dem Operator S und n Argumenten, die die Werte der Felder sind. Mit dem Kommando `new(S` wird eine neue Instanz einer Struktur S generiert. Siehe auch `new`.

  Mit einem Symbol a als Argument wird der Name eines Feldes bezeichnet. Mit einer Gleichung `a = v` wird der Name des Feldes als a bezeichnet und ein Standardwert v definiert. Der Standardwert v kann ein beliebiger Ausdruck sein.

  `defstruct` legt die Definition der Struktur S in der Informationsliste `structures` ab.

  Mit dem Kommando `kill(S)` wird die Definition einer Struktur gelöscht und von der Informationsliste `structures` entfernt.

  Beispiele:

      (%i1) defstruct (foo (a, b, c));
      (%o1)                    [foo(a, b, c)]
      (%i2) structures;
      (%o2)                    [foo(a, b, c)]
      (%i3) new (foo);
      (%o3)                     foo(a, b, c)
      (%i4) defstruct (bar (v, w, x = 123, y = %pi));
      (%o4)             [bar(v, w, x = 123, y = %pi)]
      (%i5) structures;
      (%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
      (%i6) new (bar);
      (%o6)              bar(v, w, x = 123, y = %pi)
      (%i7) kill (foo);
      (%o7)                         done
      (%i8) structures;
      (%o8)             [bar(v, w, x = 123, y = %pi)]

Funktion: new (S)
Funktion: new (S (v_1, …, v_n))

  `new` erzeugt eine neue Instanz einer Struktur.

  Das Kommando `new(S)` erzeugt eine neue Instanz der Struktur S, die mit der Funktion `defstruct` definiert wurde. Die Felder werden mit den Standardwerten belegt, wenn die Definition der Struktur Standardwerte enthält. Ansonsten erhalten die Felder keine Werte.

  Das Kommando `new(S(v_1, ..., v_n))` erzeugt eine neue Instanz der Struktur S, wobei die Felder mit den Werten v_1, …, v_n initialisiert werden.

  Beispiele:

      (%i1) defstruct (foo (w, x = %e, y = 42, z));
      (%o1)              [foo(w, x = %e, y = 42, z)]
      (%i2) new (foo);
      (%o2)               foo(w, x = %e, y = 42, z)
      (%i3) new (foo (1, 2, 4, 8));
      (%o3)            foo(w = 1, x = 2, y = 4, z = 8)

Operator: @

  `@` ist der Operator für den Zugriff auf ein Feld einer Struktur. Der Ausdruck `x@a` bezeichnet das Feld a der Instanz x einer Struktur. Der Feldname wird nicht ausgewertet.

  Hat das Feld a der Instanz x keinen Wert, wird der Ausdruck `x@a` zu sich selbst ausgewertet.

  `kill(x@a)` löscht den Wert des Feldes a der Instanz x einer Struktur.

  Beispiele:

      (%i1) defstruct (foo (x, y, z));
      (%o1)                    [foo(x, y, z)]
      (%i2) u : new (foo (123, a - b, %pi));
      (%o2)           foo(x = 123, y = a - b, z = %pi)
      (%i3) u@z;
      (%o3)                          %pi
      (%i4) u@z : %e;
      (%o4)                          %e
      (%i5) u;
      (%o5)            foo(x = 123, y = a - b, z = %e)
      (%i6) kill (u@z);
      (%o6)                         done
      (%i7) u;
      (%o7)              foo(x = 123, y = a - b, z)
      (%i8) u@z;
      (%o8)                          u@z

  Der Feldname wird nicht ausgewertet.

      (%i1) defstruct (bar (g, h));
      (%o1)                      [bar(g, h)]
      (%i2) x : new (bar);
      (%o2)                       bar(g, h)
      (%i3) x@h : 42;
      (%o3)                          42
      (%i4) h : 123;
      (%o4)                          123
      (%i5) x@h;
      (%o5)                          42
      (%i6) x@h : 19;
      (%o6)                          19
      (%i7) x;
      (%o7)                    bar(g, h = 19)
      (%i8) h;
      (%o8)                          123

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by U-CYGWINX\ASSI on diciembre, 18 2015 using texi2html 1.76.