Previous: Einführung in nutzerdefinierte Operatoren, Up: Nutzerdefinierte Operatoren [Contents][Index]

#### 7.7.2 Funktionen und Variablen für nutzerdefinierte Operatoren

Funktion: infix (op)
Funktion: infix (op, lbp, rbp)
Funktion: infix (op, lbp, rbp, lpos, rpos, pos)

  Deklariert op als einen Infix-Operator. Ein Infix-Operator hat eine Funktionsdefinition mit zwei Argumenten. Der Infix-Operator steht zwischen den Operanden. Zum Beispiel ist die Subtraktion `-` ein Infix-Operator.

  `infix(op)` deklariert op als einen Infix-Operator mit einem links- und rechtsseitigen Vorrang von jeweils 180.

  `infix(op, lbp, rbp)` deklariert op als einen Infix-Operator mit den angegebenen Werten für den links- und rechtsseitigen Vorrang.

  `infix(op, lbp, rbp, lpos, rpos, pos)` deklariert op als einen Infix-Operator mit den angegebenen Vorrängen sowie den Wortarten lpos, rpos und pos für den linken und den rechten Operanden sowie das Ergebnis des Operators.

  Beispiele:

  Sind die rechtsseitigen und linksseitigen Vorränge eines Operators op größer als die entsprechenden Vorränge eines anderen Operators, dann hat der Operator op Vorrang.

      (%i1) :lisp (get '$+ 'lbp)
      100
      (%i1) :lisp (get '$+ 'rbp)
      100
      (%i1) infix ("##", 101, 101);
      (%o1)                          ##
      (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
      (%o2)       (a ## b) := sconcat("(", a, ",", b, ")")
      (%i3) 1 + a ## b + 2;
      (%o3)                       (a,b) + 3
      (%i4) infix ("##", 99, 99);
      (%o4)                          ##
      (%i5) 1 + a ## b + 2;
      (%o5)                       (a+1,b+2)

  Ein größerer linksseitige Vorrang lbp bewirkt, dass der Operator op rechts-assoziativ ist. Ein größerer rechtsseitiger Vorrang macht dagegen den Operator op links-assoziativ.

      (%i1) infix ("##", 100, 99);
      (%o1)                          ##
      (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
      (%i3) foo ## bar ## baz;
      (%o3)                    (foo,(bar,baz))
      (%i4) infix ("##", 100, 101);
      (%o4)                          ##
      (%i5) foo ## bar ## baz;
      (%o5)                    ((foo,bar),baz)

  Maxima kann Syntaxfehler beim Einlesen eines Ausdrucks feststellen, wenn der eingelesene Operand nicht die für den Operator definierte Wortart hat.

      (%i1) infix ("##", 100, 99, expr, expr, expr);
      (%o1)                          ##
      (%i2) if x ## y then 1 else 0;
      Incorrect syntax: Found algebraic expression where
      logical expression expected
      if x ## y then
                   ^
      (%i2) infix ("##", 100, 99, expr, expr, clause);
      (%o2)                          ##
      (%i3) if x ## y then 1 else 0;
      (%o3)                if x ## y then 1 else 0

Funktion: matchfix (ldelimiter, rdelimiter)
Funktion: matchfix (ldelimiter, rdelimiter, arg_pos, pos)

  Deklariert einen Matchfix-Operator mit dem linksseitigen Begrenzungszeichen ldelimiter und dem rechtsseitigen Begrenzungszeichen rdelimiter.

  Ein Matchfix-Operator hat eine beliebige Anzahl an Argumenten, die zwischen dem linksseitigen und dem rechtsseitigen Begrenzungszeichen stehen. Das Begrenzungszeichen kann eine beliebige Zeichenkette sein. Einige Zeichen wie `%`, `,`, `$` und `;` können nicht als Begrenzungszeichen definiert werden.

  Ein linksseitiges Begrenzungszeichen kann nicht verschiedene rechtsseitige Begrenzungszeichen haben.

  Maxima-Operatoren können als Matchfix-Operatoren definiert werden, ohne dass sich die sonstigen Operatoreigenschaften ändern. So kann zum Beispiel der Operator `+` als Matchfix-Operator definiert werden.

  `matchfix(ldelimiter, rdelimiter, arg_pos, pos)` definiert die Wortarten für die Argumente arg_pos und das Ergebnis pos sowie das linksseitige ldelimiter und rechtsseitige rdelimiter Begrenzungszeichen.

  Die zu einem Matchfix-Operator zugehörige Funktion kann jede nutzerdefinierte Funktion sein, die mit `:=` oder `define` definiert wird. Die Definition der Funktion kann mit `dispfun(ldelimiter)` ausgegeben werden.

  Maxima kennt nur den Operator für Listen `[ ]` als Matchfix-Operator. Klammern `( )` und Anführungszeichen `" "` arbeiten wie Matchfix-Operatoren, werden aber vom Parser nicht als Matchfix-Operatoren behandelt.

  `matchfix` wertet die Argumente aus. `matchfix` gibt das erste Argument ldelimiter als Ergebnis zurück.

  Beispiele:

  Begrenzungszeichen können eine beliebige Zeichenkette sein.

      (%i1) matchfix ("@@", "~");
      (%o1)                          @@
      (%i2) @@ a, b, c ~;
      (%o2)                      @@a, b, c~
      (%i3) matchfix (">>", "<<");
      (%o3)                          >>
      (%i4) >> a, b, c <<;
      (%o4)                      >>a, b, c<<
      (%i5) matchfix ("foo", "oof");
      (%o5)                          foo
      (%i6) foo a, b, c oof;
      (%o6)                     fooa, b, coof
      (%i7) >> w + foo x, y oof + z << / @@ p, q ~;
                           >>z + foox, yoof + w<<
      (%o7)                ----------------------
                                  @@p, q~

  Matchfix-Operatoren können für nutzerdefinierte Funktionen definiert werden.

      (%i1) matchfix ("!-", "-!");
      (%o1)                         "!-"
      (%i2) !- x, y -! := x/y - y/x;
                                          x   y
      (%o2)                   !-x, y-! := - - -
                                          y   x
      (%i3) define (!-x, y-!, x/y - y/x);
                                          x   y
      (%o3)                   !-x, y-! := - - -
                                          y   x
      (%i4) define ("!-" (x, y), x/y - y/x);
                                          x   y
      (%o4)                   !-x, y-! := - - -
                                          y   x
      (%i5) dispfun ("!-");
                                          x   y
      (%t5)                   !-x, y-! := - - -
                                          y   x

      (%o5)                         done
      (%i6) !-3, 5-!;
                                      16
      (%o6)                         - --
                                      15
      (%i7) "!-" (3, 5);
                                      16
      (%o7)                         - --
                                      15

Funktion: nary (op)
Funktion: nary (op, bp, arg_pos, pos)

  `nary(op)` definiert einen `N-ary`-Operator op mit einem linksseitigen Vorrang von 180. Der rechtsseitige Vorrang wird nicht benötigt.

  `nary(op, bp, arg_pos, pos)` definiert einen `N-ary`-Operator op mit einem rechtsseitigen Vorrang von bp und der Wortart arg_pos für den Operanden und der Wortart pos fÃ¼r das Ergebnis.

  Ein `N-ary`-Operator ist ein Operator, der eine beliebige Anzahl an Argumenten haben kann. Die Argumente werden durch den Operator voneinander getrennt, so ist zum Beispiel `+` ein `N-ary`-Operator und `A+B+C`.

  Im Unterschied zur Definition eines Operators kann eine Funktion `f` auch als `nary` mit der Funktion `declare` deklariert werden. Die Deklaration hat Auswirkung auf die Vereinfachung der Funktion. Zum Beispiel wird ein Ausdruck `j(j(a,b),j(c,d)` zu `j(a,b,c,d)` vereinfacht.

Funktion: nofix (op)
Funktion: nofix (op, pos)

  `nofix(op)` definiert den Operator op als einen Nofix-Operator.

  `nofix(op, pos)` definiert einen Nofix-Operator mit der Wortart pos für das Ergebnis.

  Nofix-Operatoren sind Operatoren, die kein Argument haben. Tritt ein solcher Operator allein auf, wird die dazugehörige Funktion ausgewertet. Zum Beispiel beendet die Funktion `quit()` eine Maxima-Sitzung. Wird diese Funktion mit `nofix("quit")` als ein Nofix-Operator definiert, genügt die Eingabe von `quit`, um eine Maxima-Sitzung zu beenden.

Funktion: postfix (op)
Funktion: postfix (op, lbp, lpos, pos)

  `postfix (op)` definiert einen Postfix-Operator op.

  `postfix (op, lbp, lpos, pos)` definiert einen Postfix-Operator op mit einem linksseitigem Vorrang von lbp sowie den Wortarten lpos für den Operanden und pos für das Ergebnis.

  Ein Postfix-Operator hat einen Operanden, der dem Operator vorangestellt ist. Ein Beispiel ist der `!`-Operator mit `3!`. Die Funktion `postfix("x")` erweitert die Maxima-Syntax um den Postfix-Operator `x`.

Funktion: prefix (op)
Funktion: prefix (op, rbp, rpos, pos)

  `prefix (op)` definiert einen Prefix-Operator op.

  `prefix (op, lbp, lpos, pos)` definiert einen Prefix-Operator op mit einem rechtsseitigem Vorrang von rbp sowie den Wortarten rpos für den Operanden und pos für das Ergebnis.

  Ein Prefix-Operator hat einen Operanden, der dem Operator nachfolgt. Mit `prefix("x")` wird die Maxima-Syntax um einen Prefix-Operator `x` erweitert.

Previous: Einführung in nutzerdefinierte Operatoren, Up: Nutzerdefinierte Operatoren [Contents][Index]