Next: Funktionen und Variablen für Mengen, Previous: Mengen, Up: Mengen [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.

#### 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.

Next: Funktionen und Variablen für Mengen, Previous: Mengen, Up: Mengen [Contents][Index]