Vorige: Einführung in Mengen, Nach oben: Mengen [Inhalt][Index]
Vereinigt die Menge a mit {x} und gibt die vereinigte
Menge als Ergebnis zurück.
adjoin gibt eine Fehlermeldung, wenn das Argument a keine Menge
ist.
adjoin(x, a) und union(set(x), a) sind
äquivalent. Die Funktion adjoin kann etwas schneller als die Funktion
union sein.
Siehe auch die Funktion disjoin.
Beispiele:
(%i1) adjoin (c, {a, b});
(%o1) {a, b, c}
(%i2) adjoin (a, {a, b});
(%o2) {a, b}
Repräsentiert die \(n\)-te Bellsche Zahl.
Ist das Argument n eine nicht-negative ganze Zahl, vereinfacht
belln(n) zu der \(n\)-ten Bellschen Zahl. Für andere
Argumente vereinfacht die Funktion belln nicht.
Ist das Argument der Funktion belln eine Liste, Menge, Matrix oder
eine Gleichung, wird die Funktion auf die Elemente oder beide Seiten der
Gleichung angewendet.
Beispiele:
Anwendung der Funktion belln auf nicht-negative ganze Zahlen.
(%i1) makelist (belln (i), i, 0, 6);
(%o1) [1, 1, 2, 5, 15, 52, 203]
(%i2) is (cardinality (set_partitions ({})) = belln (0));
(%o2) true
(%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) =
belln (6));
(%o3) true
Anwendung der Funktion belln auf andere Argumente als nicht-negative
ganze Zahlen.
(%i1) [belln (x), belln (sqrt(3)), belln (-9)]; (%o1) [belln(x), belln(sqrt(3)), belln(- 9)]
Gibt die Mächtigkeit (Kardinalität) einer Menge zurück. Für endliche Mengen ist die Mächtigkeit die Anzahl der Elemente der Menge.
Die Funktion cardinality ignoriert redundante Elemente einer Menge auch
dann, wenn die Vereinfachung abgeschaltet ist.
Beispiele:
(%i1) cardinality ({});
(%o1) 0
(%i2) cardinality ({a, a, b, c});
(%o2) 3
(%i3) simp : false;
(%o3) false
(%i4) cardinality ({a, a, b, c});
(%o4) 3
Gibt das kartesische Produkt der Mengen b_1, …, b_n zurück. Das kartesische Produkt ist die Menge der geordneten Paare.
Das Ergebnis ist eine Menge mit Listen der Form [x_1, ...,
x_n], wobei x_1, …, x_n die Elemente der Mengen
b_1, …, b_n sind.
Die Funktion cartesian_product gibt eine Fehlermeldung, wenn eines
der Argumente keine Menge ist.
Beispiele:
(%i1) cartesian_product ({0, 1});
(%o1) {[0], [1]}
(%i2) cartesian_product ({0, 1}, {0, 1});
(%o2) {[0, 0], [0, 1], [1, 0], [1, 1]}
(%i3) cartesian_product ({x}, {y}, {z});
(%o3) {[x, y, z]}
(%i4) cartesian_product ({x}, {-1, 0, 1});
(%o4) {[x, - 1], [x, 0], [x, 1]}
Entfernt das Element x aus der Menge a und gibt das Ergebnis zurück.
disjoin gibt eine Fehlermeldung, wenn das Argument a keine Menge
ist.
Die Ausdrücke disjoin(x, a), delete(x,
a) und setdifference(a, set(x)) sind äquivalent.
Von diesen Möglichkeiten ist im Allgemeinen die Funktion disjoin am
schnellsten.
Siehe auch die Funktion adjoin sowie die Funktionen delete und
setdifference.
Beispiele:
(%i1) disjoin (a, {a, b, c, d});
(%o1) {b, c, d}
(%i2) disjoin (a + b, {5, z, a + b, %pi});
(%o2) {5, %pi, z}
(%i3) disjoin (a - b, {5, z, a + b, %pi});
(%o3) {5, %pi, b + a, z}
disjointp hat das Ergebnis true, wenn die Mengen a und
b disjunkt sind. Zwei Mengen sind disjunkt, wenn sie kein gemeinsames
Element besitzen.
disjointp gibt eine Fehlermeldung, wenn eines der Argumente keine
Menge ist.
Beispiele:
(%i1) disjointp ({a, b, c}, {1, 2, 3});
(%o1) true
(%i2) disjointp ({a, b, 3}, {1, 2, 3});
(%o2) false
Gibt die Menge der Teiler der Zahl n zurück.
Ist das Argument n eine von Null verschiedene ganze Zahl, vereinfacht
divisors(n) zu einer Menge mit ganzen Zahlen, die Teiler des
Argumentes n sind. Ist das Argument n eine negative Zahl wird
der Betrag des Argumentes genommen. Das Ergebnis enthält die Elemente
1 und n.
Ist das Argument der Funktion divisors eine Liste, Menge, Matrix oder
eine Gleichung, wird die Funktion auf die Elemente oder beide Seiten der
Gleichung angewendet.
Beispiele:
Das Beispiel zeigt, dass 28 eine perfekte Zahl ist, die gleich die Summe ihrer Teiler außer sich selbst ist.
(%i1) s: divisors(28);
(%o1) {1, 2, 4, 7, 14, 28}
(%i2) lreduce ("+", args(s)) - 28;
(%o2) 28
divisors ist eine vereinfachende Funktion. In diesem Beispiel braucht
daher der Ausdruck nach der Substitution nicht erneut ausgewertet werden.
(%i1) divisors (a);
(%o1) divisors(a)
(%i2) subst (8, a, %);
(%o2) {1, 2, 4, 8}
Anwendung der Funktion divisors auf Gleichungen, Listen, Matrizen oder
Mengen.
(%i1) divisors (a = b);
(%o1) divisors(a) = divisors(b)
(%i2) divisors ([a, b, c]);
(%o2) [divisors(a), divisors(b), divisors(c)]
(%i3) divisors (matrix ([a, b], [c, d]));
[ divisors(a) divisors(b) ]
(%o3) [ ]
[ divisors(c) divisors(d) ]
(%i4) divisors ({a, b, c});
(%o4) {divisors(a), divisors(b), divisors(c)}
Gibt true zurück, wenn das Argument x Element der Menge a
ist.
elementp gibt eine Fehlermeldung, wenn das Argument a keine
Menge ist.
Beispiele:
(%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
(%o1) true
(%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
(%o2) false
Gibt true zurück, wenn das Argument a die leere Menge oder eine
leere Liste ist.
Beispiele:
(%i1) map (emptyp, [{}, []]);
(%o1) [true, true]
(%i2) map (emptyp, [a + b, {{}}, %pi]);
(%o2) [false, false, false]
Gibt die Menge der Äquivalenzklassen der Menge s für die
Äquivalenzrelation F zurück.
Die Äquivalenzrelation F ist eine Funktion mit zwei Argumenten
definiert auf dem Kartesischen Produkt der Menge s mit s. Die
Rückgabe der Funktion F ist true oder false oder ein
Ausdruck expr, so dass is(expr) das Ergebnis true
oder false hat.
Ist F keine Äquivalenzrelation, wird die Funktion von
equiv_classes ohne Fehlermeldung akzeptiert. Das Ergebnis ist jedoch
im Allgemeinen nicht korrekt.
Beispiele:
Die Äquivalenzrelation ist ein Lambda-Ausdruck mit den Ergebnissen
true oder false.
(%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
lambda ([x, y], is (equal (x, y))));
(%o1) {{1, 1.0}, {2, 2.0}, {3, 3.0}}
Die Äquivalenzrelation ist der Name einer relationalen Funktion, die von
is zu true oder false ausgewertet wird.
(%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
(%o1) {{1, 1.0}, {2, 2.0}, {3, 3.0}}
Die Äquivalenzklassen sind Mengen mit Zahlen, die sich um ein Vielfaches von 3 voneinander unterscheiden.
(%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7},
lambda ([x, y], remainder (x - y, 3) = 0));
(%o1) {{1, 4, 7}, {2, 5}, {3, 6}}
Gibt das Ergebnis true zurück, wenn die Aussage f das Ergebnis
true für alle Elemente der Menge s hat.
Ist das zweite Argument eine Menge, dann gibt every(f, s)
den Wert true zurück, wenn is(f(a_i)) das Ergebnis
true für alle Elemente a_i der Menge s hat. every
wertet f nicht notwendigerweise für alle Elemente a_i aus, wenn
das Ergebnis bereits feststeht. Da Mengen nicht geordnet sind, kann die
Funktion every die Ausdrücke f(a_i) in irgendeiner
Reihenfolge auswerten.
Sind die Argumente eine oder mehrere Listen, dann gibt
every(f, L_1, ..., L_n) den Wert true zurück,
wenn is(f(x_1, ..., x_n)) das Ergebnis true
für alle x_1, …, x_n der Listen L_1, …,
L_n hat. every wertet f wird nicht notwendigerweise für
alle Kombinationen x_1, …, x_n aus, wenn das Ergebnis bereits
feststeht. every wertet die Listen in der Reihenfolge des steigenden
Index aus.
Ist die leere Menge oder leere Liste ein Argument der Funktion every,
dann ist das Ergebnis immer false.
Hat die Optionsvariable maperror den Wert true, müssen alle
Listen L_1, …, L_n die gleiche Länge haben. Hat die
Optionsvariable maperror den Wert false, werden die Listen auf
die Länge der kürzesten Liste abgeschnitten.
Kann die Aussagefunktion f von der Funktion is nicht zu true
oder false ausgewertet werden, hängt das Ergebnis von der
Optionsvariablen prederror ab. Hat die Optionsvariable prederror
den Wert true, werden solche Werte als false behandelt und die
Funktion every hat das Ergebnis false. Hat prederror
den Wert false, werden solche Werte als unknown behandelt und die
Funktion every hat das Ergebnis unknown.
Beispiele:
every angewendet auf eine Menge. Die Aussagefunktion hat ein Argument.
(%i1) every (integerp, {1, 2, 3, 4, 5, 6});
(%o1) true
(%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
(%o2) false
every angewendet auf zwei Listen. Die Aussagefunktion hat zwei
Argumente entsprechend der Anzahl der Listen.
(%i1) every ("=", [a, b, c], [a, b, c]);
(%o1) true
(%i2) every ("#", [a, b, c], [a, b, c]);
(%o2) false
Kann die Aussagefunktion f nicht zu true oder false
ausgewertet werden, hängt das Ergebnis von every von der
Optionsvariablen prederror ab.
(%i1) prederror : false;
(%o1) false
(%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
[x^2, y^2, z^2]);
(%o2) [unknown, unknown, unknown]
(%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
(%o3) unknown
(%i4) prederror : true;
(%o4) true
(%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
(%o5) false
Gibt die Teilmenge von s zurück, für die die Funktion f maximale oder minimale Ergebnisse hat.
extremal_subset(s, f, max) gibt die Teilmenge der Liste oder
Menge s zurück, für die die Funktion f ihre maximalen Werte
annimmt.
extremal_subset(s, f, min) gibt die Teilmenge der Liste oder
Menge s zurück, für die die Funktion f ihre minimalen Werte
annimmt.
Beispiele:
(%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
(%o1) {- 2, 2}
(%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
(%o2) {sqrt(2)}
Sammelt die Argumente von allen Teilausdrücken, die denselben Operator wie
der Ausdruck expr haben und konstruiert einen Ausdruck mit dem Operator
des Ausdrucks expr und den Argumenten. Ein einfaches Beispiel ist eine
verschachtelte Liste. flatten konstruiert in diesem Fall eine Liste
aus den Elementen aller Teillisten.
Teilausdrücke, deren Operator sich von dem Hauptoperator des Ausdrucks expr unterscheidet, werden als ein Argument betrachtet, auch wenn der Teilausdrück wiederum Teilausdrücke des Hauptoperators enthält.
Es ist möglich, dass flatten Ausdrücke konstruiert, in denen die
Anzahl der Argumente nicht der erforderlichen Anzahl an Argumenten des Operators
entspricht. Dies kann zu Fehlermeldungen bei der Auswertung oder Vereinfachung
führen. flatten kontrolliert nicht, ob die konstruierten Ausdrücke
gültig sind.
Ausdrücke mit speziellen Darstellungen, wie zum Beispiel CRE-Ausdrücke,
können von flatten nicht verarbeitet werden. In diesem Fällen gibt
flatten das Argument unverändert zurück.
Beispiele:
Wird flatten auf eine Liste angewendet, werden die Elemente aller
Teillisten zu einer Liste zusammengefügt.
(%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]); (%o1) [a, b, c, d, e, f, g, h, i, j]
Wird flatten auf eine Menge angewendet, werden die Elemente aller
Teilmengen zu einer Menge zusammengefügt.
(%i1) flatten ({a, {b}, {{c}}});
(%o1) {a, b, c}
(%i2) flatten ({a, {[a], {a}}});
(%o2) {a, [a]}
Die Funktionsweise von flatten ist vergleichbar mit der Deklaration eines
Operators als ein N-ary-Operator. Im Unterschied zu einer Deklaration hat
flatten keinen Einfluss auf Teilausdrücke, die einen vom Hauptoperator
verschiedenen Operator haben.
(%i1) expr: flatten (f (g (f (f (x))))); (%o1) f(g(f(f(x)))) (%i2) declare (f, nary); (%o2) done (%i3) ev (expr); (%o3) f(g(f(x)))
flatten kann Ausdrücke mit indizierte Funktionen vereinfachen.
(%i1) flatten (f[5] (f[5] (x, y), z));
(%o1) f (x, y, z)
5
Es ist möglich, dass flatten einen Ausdruck konstruiert, der nicht die
korrekte Anzahl an Argumenten eines Operators enthält.
(%i1) 'mod (5, 'mod (7, 4)); (%o1) mod(5, mod(7, 4)) (%i2) flatten (%); (%o2) mod(5, 7, 4) (%i3) ''%, nouns; Wrong number of arguments to mod -- an error. Quitting. To debug this try debugmode(true);
Ersetzt jedes Auftreten des Operators für Mengen in dem Ausdruck a durch den Operator für Listen. Die Ersetzung wird auch in verschachtelten Teilausdrücken ausgeführt, deren Operator nicht der Operator für Mengen ist.
Die Funktion listify ersetzt nur den Hauptoperator eines Ausdrucks.
Beispiele:
(%i1) full_listify ({a, b, {c, {d, e, f}, g}});
(%o1) [a, b, [c, [d, e, f], g]]
(%i2) full_listify (F (G ({a, b, H({c, d, e})})));
(%o2) F(G([a, b, H([c, d, e])]))
Ist a eine Liste, wird der Operator für Listen durch den Operator für
Mengen ersetzt. Dann wird fullsetify auf alle Argumente der Liste
angewendet. Ist ein Argument keine Liste, wenn das Argument unverändert
zurückgegeben.
Die Funktion setify ersetzt nur den Hauptoperator eines Ausdrucks.
Beispiele:
Im zweiten Beispiel wird das Argument der Funktion f nicht in eine
Menge konvertiert, da der Operator des Teilausdrucks keine Liste ist.
(%i1) fullsetify ([a, [a]]);
(%o1) {a, {a}}
(%i2) fullsetify ([a, f([b])]);
(%o2) {a, f([b])}
Gibt für jedes Argument x das Argument selbst zurück.
Beispiele:
identity kann als eine Aussagefunktion genutzt werden, wenn die Argumente
boolesche Werte sind.
(%i1) every (identity, [true, true]); (%o1) true
Ermittelt die Zerlegung einer ganzen Zahl n in ganze Zahlen, die n als Summe haben.
integer_partitions(n) gibt eine Menge aller Zerlegungen der ganzen
Zahl n zurück. Jede Zerlegung ist eine Liste mit den ganzen Zahlen, die
n als Summe haben. Die Listen sind nach der Größe sortiert.
integer_partitions(n, len) gibt eine Menge aller Zerlegungen
der ganzen Zahl n zurück, deren Listen len oder weniger Elemente
haben. Listen die weniger als len Elemente haben, werden mit Nullen
aufgefüllt.
Siehe auch die Funktionen num_partitions und
num_distinct_partitions.
Beispiele:
(%i1) integer_partitions (3);
(%o1) {[1, 1, 1], [2, 1], [3]}
(%i2) s: integer_partitions (25)$
(%i3) cardinality (s);
(%o3) 1958
(%i4) map (lambda ([x], apply ("+", x)), s);
(%o4) {25}
(%i5) integer_partitions (5, 3);
(%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
(%i6) integer_partitions (5, 2);
(%o6) {[3, 2], [4, 1], [5, 0]}
Um alle Zerlegungen zu finden, die eine Bedingung erfüllen, kann die Funktion
subset genutzt werden. In diesem Beispiel werden alle Zerlegungen
der Zahl 10 ermittelt, die nur Primzahlen enthalten.
(%i1) s: integer_partitions (10)$
(%i2) cardinality (s);
(%o2) 42
(%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
(%i4) subset (s, lambda ([x], every (xprimep, x)));
(%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}
intersect ist identisch mit der Funktion intersection.
Gibt die Schnittmenge der Mengen a_1, …, a_n zurück. Die Schnittmenge enthält die Elemente, die den Mengen gemeinsam sind.
intersection gibt eine Fehlermeldung, wenn eines der Argumente
keine Menge ist.
Beispiele:
(%i1) S_1 : {a, b, c, d};
(%o1) {a, b, c, d}
(%i2) S_2 : {d, e, f, g};
(%o2) {d, e, f, g}
(%i3) S_3 : {c, d, e, f};
(%o3) {c, d, e, f}
(%i4) S_4 : {u, v, w};
(%o4) {u, v, w}
(%i5) intersection (S_1, S_2);
(%o5) {d}
(%i6) intersection (S_2, S_3);
(%o6) {d, e, f}
(%i7) intersection (S_1, S_2, S_3);
(%o7) {d}
(%i8) intersection (S_1, S_2, S_3, S_4);
(%o8) {}
Ist die Kronecker-Delta-Funktion.
kron_delta vereinfacht zu 1, wenn die Argumente x_i und
y_i für alle Paare gleich sind, und zu 0, wenn x_i und
y_i nicht gleich sind für irgendein Paar der Argumente. Die Gleichheit
wird festgestellt mit is(equal(xi,xj)) und die Ungleichheit mit
is(notequal(xi,xj)). Wird nur ein Argument angegeben, signalisiert
die Funktion kron_delta einen Fehler.
Beispiele:
(%i1) kron_delta(a,a); (%o1) 1 (%i2) kron_delta(a,b,a,b); (%o2) kron_delta(a, b) (%i3) kron_delta(a,a,b,a+1); (%o3) 0 (%i4) assume(equal(x,y)); (%o4) [equal(x, y)] (%i5) kron_delta(x,y); (%o5) 1
Ist das Argument a eine Menge, werden die Elemente der Menge als eine Liste zurückgegeben. Ansonsten wird a zurückgegeben.
Siehe die Funktion full_listify, um auch Mengen in Teilausdrücken
von a durch Listen zu ersetzen.
Beispiele:
(%i1) listify ({a, b, c, d});
(%o1) [a, b, c, d]
(%i2) listify (F ({a, b, c, d}));
(%o2) F({a, b, c, d})
Wendet eine Funktion F, die zwei Argumente hat, auf die Elemente einer Liste s an, indem die Funktionsaufrufe verkettet werden.
Das Kommando lreduce(F, s) bildet den Ausdruck
F(... F(F(s_1, s_2), s_3), ... s_n). Ist das optionale Argument
s_0 vorhanden, dann ist das Ergebnis äquivalent zu
lreduce(F, cons(s_0, s)).
Siehe auch rreduce, xreduce und tree_reduce.
Beispiele:
lreduce ohne das optionale Argument.
(%i1) lreduce (f, [1, 2, 3]); (%o1) f(f(1, 2), 3) (%i2) lreduce (f, [1, 2, 3, 4]); (%o2) f(f(f(1, 2), 3), 4)
lreduce mit dem optionalen Argument.
(%i1) lreduce (f, [1, 2, 3], 4); (%o1) f(f(f(4, 1), 2), 3)
lreduce mit den binären Operatoren der Exponentiation "^" und der
Division "/".
(%i1) lreduce ("^", args ({a, b, c, d}));
b c d
(%o1) ((a ) )
(%i2) lreduce ("/", args ({a, b, c, d}));
a
(%o2) -----
b c d
Generiert eine Menge, indem der Ausdruck expr ausgewertet wird, wobei das Argument x eine Liste mit Variablen des Ausdrucks und s eine Menge oder eine Liste mit Listen ist. Ein Element der Menge wird generiert, indem die Variablen in x nacheinander an die Elemente in s gebunden werden.
Jedes Element des Argumentes s muss dieselbe Länge wie x haben. Die Liste der Variablen x muss eine List mit Symbolen sein. Indizierte Variablen sind nicht möglich. Auch wenn nur eine Variable angegeben wird, muss diese Element einer Liste sein und jedes Element von s muss eine Liste mit einem Element sein.
Siehe auch die Funktion makelist, um eine Liste zu generieren.
Beispiele:
(%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1 2 3 4
(%o1) {-, -, -, -}
a b c d
(%i2) S : {x, y, z}$
(%i3) S3 : cartesian_product (S, S, S);
(%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
[x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
[y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
[y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
[z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
[z, z, y], [z, z, z]}
(%i4) makeset (i + j + k, [i, j, k], S3);
(%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
z + 2 y, 2 z + x, 2 z + y}
(%i5) makeset (sin(x), [x], {[1], [2], [3]});
(%o5) {sin(1), sin(2), sin(3)}
Ist die Möbiusfunktion.
Ist die natürliche Zahl n quadratfrei, dann vereinfacht die
Möbiusfunktion zu -1^k, wobei k die Anzahl der Primfaktoren der
Zahl n ist. Eine Zahl ist quadratfrei, wenn sie nur voneinander
verschiedene Primfaktoren hat. Für n = 1 vereinfacht die
Möbiusfunktion zu 1 und für alle anderen positiven ganzen Zahlen zum
Wert 0. Für andere Argumente wird eine Substantivform als Ergebnis
zurückgegeben.
Ist das Argument der Funktion moebius eine Liste, Menge, Matrix oder
eine Gleichung, wird die Funktion auf die Elemente oder beide Seiten der
Gleichung angewendet.
Beispiele:
(%i1) moebius (1);
(%o1) 1
(%i2) moebius (2 * 3 * 5);
(%o2) - 1
(%i3) moebius (11 * 17 * 29 * 31);
(%o3) 1
(%i4) moebius (2^32);
(%o4) 0
(%i5) moebius (n);
(%o5) moebius(n)
(%i6) moebius (n = 12);
(%o6) moebius(n) = 0
(%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
(%o7) [- 1, 1, 1]
(%i8) moebius (matrix ([11, 12], [13, 14]));
[ - 1 0 ]
(%o8) [ ]
[ - 1 1 ]
(%i9) moebius ({21, 22, 23, 24});
(%o9) {- 1, 0, 1}
Gibt den Multinomialkoeffizienten zurück. Im Spezialfall k = 2
ergibt sich die Binomialverteilung. Siehe binomial.
Enthält das Ergebnis Fakultäten, kann das Ergebnis möglicherweise mit der
Funktion minfactorial weiter vereinfacht werden.
Beispiele:
(%i1) multinomial_coeff (1, 2, x);
(x + 3)!
(%o1) --------
2 x!
(%i2) minfactorial (%);
(x + 1) (x + 2) (x + 3)
(%o2) -----------------------
2
(%i3) multinomial_coeff (-6, 2);
(- 4)!
(%o3) --------
2 (- 6)!
(%i4) minfactorial (%);
(%o4) 10
Gibt die Anzahl der Möglichkeiten an, eine natürliche Zahl n in Summanden zu zerlegen, wobei jeder Summand nur einmal vorkommt. Ist n keine natürliche Zahl wird eine Substantivform als Ergebnis zurückgegeben.
num_distinct_partitions(n, list) gibt eine Liste mit der Anzahl
der voneinander verschiedenen Partitionen der natürlichen Zahlen 1, 2, 3,
…, n zurück.
Siehe auch die Funktionen num_partitions und integer_partitions.
Beispiele:
(%i1) num_distinct_partitions (12); (%o1) 15 (%i2) num_distinct_partitions (12, list); (%o2) [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15] (%i3) num_distinct_partitions (n); (%o3) num_distinct_partitions(n)
Gibt die Anzahl der Möglichkeiten an, eine natürliche Zahl n in Summanden zu zerlegen. Ist n keine natürliche Zahl wird eine Substantivform als Ergebnis zurückgegeben.
num_partitions(n, list) gibt eine Liste mit der Anzahl
der Partitionen der natürlichen Zahlen 1, 2, 3, …, n zurück.
Das Kommando num_partitions(n) ist für eine natürliche Zahl
n äquivalent zu cardinality(integer_partitions(n)).
Da die Funktion num_partitions die Menge nicht konstruiert, ist diese
Funktion deutlich schneller.
Siehe auch die Funktionen num_distinct_partitions und
integer_partitions.
Beispiele:
(%i1) num_partitions (5) = cardinality (integer_partitions (5)); (%o1) 7 = 7 (%i2) num_partitions (8, list); (%o2) [1, 1, 2, 3, 5, 7, 11, 15, 22] (%i3) num_partitions (n); (%o3) num_partitions(n)
Zerlegt eine Menge a mit der Aussagefunktion f.
partition_set gibt eine Liste mit zwei Elementen zurück. Das erste
Element ist die Menge der Elemente, für die die Aussagefunktion f zu
false ausgewertet wird. Das zweite Element ist die Menge aller anderen
Elemente. partition_set wendet nicht die Funktion is auf das
Ergebnis der Aussagefunktion f an.
partition_set gibt eine Fehlermeldung, wenn a keine Menge ist.
Siehe auch die Funktion subset.
Beispiele:
(%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
(%o1) [{1, 7}, {2, 8}]
(%i2) partition_set ({x, rat(y), rat(y) + z, 1},
lambda ([x], ratp(x)));
(%o2)/R/ [{1, x}, {y, y + z}]
Gibt eine Menge mit allen voneinander verschiedenen Permutationen der Elemente der Liste oder Menge a zurück. Die Permutationen sind Listen.
Ist das Argument a eine Liste, werden auch doppelte Elemente in die möglichen Permutationen eingeschlossen.
permutations gibt eine Fehlermeldung, wenn a keine Liste oder
Menge ist.
Siehe auch die Funktion random_permutation.
Beispiele:
(%i1) permutations ([a, a]);
(%o1) {[a, a]}
(%i2) permutations ([a, a, b]);
(%o2) {[a, a, b], [a, b, a], [b, a, a]}
Gibt die Menge aller Teilmengen der Menge a oder eine Teilmenge dieser Menge zurück.
powerset(a) gibt die Menge aller Teilmengen der Menge a
zurück. Die Ergebnismenge hat 2^cardinality(a) Elemente.
powerset(a, n) gibt die Menge aller Teilmengen der Menge
a zurück, die die Mächtigkeit n haben.
powerset gibt eine Fehlermeldung, wenn a keine Menge oder n
keine natürliche Zahl ist.
Beispiele:
(%i1) powerset ({a, b, c});
(%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
(%i2) powerset ({w, x, y, z}, 4);
(%o2) {{w, x, y, z}}
(%i3) powerset ({w, x, y, z}, 3);
(%o3) {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
(%i4) powerset ({w, x, y, z}, 2);
(%o4) {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
(%i5) powerset ({w, x, y, z}, 1);
(%o5) {{w}, {x}, {y}, {z}}
(%i6) powerset ({w, x, y, z}, 0);
(%o6) {{}}
Gibt eine zufällige Permutation der Menge oder Liste a zurück, die mit dem Knuth-Misch-Algorithmus generiert wird.
Die Rückgabe ist eine neue Liste, die verschieden vom Argument a. Jedoch werden nicht die Elemente kopiert.
Beispiele:
(%i1) random_permutation ([a, b, c, 1, 2, 3]);
(%o1) [c, 1, 2, 3, a, b]
(%i2) random_permutation ([a, b, c, 1, 2, 3]);
(%o2) [b, 3, 1, c, a, 2]
(%i3) random_permutation ({x + 1, y + 2, z + 3});
(%o3) [y + 2, z + 3, x + 1]
(%i4) random_permutation ({x + 1, y + 2, z + 3});
(%o4) [x + 1, y + 2, z + 3]
Wendet eine Funktion F, die zwei Argumente hat, auf die Elemente einer Liste s an, indem die Funktionsaufrufe verkettet werden.
Das Kommando rreduce(F, s) bildet den Ausdruck
F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n))). Ist das optionale
Argument s_0 vorhanden, dann ist das Ergebnis äquivalent zu
rreduce(F, endcons(s_{n + 1}, s)).
Siehe auch lreduce, xreduce und tree_reduce.
Beispiele:
rreduce ohne das optionale Argument.
(%i1) rreduce (f, [1, 2, 3]); (%o1) f(1, f(2, 3)) (%i2) rreduce (f, [1, 2, 3, 4]); (%o2) f(1, f(2, f(3, 4)))
rreduce mit dem optionalen Argument.
(%i1) rreduce (f, [1, 2, 3], 4); (%o1) f(1, f(2, f(3, 4)))
rreduce mit den binären Operatoren der Exponentiation "^" und der
Division "/".
(%i1) rreduce ("^", args ({a, b, c, d}));
d
c
b
(%o1) a
(%i2) rreduce ("/", args ({a, b, c, d}));
a c
(%o2) ---
b d
Gibt eine Menge mit den Elementen zurück, die in der Menge a, aber nicht in der Menge b enthalten sind.
setdifference gibt eine Fehlermeldung, wenn die Argumente a oder
b keine Mengen sind.
Beispiele:
(%i1) S_1 : {a, b, c, x, y, z};
(%o1) {a, b, c, x, y, z}
(%i2) S_2 : {aa, bb, c, x, y, zz};
(%o2) {aa, bb, c, x, y, zz}
(%i3) setdifference (S_1, S_2);
(%o3) {a, b, z}
(%i4) setdifference (S_2, S_1);
(%o4) {aa, bb, zz}
(%i5) setdifference (S_1, S_1);
(%o5) {}
(%i6) setdifference (S_1, {});
(%o6) {a, b, c, x, y, z}
(%i7) setdifference ({}, S_1);
(%o7) {}
Gibt das Ergebnis true zurück, wenn die Mengen a und b
dieselbe Anzahl an Elementen haben und der Ausdruck is(x = y)
das Ergebnis true für alle Elemente x der Menge a und
y der Menge b hat. Dabei haben die Elemente eine Ordnung wie sie
von der Funktion listify generiert wird. Ansonsten ist das Ergebnis
false.
Beispiele:
(%i1) setequalp ({1, 2, 3}, {1, 2, 3});
(%o1) true
(%i2) setequalp ({a, b, c}, {1, 2, 3});
(%o2) false
(%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
(%o3) false
Konstruiert eine Menge aus den Elementen der Liste a. Doppelte Elemente
der Liste a werden entfernt und die Elemente werden mit der
Aussagefunktion orderlessp sortiert.
setify gibt eine Fehlermeldung, wenn a keine Liste ist.
Beispiele:
(%i1) setify ([1, 2, 3, a, b, c]);
(%o1) {1, 2, 3, a, b, c}
(%i2) setify ([a, b, c, a, b, c]);
(%o2) {a, b, c}
(%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
(%o3) {1, 3, 5, 7, 9, 11, 13}
Gibt das Ergebnis true zurück, wenn das Argument a eine Menge
ist.
setp gibt true auch für Mengen zurück, die noch nicht
vereinfacht sind, also möglicherweise doppelte Elemente enthalten.
setp ist äquivalent zu dem Kommando setp(a) := not atom(a)
and op(a) = 'set.
Beispiele:
(%i1) simp : false;
(%o1) false
(%i2) {a, a, a};
(%o2) {a, a, a}
(%i3) setp (%);
(%o3) true
Gibt die Menge aller Partitionen der Menge a oder eine Teilmenge dieser Menge zurück.
set_partitions(a, n) gibt eine Menge aller Zerlegungen der
Menge a in n nicht-leere voneinander disjunkte Teilmengen zurück.
set_partitions(a) gibt die Menge aller Zerlegungen zurück.
stirling2 gibt die Mächtigkeit einer Menge zurück, die alle
Zerlegungen einer Menge enthält.
Eine Menge mit Zerlegungen \(P\) ist eine Zerlegung der Menge \(S\), wenn
Beispiele:
Die leere Menge ist eine Zerlegung von sich selbst.
(%i1) set_partitions ({});
(%o1) {{}}
Die Mächtigkeit der Menge der Zerlegungen einer Menge kann mit der Funktion
stirling2 ermittelt werden.
(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$
(%i3) cardinality(p) = stirling2 (6, 3);
(%o3) 90 = 90
Jedes Element der Menge p hat 3 Elemente.
(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$
(%i3) map (cardinality, p);
(%o3) {3}
Für jedes Element der Menge p, ist die Vereinigung ihrer Elemente
gleich der Menge s.
(%i1) s: {0, 1, 2, 3, 4, 5}$
(%i2) p: set_partitions (s, 3)$
(%i3) map (lambda ([x], apply (union, listify (x))), p);
(%o3) {{0, 1, 2, 3, 4, 5}}
Gibt das Ergebnis true zurück, wenn die Aussage f das Ergebnis
true für eines oder mehrere Argumente hat.
Ist eine Menge a als Argument gegeben, gibt some(f, s)
das Ergebnis true zurück, wenn is(f(a_i)) das Ergebnis
true für eines oder mehrere Elemente a_i der Menge a hat.
some wertet f nicht notwendigerweise für alle Elemente a_i
aus, wenn das Ergebnis bereits feststeht. Da Mengen nicht geordnet sind, kann
die Funktion some die Ausdrücke f(a_i) in
irgendeiner Reihenfolge auswerten.
Sind die Argumente eine oder mehrere Listen, dann gibt
some(f, L_1, ..., L_n) den Wert true zurück,
wenn is(f(x_1, ..., x_n)) das Ergebnis true
für eines oder mehrere Elemente x_1, …, x_n der Listen
L_1, …, L_n hat. some wertet f wird nicht
notwendigerweise für alle Kombinationen x_1, …, x_n aus,
wenn das Ergebnis bereits feststeht. some wertet die Listen in der
Reihenfolge des steigenden Index aus.
Ist die leere Menge {} oder die leere Liste [] unter den
Argumenten, ist das Ergebnis immer false.
Hat die Optionsvariable maperror den Wert true, müssen alle
Listen L_1, …, L_n die gleiche Länge haben. Hat die
Optionsvariable maperror den Wert false, werden Listen auf die
Länge der kürzesten Liste abgeschnitten.
Kann die Aussagefunktion f von der Funktion is nicht zu true
oder false ausgewertet werden, hängt das Ergebnis von der
Optionsvariablen prederror ab. Hat die Optionsvariable prederror
den Wert true, werden solche Werte als false behandelt. Hat
prederror den Wert false, werden solche Werte als unknown
behandelt.
Beispiele:
some für eine Menge als Argument. Die Aussage ist eine Funktion mit
einem Argument.
(%i1) some (integerp, {1, 2, 3, 4, 5, 6});
(%o1) true
(%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
(%o2) true
some angewendet auf zwei Listen. Die Aussage ist eine Funktion mit
zwei Argumenten.
(%i1) some ("=", [a, b, c], [a, b, c]);
(%o1) true
(%i2) some ("#", [a, b, c], [a, b, c]);
(%o2) false
Ergebnisse der Aussage f, die zu einem Ergebnis verschieden von
true oder false auswerten, werden von der Optionsvariablen
prederror kontrolliert.
(%i1) prederror : false;
(%o1) false
(%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
[x^2, y^2, z^2]);
(%o2) [unknown, unknown, unknown]
(%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
(%o3) unknown
(%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
(%o4) true
(%i5) prederror : true;
(%o5) true
(%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
(%o6) false
(%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
(%o7) true
Berechnet Stirling-Zahlen der ersten Art.
Sind die Argumente n und m natürliche Zahlen, ist der Wert von
stirling1(n, m) die Anzahl der Permutationen einer Menge
mit n Elementen, die m Zyklen hat. Für Details siehe Graham,
Knuth und Patashnik in Conrecte Mathematics. Maxima nutzt eine Rekursion,
um stirling1(n, m) für m kleiner als 0 zu
berechnen. Die Funktion ist nicht definiert für n kleiner als 0
und für Argumente die keine ganze Zahlen sind.
stirling1 ist eine vereinfachende Funktion. Maxima kennt die folgenden
Beziehungen (siehe [1]).
stirling1(0, n) = kron_delta(0, n)
stirling1(n, n) = 1
stirling1(n, n - 1) = binomial(n, 2)
stirling1(n + 1, 0) = 0
stirling1(n + 1, 1) = n!
stirling1(n + 1, 2) = 2^n - 1
Diese Beziehungen werden angewendet, wenn die Argumente ganze Zahlen oder
Symbole sind, die als ganze Zahlen deklariert sind, und das erste Argument
keine negative Zahl ist. stirling1 vereinfacht nicht für Argumente,
die keine ganzen Zahlen sind.
Referenz:
[1] Donald Knuth, The Art of Computer Programming, third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
Beispiele:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling1 (n, n); (%o3) 1
stirling1 vereinfacht nicht für Argumente, die keine ganzen Zahlen
sind.
(%i1) stirling1 (sqrt(2), sqrt(2)); (%o1) stirling1(sqrt(2), sqrt(2))
Maxima kennt Vereinfachungen der Funktion stirling1.
(%i1) declare (n, integer)$
(%i2) assume (n >= 0)$
(%i3) stirling1 (n + 1, n);
n (n + 1)
(%o3) ---------
2
(%i4) stirling1 (n + 1, 1);
(%o4) n!
Berechnet Stirling-Zahlen der zweiten Art.
Sind die Argumente n und m natürliche Zahlen, ist der Wert von
stirling2(n, m) die Anzahl der Möglichkeiten, mit der eine
Menge der Mächtigkeit n in m disjunkte Mengen zerlegt werden kann.
Maxima nutzt eine Rekursion, um stirling2(n, m) für m
kleiner als 0 zu berechnen. Die Funktion ist nicht definiert für
n kleiner als 0 und für Argumente, die keine ganze Zahlen sind.
stirling2 ist eine vereinfachende Funktion. Maxima kennt die folgenden
Beziehungen (siehe [1], [2], [3]).
stirling2(0, n) = kron_delta(0, n)
stirling2(n, n) = 1
stirling2(n, n - 1) = binomial(n, 2)
stirling2(n + 1, 1) = 1
stirling2(n + 1, 2) = 2^n - 1
stirling2(n, 0) = kron_delta(n, 0)
stirling2(n, m) = 0 für m > n
stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!, wenn
\(m\) und \(n\) ganze Zahlen und \(n\) eine natürliche Zahl ist.
Diese Beziehungen werden angewendet, wenn die Argumente ganze Zahlen oder
Symbole sind, die als ganze Zahlen deklariert sind, und das erste Argument
keine negative Zahl ist. stirling2 vereinfacht nicht für Argumente,
die keine ganzen Zahlen sind.
Referenzen:
[1] Donald Knuth. The Art of Computer Programming, third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
[2] Graham, Knuth, and Patashnik. Concrete Mathematics, Table 264.
[3] Abramowitz and Stegun. Handbook of Mathematical Functions, Section 24.1.4.
Beispiele:
(%i1) declare (n, integer)$ (%i2) assume (n >= 0)$ (%i3) stirling2 (n, n); (%o3) 1
stirling2 vereinfacht nicht, wenn die Argumente keine ganze Zahlen sind.
(%i1) stirling2 (%pi, %pi); (%o1) stirling2(%pi, %pi)
Maxima kennt Vereinfachungen der Funktion stirling2.
(%i1) declare (n, integer)$
(%i2) assume (n >= 0)$
(%i3) stirling2 (n + 9, n + 8);
(n + 8) (n + 9)
(%o3) ---------------
2
(%i4) stirling2 (n + 1, 2);
n
(%o4) 2 - 1
Gibt eine Teilmenge der Menge a zurück, deren Elemente der Bedingung f genügen.
subset gibt eine Menge zurück, die alle Elemente der Menge a
enthält, die für die Bedingung f ein von false verschiedenes
Ergebnis haben. subset wendet nicht die Funktion is auf das
Ergebnis der Bedingung f an.
subset gibt eine Fehlermeldung, wenn das Argument a keine Menge
ist.
Siehe auch die Funktion partition_set.
Beispiele:
(%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
(%o1) {1, 2, x, z}
(%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
(%o2) {2, 8, 14}
Gibt das Ergebnis true zurück, wenn die Menge a einer Teilmenge
der Menge b ist.
subsetp gibt eine Fehlermeldung, wenn eines der Argumente keine Menge
ist.
Beispiele:
(%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
(%o1) true
(%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
(%o2) false
Gibt die symmetrische Differenz der Mengen a_1, ..., a_n
zurück. Für zwei Argumente ist die symmetrische Differenz äquivalent zu
union(setdifference(a, b), setdifference(b, a)).
symmdifference gibt eine Fehlermeldung, wenn eines der Argumente keine
Menge ist.
Beispiele:
(%i1) S_1 : {a, b, c};
(%o1) {a, b, c}
(%i2) S_2 : {1, b, c};
(%o2) {1, b, c}
(%i3) S_3 : {a, b, z};
(%o3) {a, b, z}
(%i4) symmdifference ();
(%o4) {}
(%i5) symmdifference (S_1);
(%o5) {a, b, c}
(%i6) symmdifference (S_1, S_2);
(%o6) {1, a}
(%i7) symmdifference (S_1, S_2, S_3);
(%o7) {1, b, z}
(%i8) symmdifference ({}, S_1, S_2, S_3);
(%o8) {1,b, z}
Wendet eine Funktion F, die zwei Argumente hat, auf die Elemente einer Liste oder Menge s an, indem die Funktionsaufrufe verkettet werden.
tree_reduce führt folgende Operationen aus: Die Funktion F wird
auf Paare von Elementen der Liste s angewendet, wodurch die neue Liste
[F(s_1, s_2), F(s_3, s_4), ...]
entsteht. Hat die Liste eine ungerade Anzahl an Elementen, bleibt das letzte
Element unverändert. Dann wird das Verfahren solange wiederholt, bis nur noch
ein einziges Element übrig ist. Dieses wird als Ergebnis zurückgegeben.
Ist das optionale Argument s_0 vorhanden, dann ist das Ergebnis
äquivalent zu tree_reduce(F, cons(s_0, s).
Werden Gleitkommazahlen addiert, dann kann tree_reduce ein Ergebnis
mit einem kleineren Rundungsfehler als lreduce oder rreduce
liefern.
Siehe auch lreduce, rreduce und xreduce.
Beispiele:
tree_reduce angewendet auf eine Liste mit einer geraden Anzahl an
Elementen.
(%i1) tree_reduce (f, [a, b, c, d]); (%o1) f(f(a, b), f(c, d))
tree_reduce angewendet auf eine List mit einer ungeraden Anzahl an
Elementen.
(%i1) tree_reduce (f, [a, b, c, d, e]); (%o1) f(f(f(a, b), f(c, d)), e)
Gibt die Vereinigung der Mengen a_1, …, a_n zurück. Wird
union ohne ein Argument aufgerufen, wird die leere Menge zurückgegeben.
union gibt eine Fehlermeldung, wenn eines der Argumente keine Menge ist.
Beispiele:
(%i1) S_1 : {a, b, c + d, %e};
(%o1) {%e, a, b, d + c}
(%i2) S_2 : {%pi, %i, %e, c + d};
(%o2) {%e, %i, %pi, d + c}
(%i3) S_3 : {17, 29, 1729, %pi, %i};
(%o3) {17, 29, 1729, %i, %pi}
(%i4) union ();
(%o4) {}
(%i5) union (S_1);
(%o5) {%e, a, b, d + c}
(%i6) union (S_1, S_2);
(%o6) {%e, %i, %pi, a, b, d + c}
(%i7) union (S_1, S_2, S_3);
(%o7) {17, 29, 1729, %e, %i, %pi, a, b, d + c}
(%i8) union ({}, S_1, S_2, S_3);
(%o8) {17, 29, 1729, %e, %i, %pi, a, b, d + c}
Wendet eine Funktion F, die zwei Argumente hat, auf die Elemente einer
Liste oder Menge s an, indem die Funktionsaufrufe verkettet werden. Ist
die Funktion eine N-ary-Funktion wird die Funktion F auf die Liste
angewendet. Ist die Funktion F keine N-ary_Funktion ist xreduce
äquivalent zu lreduce.
Folgende N-ary-Funktionen und Operatoren kennt xreduce:
Addition "+", Multiplikation "*", and, or,
max, min und append. Funktionen und Operatoren können
mit der Funktion declare als nary deklariert werden. Für diese
Funktionen ist xreduce schneller als lreduce oder
rreduce.
Ist das optionale Argument s_0 vorhanden, dann ist das Ergebnis
äquivalent zu xreduce(s, cons(s_0, s)).
Siehe auch lreduce, rreduce und tree_reduce.
Beispiele:
xreduce angewendet mit einer N-ary-Funktion. F wird einmal mit
allen Argumenten aufgerufen.
(%i1) declare (F, nary);
(%o1) done
(%i2) F ([L]) := L;
(%o2) F([L]) := L
(%i3) xreduce (F, [a, b, c, d, e]);
(%o3) [[[[[("[", simp), a], b], c], d], e]
xreduce angewendet mit einer Funktion, die nicht die Eigenschaft
nary hat.
(%i1) G ([L]) := L;
(%o1) G([L]) := L
(%i2) xreduce (G, [a, b, c, d, e]);
(%o2) [[[[[("[", simp), a], b], c], d], e]
(%i3) lreduce (G, [a, b, c, d, e]);
(%o3) [[[[a, b], c], d], e]
Vorige: Einführung in Mengen, Nach oben: Mengen [Inhalt][Index]