Next: Nutzerdefinierte Operatoren, Previous: Operatoren für Gleichungen, Up: Operatoren [Contents][Index]

### 7.6 Zuweisungsoperatoren

Operator: :

  Ist der Operator für die Zuweisung eines Wertes an eine Variable.

  Ist die linke Seite eine Variable (ohne Index), wertet der Operator `:` die rechte Seite aus und weist den Wert der Variablen auf der linken Seite zu.

  Ist die linke Seite ein Element einer Liste, Matrix oder ein deklariertes Maxima- oder Lisp-Array, wird die rechte Seite diesem Element zugewiesen. Der Index muss ein existierendes Element bezeichnen.

  Ist die linke Seite ein Element eines nicht deklarierten Arrays, dann wird die rechte Seite diesem Element zugewiesen, falls dieses existiert. Existiert das Element noch nicht, wird ein neues Element erzeugt.

  Ist die linke Seite eine Liste mit Variablen (ohne Index), muss die rechte Seite zu einer Liste auswerten. Die Elemente der Liste auf der rechten Seite werden den Elementen auf der linken Seite parallel zugewiesen.

  Siehe auch `kill` und `remvalue` für die Aufhebung der Zuweisung eines Wertes an ein Symbol.

  Beispiele:

  Zuweisung an eine einfache Variable.

      (%i1) a;
      (%o1)                           a
      (%i2) a : 123;
      (%o2)                          123
      (%i3) a;
      (%o3)                          123

  Zuweisung an ein Element einer Liste.

      (%i1) b : [1, 2, 3];
      (%o1)                       [1, 2, 3]
      (%i2) b[3] : 456;
      (%o2)                          456
      (%i3) b;
      (%o3)                      [1, 2, 456]

  Die Zuweisung erzeugt ein nicht deklariertes Array.

      (%i1) c[99] : 789;
      (%o1)                          789
      (%i2) c[99];
      (%o2)                          789
      (%i3) c;
      (%o3)                           c
      (%i4) arrayinfo (c);
      (%o4)                   [hashed, 1, [99]]
      (%i5) listarray (c);
      (%o5)                         [789]

  Mehrfache Zuweisung.

      (%i1) [a, b, c] : [45, 67, 89];
      (%o1)                     [45, 67, 89]
      (%i2) a;
      (%o2)                          45
      (%i3) b;
      (%o3)                          67
      (%i4) c;
      (%o4)                          89

  Die mehrfache Zuweisung wird parallel ausgeführt. Die Werte von `a` und `b` werden in diesem Beispiel ausgetauscht.

      (%i1) [a, b] : [33, 55];
      (%o1)                       [33, 55]
      (%i2) [a, b] : [b, a];
      (%o2)                       [55, 33]
      (%i3) a;
      (%o3)                          55
      (%i4) b;
      (%o4)                          33

Operator: ::

  Ist der Operator für die Zuweisung eines Wertes an eine Variable.

  Der Operator `::` ist vergleichbar mit dem Operator `:` mit dem Unterschied, dass `::` sowohl die rechte als auch die linke Seite auswertet.

  Beispiele:

      (%i1) x : 'foo;
      (%o1)                          foo
      (%i2) x :: 123;
      (%o2)                          123
      (%i3) foo;
      (%o3)                          123
      (%i4) x : '[a, b, c];
      (%o4)                       [a, b, c]
      (%i5) x :: [11, 22, 33];
      (%o5)                     [11, 22, 33]
      (%i6) a;
      (%o6)                          11
      (%i7) b;
      (%o7)                          22
      (%i8) c;
      (%o8)                          33

Operator: ::=

  Ist der Operator für die Definition von Makro-Funktionen.

  Der Operator `::=` definiert eine Makro-Funktion, das ist eine Funktion, die ihre Argumente nicht auswertet. Der Ausdruck, der die Makro-Funktion definiert, wird in dem Kontext ausgewertet, in dem das Makro aufgerufen wird. Ansonsten verhält sich eine Makro-Funktion wie eine gewöhnliche Funktion.

  Die Funktion `macroexpand` expandiert eine Makro-Funktion, ohne sie auszuwerten. `macroexpand(foo(x))` dem `''%` folgt, ist äquivalent zu `foo(x)`, wenn `foo` eine Makro-Funktion ist.

  Der Operator `::=` fügt den Namen der neuen Makro-Funktion der Informationsliste `macros` hinzu. Die Funktionen `kill`, `remove` und `remfunction` heben die Zuweisung der Makro-Funktion an ein Symbol auf und entfernen die Makro-Funktion von der Informationsliste `macros`.

  Die Funktionen `fundef` oder `dispfun` geben die Definition einer Makro-Funktion zurück oder weisen die Makro-Funktion einer Marke zu.

  Makro-Funktionen enthalten häufig Ausdrücke mit den Funktionen `buildq` und `splice`. Mit diesen werden Ausdrücke konstruiert, die dann ausgewertet werden.

  Beispiele:

  Eine Makro-Funktion wertet ihre Argumente nicht aus. Daher zeigt Beispiel (1) `y - z` und nicht den Wert von `y - z`. Das Makro wird in dem Kontext ausgewertet, in dem das Makro aufgerufen wird. Dies zeigt (2).

      (%i1) x: %pi$

      (%i2) y: 1234$

      (%i3) z: 1729 * w$

      (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
            '(print ("(2) x is equal to", x)))$

      (%i5) printq1 (y - z);
      (1) x is equal to y - z
      (2) x is equal to %pi
      (%o5)                                 %pi

  Eine gewöhnliche Funktion wertet ihre Argumente aus. Daher zeigt (1) den Wert von `y - z`. Der Rückgabewert wird nicht ausgewertet und gibt (2). Mit `''%` wird die Auswertung erzwungen.

      (%i1) x: %pi$

      (%i2) y: 1234$

      (%i3) z: 1729 * w$

      (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
            '(print ("(2) x is equal to", x)))$

      (%i5) printe1 (y - z);
      (1) x is equal to 1234 - 1729 w
      (%o5)                     print((2) x is equal to, x)
      (%i6) ''%;
      (2) x is equal to %pi
      (%o6)                                 %pi

  `macroexpand` gibt die Expansion des Makros zurück. `macroexpand(foo(x))` dem `''%` folgt, ist äquivalent zu `foo(x)`, wenn `foo` eine Makro-Funktion ist.

      (%i1) x: %pi$

      (%i2) y: 1234$

      (%i3) z: 1729 * w$

      (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$

      (%i5) macroexpand (g (y - z));
      (%o5)                     print(x is equal to, y - z)
      (%i6) ''%;
      x is equal to 1234 - 1729 w
      (%o6)                            1234 - 1729 w
      (%i7) g (y - z);
      x is equal to 1234 - 1729 w
      (%o7)                            1234 - 1729 w

Operator: :=

  Ist der Operator für Funktionsdefinitionen.

  `f(x_1, ..., x_n)` := expr definiert eine Funktion mit dem Namen f, den Argumenten x_1, …, x_n und der Funktionsdefinition expr. Der Operator `:=` wertet die Funktionsdefinition nicht aus. Die Auswertung kann mit dem Quote-Quote-Operator `''` erzwungen werden. Die definierte Funktion kann eine gewöhnliche Maxima-Funktion `f(x)` sein oder eine Array-Funktion `f[i](x)`.

  Ist das letzte oder das einzige Argument der Funktion x_n eine Liste mit einem Element, dann akzeptiert die mit `:=` definierte Funktion eine variable Anzahl an Argumenten. Die Argumente werden zunächst nacheinander den Argumenten x_1, …, x_(n - 1) zugewiesen. Sind weitere Argumente vorhanden, werden diese x_n als Liste zugewiesen.

  Funktionsdefinitionen erscheinen im globalen Namensraum. Wird eine Funktion `f` innerhalb einer Funktion `g` definiert, wird die Reichweite der Funktion nicht automatisch auf `g` beschränkt. Dagegen führt `local(f)` zu einer Definition, die nur innerhalb eines Blockes oder einem anderen zusammengesetzten Ausdrück erscheint. Siehe auch `local`.

  Ist eines der Argumente ein Symbol auf das der Quote-Operator `'` angewendet wurde, wird dieses Argument nicht ausgewertet. Ansonsten werden alle Argumente ausgewertet.

  Siehe auch `define` und `::=`.

  Beispiele:

  `:=` wertet die Funktionsdefinition nie aus, außer wenn der Quote-Quote-Operator angewendet wird.

      (%i1) expr : cos(y) - sin(x);
      (%o1)                    cos(y) - sin(x)
      (%i2) F1 (x, y) := expr;
      (%o2)                   F1(x, y) := expr
      (%i3) F1 (a, b);
      (%o3)                    cos(y) - sin(x)
      (%i4) F2 (x, y) := ''expr;
      (%o4)              F2(x, y) := cos(y) - sin(x)
      (%i5) F2 (a, b);
      (%o5)                    cos(b) - sin(a)

  Mit dem Operator `:=` definierte Funktionen können eine gewöhnliche Maxima-Funktion oder eine Array-Funktion sein.

      (%i1) G1 (x, y) := x.y - y.x;
      (%o1)               G1(x, y) := x . y - y . x
      (%i2) G2 [x, y] := x.y - y.x;
      (%o2)                G2     := x . y - y . x
                             x, y

  Ist das letzte oder einzige Argument x_n eine Liste mit einem Element, dann akzeptiert die Funktion eine variable Anzahl an Argumenten.

      (%i1) H ([L]) := apply ("+", L);
      (%o1)                H([L]) := apply("+", L)
      (%i2) H (a, b, c);
      (%o2)                       c + b + a

  `local` erzeugt eine lokale Funktionsdefinition.

      (%i1) foo (x) := 1 - x;
      (%o1)                    foo(x) := 1 - x
      (%i2) foo (100);
      (%o2)                         - 99
      (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
      (%o3)                          200
      (%i4) foo (100);
      (%o4)                         - 99

Next: Nutzerdefinierte Operatoren, Previous: Operatoren für Gleichungen, Up: Operatoren [Contents][Index]