[ < ] [ > ]   [ << ] [ 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 Robert on Juli, 9 2012 using texi2html 1.76.