| blob | ba481e93e7c2cc6fe2e85c2654f8da4d4406d56a |
1 @c -----------------------------------------------------------------------------
2 @c File : Operators.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Operators.texi revision 03.09.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 17.10.2010
8 @c Revision : 24.09.2011
9 @c
10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
11 @c -----------------------------------------------------------------------------
13 @menu
14 * Einf@"uhrung in Operatoren::
15 * Arithmetische Operatoren::
16 * Relationale Operatoren::
17 * Logische Operatoren::
18 * Operatoren f@"ur Gleichungen::
19 * Zuweisungsoperatoren::
20 * Nutzerdefinierte Operatoren::
21 @end menu
23 @c -----------------------------------------------------------------------------
24 @node Einf@"uhrung in Operatoren, Arithmetische Operatoren, Operatoren, Operatoren
25 @section Einf@"uhrung in Operatoren
26 @c -----------------------------------------------------------------------------
28 Maxima kennt die @"ublichen arithmetischen, relationalen und logischen
29 Operatoren der Mathematik. Weiterhin kennt Maxima Operatoren f@"ur die
30 Zuweisung von Werten an Variablen und die Definition von Funktionen. Die
31 folgende Tabelle zeigt die in diesem Kapitel beschriebenen Operatoren.
32 Angegeben sind der Name des Operators, der linksseitige Vorrang @code{lbp} und
33 der rechtsseitige Vorrang @code{rbp}, der Typ des Operators und ein Beispiel
34 einschlie@ss{}lich der internen Darstellung, wie sie vom Parser von der Eingabe
35 gelesen wird.
37 @verbatim
39 Operator lbp rbp Typ Beispiel
41 + 100 134 nary a+b ((mplus) $A $B)
42 - 100 134 prefix -a ((mminus) $A)
43 * 120 nary a*b ((mtimes) $A $B)
44 / 120 120 infix a/b ((mquotient) $A $B)
45 ^ 140 139 infix a^b ((mexpt) $A $B)
46 ** 140 139 infix a**b ((mexpt) $A $B)
47 ^^ 140 139 infix a^^b ((mncexpt) $A $B)
48 . 130 129 infix a.b ((mnctimes) $A $B)
50 < 80 80 infix a<b ((mlessp) $A $B)
51 <= 80 80 infix a<=b ((mleqp) $A $B)
52 > 80 80 infix a>b ((mqreaterp) $A $B)
53 >= 80 80 infix a>=b ((mgeqp) $A $B)
55 not 70 prefix not a ((mnot) $A)
56 and 65 nary a and b ((mand) $A $B)
57 or 60 nary a or b ((mor) $A $B)
59 # 80 80 infix a#b ((mnotequal) $A $B)
60 = 80 80 infix a=b ((mequal) $A $B)
62 : 180 20 infix a:b ((msetq) $A $B)
63 :: 180 20 infix a::b ((mset) $A $B)
64 := 180 20 infix a:=b ((mdefine) $A $B)
65 ::= 180 20 infix a::=b ((mdefmacro) $A $B)
67 @end verbatim
69 @noindent
70 Mit dem Vorrang der Operatoren werden die bekannten Rechenregeln der einzelnen
71 Operatoren definiert. So wird zum Beispiel @code{ a + b * c } vom Parser
72 als @code{ a + (b * c) } interpretiert, da der linksseitige Vorrang der
73 Multiplikation gr@"o@ss{}er als der linksseitige Vorrang der Addition ist.
75 Maxima unterscheidet die folgenden Operatoren:
77 @table @emph
78 @item Prefix
79 Prefix-Operatoren sind un@"are Operatoren, die einen Operanden haben, der dem
80 Operator nachfolgt. Beispiele sind die Operatoren @mref{-} und @mrefdot{not}
81 @item Postfix
82 Postfix-Operatoren sind un@"are Operatoren, die einen Operanden haben, der dem
83 Operator vorangestellt ist. Ein Beispiel ist der Operator @mref{!} f@"ur die
84 Fakult@"at.
85 @item Infix
86 Infix-Operatoren, sind bin@"are Operatoren, die zwei Operanden haben. Der
87 Operator steht zwischen diesen Operanden. Hierzu z@"ahlen zum Beispiel der
88 Operator f@"ur die Exponentiation @mref{^} oder der Operator f@"ur die Zuweisung
89 @mrefdot{:}
90 @item N-ary
91 N-ary-Operatoren fassen eine beliebige Anzahl an Operanden zu einem Ausdruck
92 zusammen. Hierzu z@"ahlen die Multiplikation @mref{*} oder die Addition
93 @mrefdot{+}
94 @item Matchfix
95 Matchfix-Operatoren sind Begrenzungszeichen, die eine beliebige Anzahl an
96 Operanden einschlie@ss{}en. Ein Beispiel sind die Operatoren @mref{[} und
97 @mref{]}, die eine Liste @code{[a, b, ...]} definieren.
98 @item Nofix
99 Ein Nofix-Operator ist ein Operator, der keinen Operanden hat. Maxima kennt
100 keinen internen Nofix-Operator. Zum Beispiel kann mit @code{nofix(quit)} ein
101 Nofix-Operator definiert werden. Dann ist es m@"oglich, Maxima allein mit
102 @code{quit} anstatt dem Funktionsaufruf @code{quit()} zu beenden.
103 @end table
105 Maxima unterscheidet das Symbol eines Operators, wie zum Beispiel @code{+}
106 f@"ur die Addition, von dem Namen eines Operators, der eine Zeichenkette ist.
107 Der Additionsoperator hat den Namen @code{"+"}. Mit dem Namen des Operators
108 kann der Operator als eine Funktion eingegeben werden. Im folgenden wird ein
109 Beispiel f@"ur den bin@"aren Infix-Operator der Exponentiation gezeigt:
111 @example
112 (%i1) a^b;
113 b
114 (%o1) a
115 (%i2) "^"(a,b);
116 b
117 (%o2) a
118 @end example
120 Der Name des Operators kann immer dann verwendet werden, wenn eine
121 Funktion als Argument ben@"otigt wird. Beispiele sind die Funktionen
122 @mrefcomma{map} @mref{apply} oder auch die Substitution mit @mrefdot{subst}
124 @example
125 (%i3) apply("+", [a,b,c]);
126 (%o3) c + b + a
127 (%i4) map("^", [a,b,c],[1,2,3]);
128 2 3
129 (%o4) [a, b , c ]
130 (%i5) subst("*"="+", 10*a*b*c);
131 (%o5) c + b + a + 10
132 @end example
134 In @ref{Nutzerdefinierte Operatoren} wird beschrieben, wie interne
135 Maxima-Ope@-ra@-to@-ren umdefiniert oder neue Operatoren definiert werden.
137 Die obige Tabelle enth@"alt nicht alle von Maxima definierten Operatoren.
138 Weitere Operatoren sind zum Beispiel @code{!} f@"ur die Fakult@"at, die
139 Operatoren @code{for}, @code{do}, @code{while}, um eine Programmschleife zu
140 programmieren, oder @code{if}, @code{then}, @code{else}, um eine Bedingung zu
141 definieren.
143 @c TODO: ERGAENZE TABELLE MIT DEN FOLGENDEN OPERATOREN:
144 @c
145 @c [ ] ( ) ' '' ! !! , ; $
146 @c if then else elseif
147 @c do for from step next thru unless while
148 @c @
150 @c -----------------------------------------------------------------------------
151 @need 800
152 @node Arithmetische Operatoren, Relationale Operatoren, Einf@"uhrung in Operatoren, Operatoren
153 @section Arithmetische Operatoren
154 @c -----------------------------------------------------------------------------
156 @c --- 04.05.2011 DK -----------------------------------------------------------
157 @anchor{+}
158 @anchor{-}
159 @anchor{*}
160 @anchor{/}
161 @anchor{^}
162 @deffn {Operator} +
163 @ifinfo
164 @fnindex Addition
165 @end ifinfo
166 @deffnx {Operator} -
167 @ifinfo
168 @fnindex Subtraktion
169 @end ifinfo
170 @deffnx {Operator} *
171 @ifinfo
172 @fnindex Multiplikation
173 @end ifinfo
174 @deffnx {Operator} /
175 @ifinfo
176 @fnindex Division
177 @end ifinfo
178 @deffnx {Operator} ^
179 @ifinfo
180 @fnindex Exponentiation
181 @end ifinfo
183 Sind die Operatoren der Addition, Multiplikation, Division und Exponentiation.
184 Wird der Name eines Operators in einem Ausdruck ben@"otigt, k@"onnen die
185 Bezeichnungen @code{"+"}, @code{"*"}, @code{"/"} und @code{"^"} verwendet
186 werden.
188 In Ausdr@"ucken wie @code{(+a)*(-a)} oder @code{exp(-a)} repr@"asentieren die
189 Operatoren @code{+} und @code{-} die un@"are Addition und Negation. Die Namen
190 der Operatoren sind @code{"+"} und @code{"-"}.
192 Die Subtraktion @code{a - b} wird von Maxima intern als Addition
193 @code{a + (- b)} dargestellt. In der Ausgabe wird der Ausdruck @code{a + (- b)}
194 als Subtraktion @code{a - b} angezeigt.
196 Die Division @code{a / b} wird von Maxima intern als Multiplikation
197 @code{a * b^(- 1)} dargestellt. In der Ausgabe wird der Ausdruck
198 @code{a * b^(- 1)} als Division @code{a / b} angezeigt. Der Name des Operators
199 f@"ur die Division ist @code{"/"}.
201 Die Operatoren der Addition und Multiplikation sind kommutative
202 N-ary-Operatoren. Die Operatoren der Division und Exponentiation sind
203 nicht-kommutative bin@"are Operatoren.
205 Maxima sortiert die Operanden eines kommutativen Operators und konstruiert eine
206 kanonische Darstellung. Maxima unterscheidet die interne Sortierung von der
207 externen Sortierung f@"ur die Anzeige. Die interne Sortierung wird von der
208 Aussagefunktion @mref{orderlessp} bestimmt. Die externe Sortierung f@"ur die
209 Anzeige wird von der Aussagefunktion @mref{ordergreatp} festgelegt. Ausnahme
210 ist die Multiplikation. F@"ur diese sind die interne und die externe
211 Sortierung identisch.
213 Arithmetische Rechnungen mit Zahlen (ganzen Zahlen, rationale Zahlen,
214 Gleitkommazahlen und gro@ss{}en Gleitkommazahlen) werden als eine Vereinfachung
215 und nicht als Auswertung ausgef@"uhrt. Mit Ausnahme der Exponentiation werden
216 alle arithmetischen Operationen mit Zahlen zu Zahlen vereinfacht.
217 Exponentiationen von Zahlen wie zum Beispiel @code{(1/3)^(1/2)} werden nicht
218 notwendigerweise zu Zahlen vereinfacht. In diesem Beispiel ist das Ergebnis
219 der Vereinfachung @code{1/sqrt(3)}.
221 Bei einer arithmetischen Rechnung kann es zur Umwandlung in Gleitkommazahlen
222 kommen. Ist eines der Argumente eine gro@ss{}e Gleitkommazahl, so ist auch das
223 Ergebnis eine gro@ss{}e Gleitkommazahl. Entsprechend ist das Ergebnis eine
224 einfache Gleitkommazahl, sofern mindestens einer der Operanden eine einfache
225 Gleitkommazahl ist. Treten nur ganze oder rationale Zahlen auf, ist das
226 Ergebnis wieder eine ganze oder rationale Zahl.
228 Da arithmetische Rechnungen Vereinfachungen und keine Auswertungen sind, werden
229 arithmetische Rechnungen auch dann ausgef@"uhrt, wenn die Auswertung des
230 Ausdrucks zum Beispiel mit dem @mxref{', Quote-Operator} @code{'} unterdr@"uckt
231 ist.
233 Arithmetische Operatoren werden elementweise auf Listen angewendet, wenn die
234 Optionsvariable @mref{listarith} den Wert @code{true} hat. Auf Matrizen werden
235 die arithmetischen Operatoren immer elementweise angewendet. Ist einer der
236 Operanden eine Liste oder Matrix und der andere Operand hat einen anderen
237 Typ, dann wird dieses Argument mit jedem Element der Liste oder Matrix
238 kombiniert.
240 Beispiele:
242 Addition und Multiplikation sind kommutative N-ary-Operatoren. Maxima sortiert
243 die Operanden und konstruiert eine kanonische Darstellung. Die Namen der
244 Operatoren sind @code{"+"} und @code{"*"}.
246 @example
247 (%i1) c + g + d + a + b + e + f;
248 (%o1) g + f + e + d + c + b + a
249 (%i2) [op (%), args (%)];
250 (%o2) [+, [g, f, e, d, c, b, a]]
251 (%i3) c * g * d * a * b * e * f;
252 (%o3) a b c d e f g
253 (%i4) [op (%), args (%)];
254 (%o4) [*, [a, b, c, d, e, f, g]]
255 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
256 (%o5) 3 x + 2 a + 19
257 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
258 2 3
259 (%o6) 144 a x
260 @end example
262 Division und Exponentiation sind nicht-kommutative bin@"are Operatoren. Die
263 Namen der Operatoren sind @code{"/"} und @code{"^"}.
265 @example
266 (%i1) [a / b, a ^ b];
267 @group
268 a b
269 (%o1) [-, a ]
270 b
271 @end group
272 (%i2) [map (op, %), map (args, %)];
273 (%o2) [[/, ^], [[a, b], [a, b]]]
274 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
275 a b
276 (%o3) [-, a ]
277 b
278 @end example
280 Subtraktion und Division werden intern als Addition und Multiplikation
281 dargestellt.
283 @example
284 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
285 (%o1) [+, a, - b]
286 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
287 1
288 (%o2) [*, a, -]
289 b
290 @end example
292 Sind die Operanden Zahlen, werden die Rechnungen ausgef@"uhrt. Ist einer der
293 Operanden eine Gleitkommazahl, ist das Ergebnis ebenfalls eine Gleitkommazahl.
295 @example
296 @group
297 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
298 5
299 (%o1) b + sqrt(11) + -
300 2
301 @end group
302 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
303 (%o2) [46, 46.0, 4.6b1]
304 @end example
306 Arithmetische Rechnungen sind Vereinfachungen und keine Auswertung.
308 @example
309 (%i1) simp : false;
310 (%o1) false
311 (%i2) '(17 + 29*11/7 - 5^3);
312 29 11 3
313 (%o2) 17 + ----- - 5
314 7
315 (%i3) simp : true;
316 (%o3) true
317 (%i4) '(17 + 29*11/7 - 5^3);
318 437
319 (%o4) - ---
320 7
321 @end example
323 Arithmetische Rechnungen werden elementweise f@"ur Listen und Matrizen
324 ausgef@"uhrt. Bei Listen wird dies mit der Optionsvariablen
325 @mref{listarith} kontrolliert.
327 @example
328 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
329 @group
330 [ a - 1 x - 2 ]
331 (%o1) [ ]
332 [ h - 3 u - 4 ]
333 @end group
334 (%i2) 5 * matrix ([a, x], [h, u]);
335 @group
336 [ 5 a 5 x ]
337 (%o2) [ ]
338 [ 5 h 5 u ]
339 @end group
340 (%i3) listarith : false;
341 (%o3) false
342 (%i4) [a, c, m, t] / [1, 7, 2, 9];
343 [a, c, m, t]
344 (%o4) ------------
345 [1, 7, 2, 9]
346 (%i5) [a, c, m, t] ^ x;
347 x
348 (%o5) [a, c, m, t]
349 (%i6) listarith : true;
350 (%o6) true
351 (%i7) [a, c, m, t] / [1, 7, 2, 9];
352 c m t
353 (%o7) [a, -, -, -]
354 7 2 9
355 @group
356 (%i8) [a, c, m, t] ^ x;
357 x x x x
358 (%o8) [a , c , m , t ]
359 @end group
360 @end example
361 @end deffn
363 @c --- 04.05.2011 DK -----------------------------------------------------------
364 @anchor{**}
365 @deffn {Operator} **
367 Ist eine alternative Schreibweise f@"ur den Operator @code{^} der
368 Exponentiation. In der Ausgabe wird entweder @code{^} angezeigt oder der
369 Exponent hochgestellt. Siehe den Operator der Exponentiation @mrefdot{^}
371 Die Funktion @mref{fortran} zeigt den Operator der Exponentiation immer als
372 @code{**} an, unabh@"angig davon, ob @code{**} oder @code{^} eingegeben wird.
374 Beispiele:
376 @example
377 (%i1) is (a**b = a^b);
378 (%o1) true
379 (%i2) x**y + x^z;
380 z y
381 (%o2) x + x
382 (%i3) string (x**y + x^z);
383 (%o3) x^z+x^y
384 (%i4) fortran (x**y + x^z);
385 x**z+x**y
386 (%o4) done
387 @end example
388 @end deffn
390 @c --- 04.05.2011 DK -----------------------------------------------------------
391 @anchor{^^}
392 @deffn {Operator} ^^
393 @ifinfo
394 @fnindex Nicht-kommutative Exponentiation
395 @end ifinfo
397 Ist der Operator der nicht-kommutativen Exponentiation von Matrizen. In der
398 linearen Ausgabe wird der nicht-kommutative Operator als @code{^^} angezeigt.
399 In der zweidimensionalen Ausgabe wird der hochgestellte Exponent von spitzen
400 Klammern @code{< >} eingeschlossen.
402 Beispiele:
404 @example
405 (%i1) a . a . b . b . b + a * a * a * b * b;
406 3 2 <2> <3>
407 (%o1) a b + a . b
408 (%i2) string (a . a . b . b . b + a * a * a * b * b);
409 (%o2) a^3*b^2+a^^2 . b^^3
410 @end example
411 @end deffn
413 @c --- 04.05.2011 DK -----------------------------------------------------------
414 @anchor{.}
415 @deffn {Operator} .
416 @ifinfo
417 @fnindex Nicht-kommutative Multiplikation
418 @end ifinfo
420 Ist der Operator der nicht-kommutativen Multiplikation von Matrizen. Siehe
421 f@"ur Erl@"auterungen @ref{Nicht-kommutative Multiplikation}.
422 @end deffn
424 @c -----------------------------------------------------------------------------
425 @node Relationale Operatoren, Logische Operatoren, Arithmetische Operatoren, Operatoren
426 @section Relationale Operatoren
427 @c -----------------------------------------------------------------------------
429 @c --- 31.10.2010 DK -----------------------------------------------------------
430 @anchor{<}
431 @anchor{<=}
432 @anchor{>=}
433 @anchor{>}
434 @deffn {Operator} <
435 @ifinfo
436 @fnindex kleiner als
437 @end ifinfo
438 @deffnx {Operator} <=
439 @ifinfo
440 @fnindex kleiner als oder gleich
441 @end ifinfo
442 @deffnx {Operator} >=
443 @ifinfo
444 @fnindex gr@"o@ss{}er als oder gleich
445 @end ifinfo
446 @deffnx {Operator} >
447 @ifinfo
448 @fnindex gr@"o@ss{}er als
449 @end ifinfo
451 Die Symbole @code{<}, @code{<=}, @code{>=} und @code{>} sind die relationalen
452 Operatoren "kleiner als", "kleiner als oder gleich", "gr@"o@ss{}er als oder
453 gleich" und "gr@"o@ss{}er als". Die Namen dieser Operatoren sind jeweils:
454 @code{"<"}, @code{"<="}, @code{">="} und @code{">"}. Diese k@"onnen dort
455 eingesetzt werden, wo der Name des Operators ben@"otigt wird.
457 Die relationalen Operatoren sind bin@"are Operatoren. Ausdr@"ucke wie
458 @code{a < b < c} werden von Maxima nicht erkannt und generieren eine
459 Fehlermeldung.
461 Relationale Ausdr@"ucke werden von den Funktionen @mref{is} und
462 @mref{maybe} sowie den Funktionen @mrefcomma{if} @mref{while} und
463 @mref{unless} zu booleschen Werten ausgewertet. Relationale Ausdr@"ucke werden
464 ansonsten nicht zu booleschen Werten ausgewertet oder vereinfacht. Jedoch
465 werden die Operanden eines booleschen Ausdruckes ausgewertet, wenn die
466 Auswertung nicht mit dem @mxref{', Quote-Operator} @code{'} unterdr@"uckt ist.
468 Wenn ein relationaler Ausdruck mit den Funktionen @code{is} oder @code{if} nicht
469 zu @code{true} oder @code{false} ausgewertet werden kann, wird das Verhalten der
470 Funktionen von der Optionsvariablen @mref{prederror} kontrolliert. Hat
471 @code{prederror} den Wert @code{true}, wird von @code{is} und @code{if} ein
472 Fehler erzeugt. Hat @code{prederror} den Wert @code{false}, hat @code{is} den
473 R@"uckgabewert @code{unknown} und @code{if} gibt einen konditionalen Ausdruck
474 zur@"uck, der teilweise ausgewertet ist.
476 Die Funktion @code{maybe} verh@"alt sich immer so, als ob @code{prederror} den
477 Wert @code{false} hat, und die Schleifenanweisungen @code{while} sowie
478 @code{unless} verhalten sich immer so, als ob @code{prederror} den Wert
479 @code{true} hat.
481 Relationale Operatoren werden nicht auf die Elemente von Listen oder Matrizen
482 sowie auf die beiden Seiten einer Gleichung angewendet.
484 Siehe auch die Operatoren @mref{=} und @mref{#} sowie die Funktionen
485 @mref{equal} und @mrefdot{notequal}
487 Beispiele:
489 Relationale Ausdr@"ucke werden von einigen Funktionen zu booleschen Werten
490 ausgewertet.
492 @example
493 (%i1) [x, y, z] : [123, 456, 789];
494 (%o1) [123, 456, 789]
495 (%i2) is (x < y);
496 (%o2) true
497 (%i3) maybe (y > z);
498 (%o3) false
499 (%i4) if x >= z then 1 else 0;
500 (%o4) 0
501 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
502 return (S));
503 (%o5) 5050
504 @end example
506 Relationale Ausdr@"ucke werden ansonsten nicht zu booleschen Werten ausgewertet
507 oder vereinfacht, jedoch werden die Operanden eines relationalen Ausdruckes
508 ausgewertet.
510 @example
511 (%i1) [x, y, z] : [123, 456, 789];
512 (%o1) [123, 456, 789]
513 (%i2) [x < y, y <= z, z >= y, y > z];
514 (%o2) [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
515 (%i3) map (is, %);
516 (%o3) [true, true, true, false]
517 @end example
518 @end deffn
520 @c -----------------------------------------------------------------------------
521 @node Logische Operatoren, Operatoren f@"ur Gleichungen, Relationale Operatoren, Operatoren
522 @section Logische Operatoren
523 @c -----------------------------------------------------------------------------
525 @c --- 14.09.2011 DK -----------------------------------------------------------
526 @anchor{and}
527 @deffn {Operator} and
528 @ifinfo
529 @fnindex Logische Konjunktion
530 @end ifinfo
532 Ist der logische Operator der Konjunktion. @code{and} ist ein
533 N-ary-Operator. Die Operanden sind boolesche Ausdr@"ucke und das Ergebnis ist
534 ein boolescher Wert.
536 Der Operator @code{and} erzwingt die Auswertung aller oder einen Teil der
537 Operanden. Die Operanden werden in der Reihenfolge ausgewertet, in der sie
538 auftreten. @code{and} wertet nur so viele Operanden aus, wie n@"otig sind, um
539 das Ergebnis des Ausdrucks zu bestimmen. Hat irgendein Argument den Wert
540 @code{false}, ist das Ergebnis @code{false} und die weiteren Argumente werden
541 nicht ausgewertet.
543 Die Optionsvariable @mref{prederror} kontrolliert das Verhalten von @code{and}
544 f@"ur den Fall, dass ein Operand nicht zu @code{true} oder @code{false}
545 ausgewertet werden kann. @code{and} gibt eine Fehlermeldung aus, wenn
546 @code{prederror} den Wert @code{true} hat. Andernfalls werden Operanden
547 akzeptiert, die nicht zu @code{true} oder @code{false} ausgewertet werden
548 k@"onnen und das Ergebnis ist ein boolescher Ausdruck.
550 @code{and} ist nicht kommutativ, da aufgrund von nicht ausgewerteten Operanden
551 die Ausdr@"ucke @code{a and b} und @code{b and a} ein unterschiedliches Ergebnis
552 haben k@"onnen.
554 Beispiele:
556 @example
557 (%i1) n:2;
558 (%o1) 2
559 (%i2) integerp(n) and evenp(n);
560 (%o2) true
561 (%i3) not(a=b) and 1=1 and integerp(2);
562 (%o3) true
563 (%i4) not(a=b) and 1=1 and oddp(2);
564 (%o4) false
565 (%i5) a and b;
566 (%o5) a and b
567 (%i6) prederror:true$
568 (%i7) a and b;
570 Unable to evaluate predicate a
571 -- an error. To debug this try: debugmode(true);
572 @end example
574 Da @code{and} nur so viele Operanden auswertet wie notwendig sind, um das
575 Ergebnis festzustellen, f@"uhrt der syntaktische Fehler im zweiten Operanden
576 nicht zu einer Fehlermeldung, das das Ergebnis bereits mit dem ersten
577 Operanden feststeht.
579 @example
580 (%i8) a=b and sin(2,2);
581 (%o8) false
582 @end example
583 @end deffn
585 @c --- 14.09.2011 DK -----------------------------------------------------------
586 @anchor{or}
587 @deffn {Operator} or
588 @ifinfo
589 @fnindex Logische Disjunktion
590 @end ifinfo
592 Ist der logische Operator der Disjunktion. @code{or} ist ein N-ary-Operator.
593 Die Operanden sind boolesche Ausdr@"ucke und das Ergebnis ist ein boolescher
594 Wert.
596 Der Operator @code{or} erzwingt die Auswertung aller oder einen Teil der
597 Operanden. Die Operanden werden in der Reihenfolge ausgewertet, in der sie
598 auftreten. @code{or} wertet nur so viele Operanden aus wie n@"otig sind, um
599 das Ergebnis des Ausdrucks zu bestimmen. Hat irgendein Operand den Wert
600 @code{true}, ist das Ergebnis @code{true} und die weiteren Operanden werden
601 nicht ausgewertet.
603 Die Optionsvariable @mref{prederror} kontrolliert das Verhalten von @code{or}
604 f@"ur den Fall, dass ein Operand nicht zu @code{true} oder @code{false}
605 ausgewertet werden kann. @code{or} gibt eine Fehlermeldung, wenn
606 @code{prederror} den Wert @code{true} hat. Andernfalls werden Operanden
607 akzeptiert, die nicht zu @code{true} oder @code{false} ausgewertet werden
608 k@"onnen und das Ergebnis ist ein boolescher Ausdruck.
610 @code{or} ist nicht kommutativ, da aufgrund von nicht ausgewerteten Operanden
611 die Ausdr@"ucke @code{a or b} und @code{b or a} ein unterschiedliches Ergebnis
612 haben k@"onnen.
614 Beispiele:
616 @example
617 (%i1) n:2;
618 (%o1) 2
619 (%i2) oddp(n) or evenp(n);
620 (%o2) true
621 (%i3) a=b or not(1=1) or integerp(2);
622 (%o3) true
623 (%i4) a or b;
624 (%o4) a or b
625 (%i5) prederror:true$
626 (%i6) a or b;
628 Unable to evaluate predicate a
629 -- an error. To debug this try: debugmode(true);
630 @end example
632 Da @code{or} nur so viele Operanden auswertet wie notwendig sind, um das
633 Ergebnis festzustellen, f@"uhrt der syntaktische Fehler im zweiten Operanden
634 nicht zu einer Fehlermeldung, da das Ergebnis bereits mit dem ersten
635 Operanden feststeht.
637 @example
638 (%i7) integerp(2) or sin(2,2);
639 (%o7) true
640 @end example
641 @end deffn
643 @c --- 14.09.2011 DK -----------------------------------------------------------
644 @anchor{not}
645 @deffn {Operator} not
646 @ifinfo
647 @fnindex Logische Negation
648 @end ifinfo
650 Ist die logische Negation. @code{not} ist ein Prefix-Operator. Der Operand
651 ist ein boolescher Ausdruck und das Ergebnis ein boolescher Wert.
653 Der Operator @code{not} erzwingt die Auswertung des Operanden. Die
654 Optionsvariable @mref{prederror} kontrolliert das Verhalten von @code{not} f@"ur
655 den Fall, dass der Operand nicht zu @code{true} oder @code{false} ausgewertet
656 werden kann. @code{not} gibt eine Fehlermeldung, wenn @code{prederror} den Wert
657 @code{true} hat. Andernfalls wird ein Operand akzeptiert, der nicht zu
658 @code{true} oder @code{false} ausgewertet werden kann, und das Ergebnis ist ein
659 boolescher Ausdruck.
661 Beispiele:
663 @example
664 (%i1) not integerp(2);
665 (%o1) false
666 (%i2) not (a=b);
667 (%o2) true
668 (%i3) not a;
669 (%o3) not a
670 (%i4) prederror:true$
671 (%i5) not a;
673 Unable to evaluate predicate a
674 -- an error. To debug this try: debugmode(true);
675 @end example
676 @end deffn
678 @c -----------------------------------------------------------------------------
679 @node Operatoren f@"ur Gleichungen, Zuweisungsoperatoren, Logische Operatoren, Operatoren
680 @section Operatoren f@"ur Gleichungen
681 @c -----------------------------------------------------------------------------
683 @c --- 24.09.2011 DK -----------------------------------------------------------
684 @anchor{#}
685 @deffn {Operator} #
686 @ifinfo
687 @fnindex Nicht gleich (Ungleichheit)
688 @end ifinfo
690 Ist der Operator f@"ur eine Ungleichung. @code{#} ist ein Infix-Operator mit
691 zwei Operanden.
693 Mit dem Operator @code{#} wird eine Ungleichung @code{a # b} formuliert, wobei
694 die Operanden @code{a} und @code{b} jeweils die linke und die rechte Seite der
695 Ungleichung sind und beliebige Ausdr@"ucke sein k@"onnen. Die Operanden werden
696 ausgewertet, nicht jedoch die Ungleichung selbst.
698 Die Funktionen @mrefcomma{is} @mrefcomma{maybe} die logischen Operatoren
699 @mrefcomma{and} @mref{or} und @mref{not} sowie die Funktionen f@"ur die
700 Definition von Programmanweisungen wie @mrefcomma{if} @mref{while} oder
701 @mref{unless} erzwingen die Auswertung einer Ungleichung.
703 Wegen der Regeln f@"ur die Auswertung von Aussagen und weil @code{not expr} die
704 Auswertung des Argumentes @code{expr} bewirkt, ist der Ausdruck
705 @code{not (a = b)} @"aquivalent zu @code{is(a # b)} und nicht zu @code{a # b}.
707 Die Funktionen @mref{rhs} und @mref{lhs} geben die rechte und die linke Seite
708 einer Gleichung oder Ungleichung zur@"uck.
710 Siehe auch den Operator @mrefcomma {=} um eine Gleichung zu formulieren, sowie
711 die Funktionen @mref{equal} und @mrefdot{notequal}
713 Beispiele:
715 @example
716 (%i1) a = b;
717 (%o1) a = b
718 (%i2) is (a = b);
719 (%o2) false
720 (%i3) a # b;
721 (%o3) a # b
722 (%i4) not (a = b);
723 (%o4) true
724 (%i5) is (a # b);
725 (%o5) true
726 (%i6) is (not (a = b));
727 (%o6) true
728 @end example
729 @end deffn
731 @c --- 24.09.2011 DK -----------------------------------------------------------
732 @need 900
733 @anchor{=}
734 @deffn {Operator} =
735 @ifinfo
736 @fnindex Operator f@"ur Gleichungen
737 @fnindex gleich (Gleichheit)
738 @end ifinfo
740 Ist der Operator f@"ur eine Gleichung. @code{=} ist ein Infix-Operator mit
741 zwei Operanden.
743 Mit dem Operator @code{=} wird eine Gleichung @code{a = b} formuliert, wobei die
744 Operanden @code{a} und @code{b} jeweils die linke und die rechte Seite der
745 Gleichung sind und beliebige Ausdr@"ucke sein k@"onnen. Die Operanden werden
746 ausgewertet, nicht jedoch die Gleichung selbst. Nicht ausgewertete Gleichungen
747 k@"onnen als Argument von Funktionen wie zum Beispiel den Funktionen
748 @mrefcomma{solve} @mref{algsys} oder @mref{ev} auftreten.
750 Die Funktion @mref{is} wertet eine Gleichung @code{=} zu einem booleschen Wert
751 aus. @code{is(a = b)} wertet die Gleichung @code{a = b} zum Wert @code{true}
752 aus, wenn @code{a} und @code{b} identische Ausdr@"ucke sind. Das trifft zu,
753 wenn @code{a} und @code{b} identische Atome sind oder wenn ihre Operatoren sowie
754 die Operanden identisch sind. In jedem anderen Fall ist das Ergebnis
755 @code{false}. Das Ergebnis der Auswertung ist nie @code{unkown}. Hat
756 @code{is(a = b)} das Ergebnis @code{true}, werden @code{a} und @code{b} als
757 syntaktisch gleich bezeichnet. Im Unterschied dazu gilt f@"ur @"aquivalente
758 Ausdr@"ucke, dass @code{is(equal(a, b))} den Wert @code{true} hat. Ausdr@"ucke
759 k@"onnen @"aquivalent aber syntaktisch verschieden sein.
761 Eine Ungleichung wird mit dem Operator @mref{#} formuliert. Wie f@"ur den
762 Operator @code{=} f@"ur eine Gleichung wird eine Ungleichung @code{a # b} nicht
763 ausgewertet. Eine Auswertung erfolgt mit @code{is(a # b)}, welche die Werte
764 @code{true} oder @code{false} als Ergebnis hat.
766 Neben @code{is} werten auch die Operatoren @mrefcomma{if} @mrefcomma{and}@w{}
767 @mref{or} und @mref{not} Gleichungen mit dem Operator @code{=} oder
768 Ungleichungen mit dem Operator @code{#} zu den Werten @code{true} oder
769 @code{false} aus.
771 Wegen der Regeln f@"ur die Auswertung von Aussagen und weil im Ausdruck
772 @code{not expr} der Operand @code{expr} ausgewertet wird, ist
773 @code{not a = b} @"aquivalent zu @code{is(a # b)} und nicht zu @code{a # b}.
775 Die Funktionen @mref{rhs} und @mref{lhs} geben die rechte und die linke Seite
776 einer Gleichung oder Ungleichung zur@"uck.
778 Siehe auch den Operator @mref{#} f@"ur Ungleichungen sowie die Funktionen
779 @mref{equal} und @mrefdot{notequal}
781 Beispiele:
783 Ein Ausdruck @code{a = b} repr@"asentiert eine nicht ausgewertete Gleichung.
785 @example
786 (%i1) eq_1 : a * x - 5 * y = 17;
787 (%o1) a x - 5 y = 17
788 (%i2) eq_2 : b * x + 3 * y = 29;
789 (%o2) 3 y + b x = 29
790 (%i3) solve ([eq_1, eq_2], [x, y]);
791 196 29 a - 17 b
792 (%o3) [[x = ---------, y = -----------]]
793 5 b + 3 a 5 b + 3 a
794 (%i4) subst (%, [eq_1, eq_2]);
795 196 a 5 (29 a - 17 b)
796 (%o4) [--------- - --------------- = 17,
797 5 b + 3 a 5 b + 3 a
798 196 b 3 (29 a - 17 b)
799 --------- + --------------- = 29]
800 5 b + 3 a 5 b + 3 a
801 (%i5) ratsimp (%);
802 (%o5) [17 = 17, 29 = 29]
803 @end example
805 @code{is(a = b)} wertet die Gleichung @code{a = b} zu @code{true} aus, wenn
806 @code{a} und @code{b} syntaktisch gleich sind. Ausdr@"ucke k@"onnen
807 @"aquivalent sein, ohne syntaktisch gleich zu sein.
809 @example
810 (%i1) a : (x + 1) * (x - 1);
811 (%o1) (x - 1) (x + 1)
812 (%i2) b : x^2 - 1;
813 2
814 (%o2) x - 1
815 (%i3) [is (a = b), is (a # b)];
816 (%o3) [false, true]
817 (%i4) [is (equal (a, b)), is (notequal (a, b))];
818 (%o4) [true, false]
819 @end example
821 Einige Operatoren werten @code{=} und @code{#} zu @code{true} oder @code{false}
822 aus.
824 @example
825 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
826 BAR;
827 (%o1) FOO
828 (%i2) eq_3 : 2 * x = 3 * x;
829 (%o2) 2 x = 3 x
830 (%i3) eq_4 : exp (2) = %e^2;
831 2 2
832 (%o3) %e = %e
833 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
834 (%o4) [false, true, true]
835 @end example
837 Da @code{not expr} die Auswertung des Ausdrucks @code{expr} bewirkt, ist
838 @code{not (a = b)} @"aquivalent zu @code{is(a # b)}.
840 @example
841 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
842 (%o1) [2 x # 3 x, true]
843 (%i2) is (2 * x # 3 * x);
844 (%o2) true
845 @end example
846 @end deffn
848 @c -----------------------------------------------------------------------------
849 @node Zuweisungsoperatoren, Nutzerdefinierte Operatoren, Operatoren f@"ur Gleichungen, Operatoren
850 @section Zuweisungsoperatoren
851 @c -----------------------------------------------------------------------------
853 @c --- 17.10.2010 DK -----------------------------------------------------------
854 @anchor{:}
855 @deffn {Operator} :
856 @ifinfo
857 @fnindex Zuweisungsoperator
858 @end ifinfo
860 Ist der Operator f@"ur die Zuweisung eines Wertes an eine Variable.
862 Ist die linke Seite eine Variable (ohne Index), wertet der Operator @code{:} die
863 rechte Seite aus und weist den Wert der Variablen auf der linken Seite zu.
865 Ist die linke Seite ein Element einer Liste, Matrix oder ein deklariertes
866 Maxima- oder Lisp-Array, wird die rechte Seite diesem Element zugewiesen. Der
867 Index muss ein existierendes Element bezeichnen.
869 Ist die linke Seite ein Element eines nicht deklarierten Arrays, dann wird
870 die rechte Seite diesem Element zugewiesen, falls dieses existiert. Existiert
871 das Element noch nicht, wird ein neues Element erzeugt.
873 Ist die linke Seite eine Liste mit Variablen (ohne Index), muss die rechte Seite
874 zu einer Liste auswerten. Die Elemente der Liste auf der rechten Seite werden
875 den Elementen auf der linken Seite parallel zugewiesen.
877 Siehe auch @mref{kill} und @mref{remvalue} f@"ur die Aufhebung der Zuweisung
878 eines Wertes an ein Symbol.
880 Beispiele:
882 Zuweisung an eine einfache Variable.
884 @example
885 (%i1) a;
886 (%o1) a
887 (%i2) a : 123;
888 (%o2) 123
889 (%i3) a;
890 (%o3) 123
891 @end example
893 Zuweisung an ein Element einer Liste.
895 @example
896 (%i1) b : [1, 2, 3];
897 (%o1) [1, 2, 3]
898 (%i2) b[3] : 456;
899 (%o2) 456
900 (%i3) b;
901 (%o3) [1, 2, 456]
902 @end example
904 Die Zuweisung erzeugt ein nicht deklariertes Array.
906 @example
907 (%i1) c[99] : 789;
908 (%o1) 789
909 (%i2) c[99];
910 (%o2) 789
911 (%i3) c;
912 (%o3) c
913 (%i4) arrayinfo (c);
914 (%o4) [hashed, 1, [99]]
915 (%i5) listarray (c);
916 (%o5) [789]
917 @end example
919 Mehrfache Zuweisung.
921 @example
922 (%i1) [a, b, c] : [45, 67, 89];
923 (%o1) [45, 67, 89]
924 (%i2) a;
925 (%o2) 45
926 (%i3) b;
927 (%o3) 67
928 (%i4) c;
929 (%o4) 89
930 @end example
932 Die mehrfache Zuweisung wird parallel ausgef@"uhrt. Die Werte von @code{a} und
933 @code{b} werden in diesem Beispiel ausgetauscht.
935 @example
936 (%i1) [a, b] : [33, 55];
937 (%o1) [33, 55]
938 (%i2) [a, b] : [b, a];
939 (%o2) [55, 33]
940 (%i3) a;
941 (%o3) 55
942 (%i4) b;
943 (%o4) 33
944 @end example
945 @end deffn
947 @c --- 17.10.2010 DK -----------------------------------------------------------
948 @anchor{::}
949 @deffn {Operator} ::
950 @ifinfo
951 @fnindex Zuweisungsoperator (wertet die linke Seite aus)
952 @end ifinfo
954 Ist der Operator f@"ur die Zuweisung eines Wertes an eine Variable.
956 Der Operator @code{::} ist vergleichbar mit dem Operator @mref{:} mit dem
957 Unterschied, dass @code{::} sowohl die rechte als auch die linke Seite
958 auswertet.
960 Beispiele:
962 @example
963 (%i1) x : 'foo;
964 (%o1) foo
965 (%i2) x :: 123;
966 (%o2) 123
967 (%i3) foo;
968 (%o3) 123
969 (%i4) x : '[a, b, c];
970 (%o4) [a, b, c]
971 (%i5) x :: [11, 22, 33];
972 (%o5) [11, 22, 33]
973 (%i6) a;
974 (%o6) 11
975 (%i7) b;
976 (%o7) 22
977 (%i8) c;
978 (%o8) 33
979 @end example
980 @end deffn
982 @c --- 17.10.2010 DK -----------------------------------------------------------
983 @anchor{::=}
984 @deffn {Operator} ::=
985 @ifinfo
986 @fnindex Operator f@"ur Makrodefinitionen
987 @end ifinfo
989 Ist der Operator f@"ur die Definition von Makro-Funktionen.
991 Der Operator @code{::=} definiert eine Makro-Funktion, das ist eine Funktion,
992 die ihre Argumente nicht auswertet. Der Ausdruck, der die Makro-Funktion
993 definiert, wird in dem Kontext ausgewertet, in dem das Makro aufgerufen wird.
994 Ansonsten verh@"alt sich eine Makro-Funktion wie eine gew@"ohnliche Funktion.
996 Die Funktion @mref{macroexpand} expandiert eine Makro-Funktion, ohne sie
997 auszuwerten. @code{macroexpand(foo(x))} dem @code{''%} folgt, ist @"aquivalent
998 zu @code{foo(x)}, wenn @code{foo} eine Makro-Funktion ist.
1000 Der Operator @code{::=} f@"ugt den Namen der neuen Makro-Funktion der
1001 Informationsliste @mref{macros} hinzu. Die Funktionen @mrefcomma{kill}@w{}
1002 @mref{remove} und @mref{remfunction} heben die Zuweisung der Makro-Funktion an
1003 ein Symbol auf und entfernen die Makro-Funktion von der Informationsliste
1004 @code{macros}.
1006 Die Funktionen @mref{fundef} oder @mref{dispfun} geben die Definition einer
1007 Makro-Funktion zur@"uck oder weisen die Makro-Funktion einer Marke zu.
1009 Makro-Funktionen enthalten h@"aufig Ausdr@"ucke mit den Funktionen
1010 @mref{buildq} und @mrefdot{splice} Mit diesen werden Ausdr@"ucke konstruiert,
1011 die dann ausgewertet werden.
1013 @need 800
1014 Beispiele:
1016 Eine Makro-Funktion wertet ihre Argumente nicht aus. Daher zeigt Beispiel (1)
1017 @code{y - z} und nicht den Wert von @code{y - z}. Das Makro wird in
1018 dem Kontext ausgewertet, in dem das Makro aufgerufen wird. Dies zeigt (2).
1020 @example
1021 (%i1) x: %pi$
1023 (%i2) y: 1234$
1025 (%i3) z: 1729 * w$
1027 (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
1028 '(print ("(2) x is equal to", x)))$
1030 (%i5) printq1 (y - z);
1031 (1) x is equal to y - z
1032 (2) x is equal to %pi
1033 (%o5) %pi
1034 @end example
1036 Eine gew@"ohnliche Funktion wertet ihre Argumente aus. Daher zeigt (1) den Wert
1037 von @code{y - z}. Der R@"uckgabewert wird nicht ausgewertet und gibt (2). Mit
1038 @code{''%} wird die Auswertung erzwungen.
1040 @example
1041 (%i1) x: %pi$
1043 (%i2) y: 1234$
1045 (%i3) z: 1729 * w$
1047 (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
1048 '(print ("(2) x is equal to", x)))$
1050 (%i5) printe1 (y - z);
1051 (1) x is equal to 1234 - 1729 w
1052 (%o5) print((2) x is equal to, x)
1053 (%i6) ''%;
1054 (2) x is equal to %pi
1055 (%o6) %pi
1056 @end example
1058 @mref{macroexpand} gibt die Expansion des Makros zur@"uck.
1059 @code{macroexpand(foo(x))} dem @code{''%} folgt, ist @"aquivalent zu
1060 @code{foo(x)}, wenn @code{foo} eine Makro-Funktion ist.
1062 @example
1063 (%i1) x: %pi$
1065 (%i2) y: 1234$
1067 (%i3) z: 1729 * w$
1069 (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
1071 (%i5) macroexpand (g (y - z));
1072 (%o5) print(x is equal to, y - z)
1073 (%i6) ''%;
1074 x is equal to 1234 - 1729 w
1075 (%o6) 1234 - 1729 w
1076 (%i7) g (y - z);
1077 x is equal to 1234 - 1729 w
1078 (%o7) 1234 - 1729 w
1079 @end example
1080 @end deffn
1082 @c --- 09.10.2010 DK -----------------------------------------------------------
1083 @anchor{:=}
1084 @deffn {Operator} :=
1085 @ifinfo
1086 @fnindex Operator f@"ur Funktionsdefinitionen
1087 @end ifinfo
1089 Ist der Operator f@"ur Funktionsdefinitionen.
1091 @code{@var{f}(@var{x_1}, ..., @var{x_n})} := @var{expr} definiert eine Funktion
1092 mit dem Namen @var{f}, den Argumenten @var{x_1}, @dots{}, @var{x_n} und der
1093 Funktionsdefinition @var{expr}. Der Operator @code{:=} wertet die
1094 Funktionsdefinition nicht aus. Die Auswertung kann mit dem
1095 @nxref{'', Quote-Quote-Operator} @code{''} erzwungen werden. Die definierte
1096 Funktion kann eine gew@"ohnliche Maxima-Funktion @code{f(x)} sein oder eine
1097 Array-Funktion @code{f[i](x)}.
1099 Ist das letzte oder das einzige Argument der Funktion @var{x_n} eine Liste mit
1100 einem Element, dann akzeptiert die mit @code{:=} definierte Funktion eine
1101 variable Anzahl an Argumenten. Die Argumente werden zun@"achst nacheinander den
1102 Argumenten @var{x_1}, @dots{}, @var{x_(n - 1)} zugewiesen. Sind weitere
1103 Argumente vorhanden, werden diese @var{x_n} als Liste zugewiesen.
1105 Funktionsdefinitionen erscheinen im globalen Namensraum. Wird eine Funktion
1106 @code{f} innerhalb einer Funktion @code{g} definiert, wird die Reichweite der
1107 Funktion nicht automatisch auf @code{g} beschr@"ankt. Dagegen f@"uhrt
1108 @code{local(f)} zu einer Definition, die nur innerhalb eines Blockes oder einem
1109 anderen zusammengesetzten Ausdr@"uck erscheint. Siehe auch @mrefdot{local}
1111 Ist eines der Argumente ein Symbol auf das der @nxref{', Quote-Operator}@w{}
1112 @code{'} angewendet wurde, wird dieses Argument nicht ausgewertet. Ansonsten
1113 werden alle Argumente ausgewertet.
1115 Siehe auch @mref{define} und @mrefdot{::=}
1117 Beispiele:
1119 @code{:=} wertet die Funktionsdefinition nie aus, au@ss{}er wenn der
1120 Quote-Quote-Operator angewendet wird.
1122 @example
1123 (%i1) expr : cos(y) - sin(x);
1124 (%o1) cos(y) - sin(x)
1125 (%i2) F1 (x, y) := expr;
1126 (%o2) F1(x, y) := expr
1127 (%i3) F1 (a, b);
1128 (%o3) cos(y) - sin(x)
1129 (%i4) F2 (x, y) := ''expr;
1130 (%o4) F2(x, y) := cos(y) - sin(x)
1131 (%i5) F2 (a, b);
1132 (%o5) cos(b) - sin(a)
1133 @end example
1135 Mit dem Operator @code{:=} definierte Funktionen k@"onnen eine gew@"ohnliche
1136 Maxima-Funktion oder eine Array-Funktion sein.
1138 @example
1139 (%i1) G1 (x, y) := x.y - y.x;
1140 (%o1) G1(x, y) := x . y - y . x
1141 (%i2) G2 [x, y] := x.y - y.x;
1142 (%o2) G2 := x . y - y . x
1143 x, y
1144 @end example
1146 Ist das letzte oder einzige Argument @var{x_n} eine Liste mit einem Element,
1147 dann akzeptiert die Funktion eine variable Anzahl an Argumenten.
1149 @example
1150 (%i1) H ([L]) := apply ("+", L);
1151 (%o1) H([L]) := apply("+", L)
1152 (%i2) H (a, b, c);
1153 (%o2) c + b + a
1154 @end example
1156 @mref{local} erzeugt eine lokale Funktionsdefinition.
1158 @example
1159 (%i1) foo (x) := 1 - x;
1160 (%o1) foo(x) := 1 - x
1161 (%i2) foo (100);
1162 (%o2) - 99
1163 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1164 (%o3) 200
1165 (%i4) foo (100);
1166 (%o4) - 99
1167 @end example
1168 @end deffn
1170 @c -----------------------------------------------------------------------------
1171 @node Nutzerdefinierte Operatoren, , Zuweisungsoperatoren, Operatoren
1172 @section Nutzerdefinierte Operatoren
1173 @c -----------------------------------------------------------------------------
1175 @menu
1176 * Einf@"uhrung in nutzerdefinierte Operatoren::
1177 * Funktionen und Variablen f@"ur nutzerdefinierte Operatoren::
1178 @end menu
1180 @c -----------------------------------------------------------------------------
1181 @node Einf@"uhrung in nutzerdefinierte Operatoren, Funktionen und Variablen f@"ur nutzerdefinierte Operatoren, Nutzerdefinierte Operatoren, Nutzerdefinierte Operatoren
1182 @subsection Einf@"uhrung in nutzerdefinierte Operatoren
1183 @c -----------------------------------------------------------------------------
1185 Es ist m@"oglich neue Operatoren zu definieren, vorhandene Operatoren zu
1186 entfernen oder deren Eigenschaften zu @"andern. Jede Funktion kann als ein
1187 Operator definiert werden, die Funktion kann, muss aber nicht definiert sein.
1189 Im Folgenden werden die Operatoren @code{dd} und @code{"<-"} definiert. Nach
1190 der Definition als Operatoren ist @code{dd a} gleichbedeutend mit @code{"dd"(a)}
1191 und @code{a <- b} entspricht dem Funktionsaufruf @code{"<-"(a,b)}. In diesem
1192 Beispiel sind die Funktionen @code{"dd"} und @code{"<-"} nicht definiert.
1194 @example
1195 (%i1) prefix ("dd");
1196 (%o1) dd
1197 (%i2) dd a;
1198 (%o2) dd a
1199 (%i3) "dd" (a);
1200 (%o3) dd a
1201 (%i4) infix ("<-");
1202 (%o4) <-
1203 (%i5) a <- dd b;
1204 (%o5) a <- dd b
1205 (%i6) "<-" (a, "dd" (b));
1206 (%o6) a <- dd b
1207 @end example
1209 Maxima kennt die folgenden Funktionen, um Operatoren zu definieren:
1210 @code{prefix}, @code{postfix}, @code{infix}, @code{nary}, @code{matchfix} und
1211 @code{nofix}.
1213 Der Vorrang eines Operators @var{op} vor anderen Operatoren leitet sich aus dem
1214 links- und rechtsseitigen Vorrang des Operators ab. Sind die links- und
1215 rechtsseitigen Vorr@"ange von @var{op} beide gr@"o@ss{}er als der links-
1216 und rechtsseitige Vorrang eines anderen Operators, dann hat @var{op}
1217 Vorrang vor diesem Operator. Sind die Vorr@"ange nicht beide gr@"o@ss{}er oder
1218 kleiner, werden weitere Regeln zur Bestimmung des Vorrangs herangezogen.
1220 Maxima kennt die Wortart eines Operanden und des Ergebnisses eines Operanden.
1221 Wortart bedeutet hier, den Typ eines Operanden. Maxima kennt die drei Typen
1222 @code{expr}, @code{clause} und @code{any}. Diese stehen f@"ur einen
1223 algebraischen Ausdruck, einen logischen Ausdruck und einen beliebigen Ausdruck.
1224 Mit Hilfe der f@"ur einen Operator definierten Wortart kann der Parser beim
1225 Einlesen eines Ausdrucks Syntaxfehler feststellen.
1227 Die Assoziativit@"at eines Operators @var{op} h@"angt ab von seinem Vorrang.
1228 Ein gr@"o@ss{}erer linksseitiger Vorrang hat zur Folge, dass der Operator
1229 @var{op} vor einem anderen Operator auf seiner linken Seite ausgewertet wird.
1230 W@"ahrend ein gr@"o@ss{}erer rechtsseitiger Vorrang zur Folge hat, dass der
1231 Operator vor anderen Operatoren auf der rechten Seite ausgewertet wird. Daraus
1232 folgt, dass ein gr@"o@ss{}erer linksseitiger Vorrang @var{lbp} einen Operator
1233 @var{op} rechts-assoziativ und eine gr@"o@ss{}erer rechtsseitiger Vorrang
1234 @var{rbp} den Operator links-assoziativ macht. Sind der links- und
1235 rechtsseitige Vorrang gleich gro@ss{}, ist der Operator @var{op}
1236 links-assoziativ.
1238 Mit den Befehlen @mref{remove} und @mref{kill} k@"onnen Operatoreigenschaften
1239 von einem Symbol entfernt werden. @code{remove("@var{a}", op)} entfernt
1240 die Operatoreigenschaften des Symbols @var{a}. @code{kill("@var{a}")} entfernt
1241 alle Eigenschaften einschlie@ss{}ich der Operator-Eigenschaften des Symbols
1242 @var{a}. In diesem Fall steht der Name des Symbols in Anf@"uhrungszeichen.
1244 @example
1245 (%i1) infix ("##");
1246 (%o1) ##
1247 (%i2) "##" (a, b) := a^b;
1248 b
1249 (%o2) a ## b := a
1250 (%i3) 5 ## 3;
1251 (%o3) 125
1252 (%i4) remove ("##", op);
1253 (%o4) done
1254 (%i5) 5 ## 3;
1255 Incorrect syntax: # is not a prefix operator
1256 5 ##
1257 ^
1258 (%i5) "##" (5, 3);
1259 (%o5) 125
1260 (%i6) infix ("##");
1261 (%o6) ##
1262 (%i7) 5 ## 3;
1263 (%o7) 125
1264 (%i8) kill ("##");
1265 (%o8) done
1266 (%i9) 5 ## 3;
1267 Incorrect syntax: # is not a prefix operator
1268 5 ##
1269 ^
1270 (%i9) "##" (5, 3);
1271 (%o9) ##(5, 3)
1272 @end example
1274 @c -----------------------------------------------------------------------------
1275 @node Funktionen und Variablen f@"ur nutzerdefinierte Operatoren, , Einf@"uhrung in nutzerdefinierte Operatoren, Nutzerdefinierte Operatoren
1276 @subsection Funktionen und Variablen f@"ur nutzerdefinierte Operatoren
1277 @c -----------------------------------------------------------------------------
1279 @c --- 04.05.2011 DK -----------------------------------------------------------
1280 @anchor{infix}
1281 @deffn {Funktion} infix (@var{op})
1282 @deffnx {Funktion} infix (@var{op}, @var{lbp}, @var{rbp})
1283 @deffnx {Funktion} infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})
1285 Deklariert @var{op} als einen Infix-Operator. Ein Infix-Operator hat eine
1286 Funktionsdefinition mit zwei Argumenten. Der Infix-Operator steht zwischen den
1287 Operanden. Zum Beispiel ist die Subtraktion @mref{-} ein Infix-Operator.
1289 @code{infix(@var{op})} deklariert @var{op} als einen Infix-Operator mit einem
1290 links- und rechtsseitigen Vorrang von jeweils 180.
1292 @code{infix(@var{op}, @var{lbp}, @var{rbp})} deklariert @var{op} als einen
1293 Infix-Operator mit den angegebenen Werten f@"ur den links- und rechtsseitigen
1294 Vorrang.
1296 @code{infix(@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})}
1297 deklariert @var{op} als einen Infix-Operator mit den angegebenen
1298 Vorr@"angen sowie den Wortarten @var{lpos}, @var{rpos} und @var{pos} f@"ur
1299 den linken und den rechten Operanden sowie das Ergebnis des Operators.
1301 Beispiele:
1303 Sind die rechtsseitigen und linksseitigen Vorr@"ange eines Operators
1304 @var{op} gr@"o@ss{}er als die entsprechenden Vorr@"ange eines anderen
1305 Operators, dann hat der Operator @var{op} Vorrang.
1307 @example
1308 (%i1) :lisp (get '$+ 'lbp)
1309 100
1310 (%i1) :lisp (get '$+ 'rbp)
1311 100
1312 (%i1) infix ("##", 101, 101);
1313 (%o1) ##
1314 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
1315 (%o2) (a ## b) := sconcat("(", a, ",", b, ")")
1316 (%i3) 1 + a ## b + 2;
1317 (%o3) (a,b) + 3
1318 (%i4) infix ("##", 99, 99);
1319 (%o4) ##
1320 (%i5) 1 + a ## b + 2;
1321 (%o5) (a+1,b+2)
1322 @end example
1324 Ein gr@"o@ss{}erer linksseitige Vorrang @var{lbp} bewirkt, dass der
1325 Operator @var{op} rechts-assoziativ ist. Ein gr@"o@ss{}erer rechtsseitiger
1326 Vorrang macht dagegen den Operator @var{op} links-as@-so@-zia@-tiv.
1328 @example
1329 (%i1) infix ("##", 100, 99);
1330 (%o1) ##
1331 (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
1332 (%i3) foo ## bar ## baz;
1333 (%o3) (foo,(bar,baz))
1334 (%i4) infix ("##", 100, 101);
1335 (%o4) ##
1336 (%i5) foo ## bar ## baz;
1337 (%o5) ((foo,bar),baz)
1338 @end example
1340 Maxima kann Syntaxfehler beim Einlesen eines Ausdrucks feststellen, wenn der
1341 eingelesene Operand nicht die f@"ur den Operator definierte Wortart hat.
1343 @example
1344 (%i1) infix ("##", 100, 99, expr, expr, expr);
1345 (%o1) ##
1346 (%i2) if x ## y then 1 else 0;
1347 Incorrect syntax: Found algebraic expression where
1348 logical expression expected
1349 if x ## y then
1350 ^
1351 (%i2) infix ("##", 100, 99, expr, expr, clause);
1352 (%o2) ##
1353 (%i3) if x ## y then 1 else 0;
1354 (%o3) if x ## y then 1 else 0
1355 @end example
1356 @end deffn
1358 @c --- 04.05.2011 DK -----------------------------------------------------------
1359 @anchor{matchfix}
1360 @deffn {Funktion} matchfix (@var{ldelimiter}, @var{rdelimiter})
1361 @deffnx {Funktion} matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})
1363 Deklariert einen Matchfix-Operator mit dem linksseitigen Begrenzungszeichen
1364 @var{ldelimiter} und dem rechtsseitigen Begrenzungszeichen @var{rdelimiter}.
1366 Ein Matchfix-Operator hat eine beliebige Anzahl an Argumenten, die zwischen
1367 dem linksseitigen und dem rechtsseitigen Begrenzungszeichen stehen. Das
1368 Begrenzungszeichen kann eine beliebige Zeichenkette sein. Einige Zeichen wie
1369 @code{%}, @code{,}, @code{$} und @code{;} k@"onnen nicht als Begrenzungszeichen
1370 definiert werden.
1372 Ein linksseitiges Begrenzungszeichen kann nicht verschiedene rechtsseitige
1373 Begrenzungszeichen haben.
1375 Maxima-Operatoren k@"onnen als Matchfix-Operatoren definiert werden, ohne
1376 dass sich die sonstigen Operatoreigenschaften @"andern. So kann zum Beispiel
1377 der Operator @code{+} als Matchfix-Operator definiert werden.
1379 @code{matchfix(@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})}
1380 definiert die Wortarten f@"ur die Argumente @var{arg_pos} und das Ergebnis
1381 @var{pos} sowie das linksseitige @var{ldelimiter} und rechtsseitige
1382 @var{rdelimiter} Begrenzungszeichen.
1384 Die zu einem Matchfix-Operator zugeh@"orige Funktion kann jede
1385 nutzerdefinierte Funktion sein, die mit @mref{:=} oder @mref{define} definiert
1386 wird. Die Definition der Funktion kann mit @code{dispfun(@var{ldelimiter})}
1387 ausgegeben werden.
1389 Maxima kennt nur den Operator f@"ur Listen @code{[ ]} als Matchfix-Operator.
1390 Klammern @code{( )} und Anf@"uhrungszeichen @code{" "} arbeiten wie
1391 Matchfix-Operatoren, werden aber vom Parser nicht als Matchfix-Operatoren
1392 behandelt.
1394 @mref{matchfix} wertet die Argumente aus. @code{matchfix} gibt das erste
1395 Argument @var{ldelimiter} als Ergebnis zur@"uck.
1397 Beispiele:
1399 Begrenzungszeichen k@"onnen eine beliebige Zeichenkette sein.
1401 @example
1402 (%i1) matchfix ("@@@@", "~");
1403 (%o1) @@@@
1404 (%i2) @@@@ a, b, c ~;
1405 (%o2) @@@@a, b, c~
1406 (%i3) matchfix (">>", "<<");
1407 (%o3) >>
1408 (%i4) >> a, b, c <<;
1409 (%o4) >>a, b, c<<
1410 (%i5) matchfix ("foo", "oof");
1411 (%o5) foo
1412 (%i6) foo a, b, c oof;
1413 (%o6) fooa, b, coof
1414 (%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
1415 >>z + foox, yoof + w<<
1416 (%o7) ----------------------
1417 @@@@p, q~
1418 @end example
1420 Matchfix-Operatoren k@"onnen f@"ur nutzerdefinierte Funktionen definiert
1421 werden.
1423 @example
1424 (%i1) matchfix ("!-", "-!");
1425 (%o1) "!-"
1426 (%i2) !- x, y -! := x/y - y/x;
1427 x y
1428 (%o2) !-x, y-! := - - -
1429 y x
1430 (%i3) define (!-x, y-!, x/y - y/x);
1431 x y
1432 (%o3) !-x, y-! := - - -
1433 y x
1434 (%i4) define ("!-" (x, y), x/y - y/x);
1435 x y
1436 (%o4) !-x, y-! := - - -
1437 y x
1438 (%i5) dispfun ("!-");
1439 x y
1440 (%t5) !-x, y-! := - - -
1441 y x
1443 (%o5) done
1444 (%i6) !-3, 5-!;
1445 16
1446 (%o6) - --
1447 15
1448 (%i7) "!-" (3, 5);
1449 16
1450 (%o7) - --
1451 15
1452 @end example
1453 @end deffn
1455 @c --- 04.05.2011 DK -----------------------------------------------------------
1456 @anchor{nary}
1457 @deffn {Funktion} nary (@var{op})
1458 @deffnx {Funktion} nary (@var{op}, @var{bp}, @var{arg_pos}, @var{pos})
1460 @code{nary(@var{op})} definiert einen @code{N-ary}-Operator @var{op} mit einem
1461 linksseitigen Vorrang von 180. Der rechtsseitige Vorrang wird nicht ben@"otigt.
1463 @code{nary(@var{op}, @var{bp}, @var{arg_pos}, @var{pos})} definiert einen
1464 @code{N-ary}-Operator @var{op} mit einem rechtsseitigen Vorrang von @var{bp} und
1465 der Wortart @var{arg_pos} f@"ur den Operanden und der Wortart @var{pos} für das
1466 Ergebnis.
1468 Ein @code{N-ary}-Operator ist ein Operator, der eine beliebige Anzahl an
1469 Argumenten haben kann. Die Argumente werden durch den Operator voneinander
1470 getrennt, so ist zum Beispiel @code{+} ein @code{N-ary}-Operator und
1471 @code{A+B+C}.
1473 Im Unterschied zur Definition eines Operators kann eine Funktion @code{f} auch
1474 als @mref{nary} mit der Funktion @mref{declare} deklariert werden. Die
1475 Deklaration hat Auswirkung auf die Vereinfachung der Funktion. Zum Beispiel
1476 wird ein Ausdruck @code{j(j(a,b),j(c,d)} zu @code{j(a,b,c,d)} vereinfacht.
1477 @end deffn
1479 @c --- 04.05.2011 DK -----------------------------------------------------------
1480 @anchor{nofix}
1481 @deffn {Funktion} nofix (@var{op})
1482 @deffnx {Funktion} nofix (@var{op}, @var{pos})
1484 @code{nofix(@var{op})} definiert den Operator @var{op} als einen Nofix-Operator.
1486 @code{nofix(@var{op}, @var{pos})} definiert einen Nofix-Operator mit der
1487 Wortart @var{pos} f@"ur das Ergebnis.
1489 Nofix-Operatoren sind Operatoren, die kein Argument haben. Tritt ein solcher
1490 Operator allein auf, wird die dazugeh@"orige Funktion ausgewertet. Zum Beispiel
1491 beendet die Funktion @code{quit()} eine Maxima-Sitzung. Wird diese Funktion
1492 mit @code{nofix("quit")} als ein Nofix-Operator definiert, gen@"ugt die
1493 Eingabe von @code{quit}, um eine Maxima-Sitzung zu beenden.
1494 @end deffn
1496 @c --- 04.05.2011 DK -----------------------------------------------------------
1497 @anchor{postfix}
1498 @deffn {Funktion} postfix (@var{op})
1499 @deffnx {Funktion} postfix (@var{op}, @var{lbp}, @var{lpos}, @var{pos})
1501 @code{postfix (@var{op})} definiert einen Postfix-Operator @var{op}.
1503 @code{postfix (@var{op}, @var{lbp}, @var{lpos}, @var{pos})} definiert einen
1504 Postfix-Operator @var{op} mit einem linksseitigem Vorrang von @var{lbp} sowie
1505 den Wortarten @var{lpos} f@"ur den Operanden und @var{pos} f@"ur das Ergebnis.
1507 Ein Postfix-Operator hat einen Operanden, der dem Operator vorangestellt ist.
1508 Ein Beispiel ist der @code{!}-Operator mit @code{3!}. Die Funktion
1509 @code{postfix("x")} erweitert die Maxima-Syntax um den Postfix-Operator
1510 @code{x}.
1511 @end deffn
1513 @c --- 04.05.2011 DK -----------------------------------------------------------
1514 @anchor{prefix}
1515 @deffn {Funktion} prefix (@var{op})
1516 @deffnx {Funktion} prefix (@var{op}, @var{rbp}, @var{rpos}, @var{pos})
1518 @code{prefix (@var{op})} definiert einen Prefix-Operator @var{op}.
1520 @code{prefix (@var{op}, @var{lbp}, @var{lpos}, @var{pos})} definiert einen
1521 Prefix-Operator @var{op} mit einem rechtsseitigem Vorrang von @var{rbp} sowie
1522 den Wortarten @var{rpos} f@"ur den Operanden und @var{pos} f@"ur das Ergebnis.
1524 Ein Prefix-Operator hat einen Operanden, der dem Operator nachfolgt. Mit
1525 @code{prefix("x")} wird die Maxima-Syntax um einen Prefix-Operator @code{x}
1526 erweitert.
1527 @end deffn
1529 @c --- End of file Operators.de.texi -------------------------------------------