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