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

14. Mengen


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

14.1 Einführung in Mengen

Maxima hat Funktionen wie den Schnitt und die Vereinigung von endlichen Mengen, die durch eine explizite Aufzählung definiert werden können. Listen und Mengen sind in Maxima unterschiedliche Objekte und können selbst Elemente von Mengen sein. Siehe auch Listen.

Neben den Funktionen für Mengen, enthält dieses Kapitel weitere Funktionen der Kombinatorik. Darunter die Stirling-Zahlen der ersten und zweiten Art, die Bellschen Zahlen, Multinomialverteilungen, Partitionsfunktionen oder die Kronecker-Delta-Funktion.


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

14.1.1 Anwendung

Mit set(a_1, ..., a_n) oder {a_1, ..., a_n} wird eine Menge mit den Elementen a_1, ..., a_n konstruiert. Die leere Menge wird mit set() oder {} angegeben. Mengen werden immer mit geschweiften Klammern angezeigt. Werden Elemente mehrmals angegeben, werden die doppelten Elemente aus der Menge entfernt.

Beispiele:

(%i1) set();
(%o1)                          {}
(%i2) set(a, b, a);
(%o2)                        {a, b}
(%i3) set(a, set(b));
(%o3)                       {a, {b}}
(%i4) set(a, [b]);
(%o4)                       {a, [b]}
(%i5) {};
(%o5)                          {}
(%i6) {a, b, a};
(%o6)                        {a, b}
(%i7) {a, {b}};
(%o7)                       {a, {b}}
(%i8) {a, [b]};
(%o8)                       {a, [b]}

Zwei Elemente x und y werden als gleich angesehen, wenn is(x = y) das Ergebnis true hat. Die Elemente sind dann syntaktisch gleich. Es ist zu beachten, dass is(equal(x, y)) das Ergebnis true haben kann, jedoch der Ausdruck is(x = y) das Ergebnis false liefert.

(%i1) x: a/c + b/c;
                              b   a
(%o1)                         - + -
                              c   c
(%i2) y: a/c + b/c;
                              b   a
(%o2)                         - + -
                              c   c
(%i3) z: (a + b)/c;
                              b + a
(%o3)                         -----
                                c
(%i4) is (x = y);
(%o4)                         true
(%i5) is (y = z);
(%o5)                         false
(%i6) is (equal (y, z));
(%o6)                         true
(%i7) y - z;
                           b + a   b   a
(%o7)                    - ----- + - + -
                             c     c   c
(%i8) ratsimp (%);
(%o8)                           0
(%i9) {x, y, z};
                          b + a  b   a
(%o9)                    {-----, - + -}
                            c    c   c

Mit der Funktion setify kann eine Menge aus einer Liste konstruiert werden.

(%i1) setify ([b, a]);
(%o1)                        {a, b}

Die Elemente x und y einer Menge sind gleich, wenn der Ausdruck is(x = y) das Ergebnis true hat. Daher werden zum Beispiel rat(x) und x als gleich betrachtet.

(%i1) {x, rat(x)};
(%o1)                          {x}

Da der Ausdruck is((x - 1)*(x + 1) = x^2 - 1) das Ergebnis false hat, werden (x - 1)*(x + 1) und x^2 - 1 als verschiedene Elemente angenommen.

(%i1) {(x - 1)*(x + 1), x^2 - 1};
                                       2
(%o1)               {(x - 1) (x + 1), x  - 1}

Um die Menge des letzten Beispiels auf ein Element zu reduzieren, kann die Funktion rat auf die Elemente der Menge angewendet werden.

(%i1) {(x - 1)*(x + 1), x^2 - 1};
                                       2
(%o1)               {(x - 1) (x + 1), x  - 1}
(%i2) map (rat, %);
                              2
(%o2)/R/                    {x  - 1}

Um redundante Elemente von Mengen zu entfernen, können Funktionen für die Vereinfachung von Ausdrücken angewendet werden. In diesem Beispiel wird die Funktion trigsimp auf die Elemente der Menge angewendet.

(%i1) {1, cos(x)^2 + sin(x)^2};
                            2         2
(%o1)                {1, sin (x) + cos (x)}
(%i2) map (trigsimp, %);
(%o2)                          {1}

Hat eine Menge redundante Elemente, wird sie vereinfacht und sortiert. Die Ordnung der Elemente wird von der Funktion orderlessp bestimmt. Einige Operationen auf Mengen, wie zum Beispiel Substitutionen erzwingen die Vereinfachung von Mengen.

(%i1) s: {a, b, c}$
(%i2) subst (c=a, s);
(%o2)                        {a, b}
(%i3) subst ([a=x, b=x, c=x], s);
(%o3)                          {x}
(%i4) map (lambda ([x], x^2), set (-1, 0, 1));
(%o4)                        {0, 1}

Maxima behandelt Listen und Mengen als verschiedene Objekte. Funktionen wie union oder intersection geben eine Fehlermeldung, wenn die Argumente keine Mengen sind. Um eine Funktion für Mengen auf eine Liste anzuwenden, kann diese mit der Funktion setify in eine Menge umgewandelt werden.

(%i1) union ([1, 2], {a, b});
Function union expects a set, instead found [1,2]
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i2) union (setify ([1, 2]), {a, b});
(%o2)                     {1, 2, a, b}

Mit der Funktion subset kann eine Teilmenge ermittelt werden, deren Elemente für eine Aussagefunktion das Ergebnis true haben. Um die Gleichungen einer Menge zu finden, die nicht von der Variablen z abhängen, wird im Folgenden die Aussagefunktion freeof verwendet.

(%i1) subset ({x + y + z, x - y + 4, x + y - 5},
                                    lambda ([e], freeof (z, e)));
(%o1)               {- y + x + 4, y + x - 5}

In Funktionen und Variablen für Mengen sind die Funktionen dokumentiert, die Maxima für Mengen kennt.


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

14.1.2 Iteration über Mengen

Es gibt zwei Möglichkeiten, über die Elemente einer Menge zu iterieren. Im ersten Fall wird die Funktion map genutzt.

(%i1) map (f, {a, b, c});
(%o1)                  {f(a), f(b), f(c)}

Eine weitere Möglichkeit ist, eine for-Schleife einzusetzen.

(%i1) s: {a, b, c};
(%o1)                       {a, b, c}
(%i2) for si in s do print (concat (si, 1));
a1 
b1 
c1 
(%o2)                         done

Die Funktionen first und rest funktionieren auch für Mengen. Wird die Funktion first auf eine Menge angewendet, ist das Ergebnis das erste Element, wie es in der Anzeige erscheint. Ist s eine Menge, dann ist der Ausdruck rest(s) äquivalent zu disjoin(first(s), s). Siehe die Funktion disjoin.


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

14.1.3 Programmfehler

Die Möglichkeit mit den Funktionen orderless und ordergreat eine neue Ordnung für Variablen zu definieren, ist nicht kompatibel mit den Funktionen für Mengen. Wird eine der Funktionen orderless oder ordergreat benötigt, sollten diese vor der Konstruktion der ersten Menge ausgeführt werden. Die Funktion unorder sollte nicht ausgeführt werden.


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

14.1.4 Autoren

Stavros Macrakis aus Cambridge, Massachusetts und Barton Willis von der Universität Nebraska in Kearney (UNK) haben die Funktionen und die Dokumentation für Mengen geschrieben.


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

14.2 Funktionen und Variablen für Mengen

Funktion: adjoin (x, a)

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}

Funktion: belln (n)

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)]

Funktion: cardinality (a)

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

Funktion: cartesian_product (b_1, …, b_n)

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]}

Funktion: disjoin (x, a)

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}

Funktion: disjointp (a, b)

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

Funktion: divisors (n)

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)}

Funktion: elementp (x, a)

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

Funktion: emptyp (a)

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]

Funktion: equiv_classes (s, F)

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}}

Funktion: every (f, s)
Funktion: every (f, L_1, …, L_n)

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

Funktion: extremal_subset (s, f, max)
Funktion: extremal_subset (s, f, min)

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)}

Funktion: flatten (expr)

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);

Funktion: full_listify (a)

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])]))

Funktion: fullsetify (a)

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])}

Funktion: identity (x)

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

Funktion: integer_partitions (n)
Funktion: integer_partitions (n, len)

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]}

Funktion: intersect (a_1, …, a_n)

intersect ist identisch mit der Funktion intersection.

Funktion: intersection (a_1, …, a_n)

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)                          {}

Funktion: kron_delta (x_1, x_2, …, x_p)

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

Funktion: listify (a)

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})

Funktion: lreduce (F, s)
Funktion: lreduce (F, s, s_0)

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

Funktion: makeset (expr, x, s)

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)}

Funktion: moebius (n)

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}

Funktion: multinomial_coeff (a_1, …, a_n)
Funktion: multinomial_coeff ()

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

Funktion: num_distinct_partitions (n)
Funktion: num_distinct_partitions (n, list)

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)

Funktion: num_partitions (n)
Funktion: num_partitions (n, list)

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)

Funktion: partition_set (a, f)

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}]

Funktion: permutations (a)

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]}

Funktion: powerset (a)
Funktion: powerset (a, n)

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)                         {{}}

Funktion: random_permutation (a)

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]

Funktion: rreduce (F, s)
Funktion: rreduce (F, s, s_{n + 1})

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

Funktion: setdifference (a, b)

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)                          {}

Funktion: setequalp (a, b)

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

Funktion: setify (a)

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}

Funktion: setp (a)

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

Funktion: set_partitions (a)
Funktion: set_partitions (a, n)

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

  1. jedes Elemente der Menge P eine nicht-leere Menge ist,
  2. verschiedene Elemente der Menge P voneinander disjunkt sind,
  3. die Vereinigung von Elementen der Menge P gleich der Menge S ist.

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}}

Funktion: some (f, a)
Funktion: some (f, L_1, …, L_n)

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

Funktion: stirling1 (n, m)

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]).

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!

Funktion: stirling2 (n, m)

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]).

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

Funktion: subset (a, f)

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}

Funktion: subsetp (a, b)

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

Funktion: symmdifference (a_1, …, a_n)

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}

Funktion: tree_reduce (F, s)
Funktion: tree_reduce (F, s, s_0)

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)

Funktion: union (a_1, …, a_n)

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}

Funktion: xreduce (F, s)
Funktion: xreduce (F, s, s_0)

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]

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

This document was generated by Jaime Villate on Oktober, 14 2014 using texi2html 1.76.