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.

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.

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.

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.