Vorige: Einführung in Listen, Nach oben: Listen [Inhalt][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]
Vorige: Einführung in Listen, Nach oben: Listen [Inhalt][Index]