| blob | 0149155f4029900603a6a5feeb1f0412b360d77a |
1 @c -----------------------------------------------------------------------------
2 @c File : Expressions.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Expressions.texi revision 1.73
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 17.10.2010
8 @c Revision : 08.04.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 Ausdr@"ucke::
15 * Substantive und Verben::
16 * Bezeichner::
17 * Funktionen und Variablen f@"ur Ausdr@"ucke::
18 @end menu
20 @c -----------------------------------------------------------------------------
21 @node Einf@"uhrung in Ausdr@"ucke, Substantive und Verben, Ausdr@"ucke, Ausdr@"ucke
22 @section Einf@"uhrung in Ausdr@"ucke
23 @c -----------------------------------------------------------------------------
25 Alles in Maxima, bis auf wenige Ausnahmen, sind Ausdr@"ucke. Dazu geh@"oren
26 mathematische Ausdr@"ucke wie @code{sqrt(2*a+b)} oder Kommandos wie
27 @code{subst(a^2,b,sin(b+1)}. Auch Maxima-Programme sind Ausdr@"ucke.
28 Ausdr@"ucke bestehen aus einem Atom oder einem Operator mit seinen Argumenten.
30 Ein Atom kann ein Symbol, eine Zeichenkette, eine ganze Zahl oder
31 eine Gleitkommazahl sein. Jeder Ausdruck, der nicht ein Atom ist, hat die
32 Darstellung @code{op(a_1, a_2, ..., a_n)}. @code{op} ist der Operator und
33 @code{a_1}, @dots{}, @code{a_n} sind die Argumente des Operators. Die Argumente
34 des Operators k@"onnen Atome oder wiederum Operatoren mit Argumenten sein.
36 Da Maxima in Lisp programmiert ist, wird ein Ausdruck intern als eine Liste
37 dargestellt, die die Gestalt @code{((op) a_1 a_2 ... a_n)} hat. Die
38 arithmetischen Operatoren "+" und "*" haben zum Beispiel die interne
39 Darstellung:
41 @example
42 x+y+10 -> ((mplus) 10 $x $y)
43 2*x*x -> ((mtimes) 2 $x $y)
44 2*(x+y) -> ((mtimes) 2 ((mplus) $x $y)
45 @end example
47 Mathematische Funktionen wie die trigonometrischen Funktionen oder die
48 Logarithmusfunktion werden von Maxima intern analog dargestellt:
50 @example
51 sin(x) -> ((%sin) $x)
52 log(y) -> ((%log) $y)
53 2*sin(x)+log(y) -> ((mplus) ((mtimes) 2 ((%sin) $x)) ((%log) $y))
54 @end example
56 Mehrere Ausdr@"ucke k@"onnen zusammengefa@ss{}t werden, indem die Ausdr@"ucke
57 durch Kommata getrennt und mit runden Klammern umgeben werden.
59 @example
60 (%i1) x: 3$
61 (%i2) (x: x+1, x: x^2);
62 (%o2) 16
63 (%i3) (if (x > 17) then 2 else 4);
64 (%o3) 4
65 (%i4) (if (x > 17) then x: 2 else y: 4, y+x);
66 (%o4) 20
67 @end example
69 Auch Programmschleifen sind in Maxima Ausdr@"ucke. Der R@"uckgabewert einer
70 Programmschleife ist @code{done}.
72 @example
73 (%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
74 (%i2) y;
75 (%o2) done
76 @end example
78 Um einen anderen R@"uckgabewert als @code{done} zu erhalten, kann zum Beispiel
79 der Wert der Variablen @var{x} nach dem Ende der Programmschleife ausgegeben
80 werden.
82 @example
83 (%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
84 (%i4) y;
85 (%o4) 3628800
86 @end example
88 Es gibt eine Anzahl an reservierten Namen, die nicht als Variablennamen
89 verwendet werden sollten. Ihre Verwendung kann m@"oglicherweise kryptische
90 Fehlermeldungen erzeugen. Dazu geh@"oren zum Beispiel die folgenden Namen:
92 @verbatim
93 integrate next from diff
94 in at limit sum
95 for and elseif then
96 else do or if
97 unless product while thru
98 step
99 @end verbatim
101 @noindent
102 Funktionen und Variablen um einen Teilausdruck zu isolieren:
104 @verbatim
105 isolate disolate isolate_wrt_times expisolate
106 part inpart substpart substinpart
107 inflag piece partswitch
108 pickapart
109 @end verbatim
111 @noindent
112 Funktionen und Variablen f@"ur Substantive und Verben:
114 @verbatim
115 nounify verbify alias aliases
116 @end verbatim
118 @noindent
119 Funktionen und Variablen, um zu pr@"ufen, ob ein Teilausdruck enthalten ist und
120 um eine Liste der Variablen eines Ausdrucks zu erstellen:
122 @verbatim
123 freeof lfreeof
124 listofvars listconstvars listdummyvars
125 @end verbatim
127 @noindent
128 Funktionen und Variablen f@"ur Operatoren und Argumente:
130 @verbatim
131 args op operatorp
132 @end verbatim
134 @noindent
135 Funktionen und Variablen f@"ur Substitutionen in Ausdr@"ucke:
137 @verbatim
138 subst psubst sublis exptsubst opsubst
139 @end verbatim
141 @noindent
142 Funktionen und Variablen f@"ur die kanonische Ordnung der Argumente eines
143 Ausdrucks:
145 @verbatim
146 ordergreat orderless unorder
147 ordergreatp orderlessp ordermagnitudep
148 @end verbatim
150 @noindent
151 Weitere Funktionen und Variablen:
153 @verbatim
154 nterms optimize optimprefix partition
155 @end verbatim
157 @c -----------------------------------------------------------------------------
158 @anchor{verb}
159 @node Substantive und Verben, Bezeichner, Einf@"uhrung in Ausdr@"ucke, Ausdr@"ucke
160 @section Substantive und Verben
161 @c -----------------------------------------------------------------------------
163 Operatoren und Funktionen k@"onnen als Substantiv oder Verb vorliegen. Verben
164 werden von Maxima ausgewertet. Substantive, die in einem Ausdruck auftreten,
165 werden dagegen nicht ausgewertet, sondern vereinfacht. Die meisten
166 mathematischen Funktionen sind Substantive. Funktionen wie
167 @mrefcomma{limit} @mref{diff} oder @mref{integrate} sind standardm@"a@ss{}ig
168 Verben, die jedoch in ein Substantiv umgewandelt werden k@"onnen. Ein Verb kann
169 durch den @nxref{', Quote-Operator} @code{'} oder mit der Funktion
170 @mref{nounify} in ein Substantiv umgewandelt werden. Der Auswertungsschalter
171 @mref{nouns} bewirkt, dass Substantive von der Funktion @mref{ev} ausgewertet
172 werden.
174 In der internen Darstellung von Maxima erhalten Lisp-Symbole, die ein Verb
175 darstellen, ein f@"uhrendes Dollarzeichen @code{$}. Lisp-Symbole, die ein
176 Substantiv darstellen, erhalten ein f@"uhrendes Prozentzeichen @code{%}. Einige
177 Substantive wie @code{'integrate} oder @code{'derivative} haben eine spezielle
178 Darstellung f@"ur die Ausgabe. Standardm@"a@ss{}ig werden jedoch Substantive
179 und Verben identisch dargestellt. Hat die Optionsvariable @mref{noundisp} den
180 Wert @code{true}, werden Substantive mit einem f@"uhrenden Hochkommata
181 angezeigt.
183 Siehe auch @mrefcomma{noun} @mrefcomma{nouns} @mref{nounify} und
184 @mrefdot{verbify}
186 Beispiele:
188 @example
189 (%i1) foo (x) := x^2;
190 2
191 (%o1) foo(x) := x
192 (%i2) foo (42);
193 (%o2) 1764
194 (%i3) 'foo (42);
195 (%o3) foo(42)
196 (%i4) 'foo (42), nouns;
197 (%o4) 1764
198 (%i5) declare (bar, noun);
199 (%o5) done
200 (%i6) bar (x) := x/17;
201 x
202 (%o6) ''bar(x) := --
203 17
204 (%i7) bar (52);
205 (%o7) bar(52)
206 (%i8) bar (52), nouns;
207 52
208 (%o8) --
209 17
210 (%i9) integrate (1/x, x, 1, 42);
211 (%o9) log(42)
212 (%i10) 'integrate (1/x, x, 1, 42);
213 42
214 /
215 [ 1
216 (%o10) I - dx
217 ] x
218 /
219 1
220 (%i11) ev (%, nouns);
221 (%o11) log(42)
222 @end example
224 @c -----------------------------------------------------------------------------
225 @node Bezeichner, Funktionen und Variablen f@"ur Ausdr@"ucke, Substantive und Verben, Ausdr@"ucke
226 @section Bezeichner
227 @c -----------------------------------------------------------------------------
229 Maxima Bezeichner bestehen aus den Buchstaben des Alphabets und den
230 Zahlzeichen 0 bis 9. Sonderzeichen k@"onnen in einem Bezeichner mit einem
231 vorangestellten Backslash @code{\} verwendet werden, zum Beispiel @code{a\&b}.
233 Ein Zahlzeichen kann der erste Buchstabe eines Bezeichners sein, wenn ihm ein
234 Backslash vorangestellt ist, zum Beispiel @code{\2and3}. Zahlzeichen, die an
235 anderen Stellen auftreten, muss kein Backslash vorangestellt werden, zum
236 Beispiel @code{is5}.
238 Sonderzeichen k@"onnen mit der Funktion @mref{declare} als alphabetisch
239 erkl@"art werden. In diesem Fall muss dem Sonderzeichen kein Backslash
240 vorangestellt werden, wenn es in einem Bezeichner genutzt wird. Die Zeichen
241 @code{A} bis @code{Z}, @code{a} bis @code{z} und @code{0} bis @code{9} sowie
242 die Zeichen @code{%} und @code{_} haben bereits die Eigenschaft alphabetisch.
244 Maxima unterscheidet Gro@ss{}- und Kleinschreibung. So werden von Maxima
245 @code{foo}, @code{FOO} oder @code{Foo} unterschieden. Ein Maxima-Bezeichner
246 ist ein Lisp-Symbol, dem ein Dollarzeichen @code{$} vorangestellt ist.
247 Lisp-Symbolen, die in Maxima verwendet werden sollen, ist ein Fragezeichen
248 @code{?} vorangestellt. Siehe das Kapitel @nref{Lisp und Maxima} f@"ur eine
249 ausf@"uhrlichere Beschreibung.
251 Beispiele:
253 @example
254 (%i1) %an_ordinary_identifier42;
255 (%o1) %an_ordinary_identifier42
256 (%i2) embedded\ spaces\ in\ an\ identifier;
257 (%o2) embedded spaces in an identifier
258 (%i3) symbolp (%);
259 (%o3) true
260 (%i4) [foo+bar, foo\+bar];
261 (%o4) [foo + bar, foo+bar]
262 (%i5) [1729, \1729];
263 (%o5) [1729, 1729]
264 (%i6) [symbolp (foo\+bar), symbolp (\1729)];
265 (%o6) [true, true]
266 (%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
267 (%o7) [false, false]
268 (%i8) baz\~quux;
269 (%o8) baz~quux
270 (%i9) declare ("~", alphabetic);
271 (%o9) done
272 (%i10) baz~quux;
273 (%o10) baz~quux
274 (%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
275 (%o11) [false, false, false]
276 (%i12) :lisp (defvar *my-lisp-variable* '$foo)
277 *MY-LISP-VARIABLE*
278 (%i12) ?\*my\-lisp\-variable\*;
279 (%o12) foo
280 @end example
282 @c -----------------------------------------------------------------------------
283 @node Funktionen und Variablen f@"ur Ausdr@"ucke, , Bezeichner, Ausdr@"ucke
284 @section Funktionen und Variablen f@"ur Ausdr@"ucke
285 @c -----------------------------------------------------------------------------
287 @c --- 13.10.2010 DK -----------------------------------------------------------
288 @anchor{alias}
289 @deffn {Funktion} alias (@var{new_name_1}, @var{old_name_1}, @dots{}, @var{new_name_n}, @var{old_name_n})
291 Die Funktion @code{alias} erm@"oglicht einen alternativen Alias-Namen f@"ur eine
292 Maxima-Funktion, einer Variablen oder einem Array. Der Funktion @code{alias}
293 kann eine beliebige Anzahl von paarweisen Namen und Alias-Namen @"ubergeben
294 werden.
296 @code{alias} gibt eine Liste mit den Symbolen zur@"uck, denen ein Alias-Name
297 zugewiesen werden konnte. Wurde einem Symbol bereits derselbe Alias-Name
298 gegeben, enth@"alt die Liste den Wert @code{false}. Wird versucht einem Symbol,
299 das bereits einen Alias-Namen hat, einen neuen Alias-Namen zu geben, bricht
300 @code{alias} mit einer Fehlermeldung ab.
302 Symbole, die einen Alias-Namen erhalten haben, werden in die Systemvariable
303 @code{aliases} eingetragen. Siehe die Systemvariable @mrefdot{aliases}
305 Die Funktionen @mref{ordergreat} und @mref{orderless} sowie die Deklaration
306 eines Symbols als ein @mref{noun} mit der Funktion @mref{declare} erzeugen
307 automatisch Alias-Namen, die in die Liste @code{aliases} eingetragen werden.
309 Der Alias-Name kann mit der Funktion @mref{kill} entfernt werden.
311 Beispiel:
313 @example
314 (%i1) alias(mysqrt,sqrt);
315 (%o1) [sqrt]
316 (%i2) aliases;
317 (%o2) [sqrt]
318 (%i3) mysqrt(4);
319 (%o3) 2
320 (%i4) kill(mysqrt);
321 (%o4) done
322 (%i5) mysqrt(4);
323 (%o5) mysqrt(4)
324 (%i6) aliases;
325 (%o6) []
326 @end example
327 @end deffn
329 @c --- 13.10.2010 DK -----------------------------------------------------------
330 @anchor{aliases}
331 @defvr {Systemvariable} aliases
332 Anfangswert: @code{[]}
334 Die Systemvariable @code{aliases} ist eine Informationsliste der Symbole, die
335 einen vom Nutzer definierten Alias-Namen mit dem Kommando @code{alias}
336 erhalten haben. Weiterhin werden von den Funktionen @mref{ordergreat} und
337 @mref{orderless} sowie bei der Deklaration eines Symbols als ein
338 @mref{noun} mit der Funktion @mref{declare} Alias-Namen generiert, die in die
339 Liste @code{aliases} eingetragen werden.
341 Siehe auch die Funktion @mref{alias} f@"ur ein Beispiel.
342 @end defvr
344 @c --- 21.03.2011 DK -----------------------------------------------------------
345 @anchor{allbut}
346 @defvr {Schl@"usselwort} allbut
348 Das Schl@"usselwort @code{allbut} wird bei @code{part}-Befehlen wie
349 @mrefcomma{part} @mrefcomma{inpart} @mrefcomma{substpart}@w{}
350 @mrefcomma{substinpart} @mref{dpart} und @mref{lpart} genutzt, um Indizes bei
351 der Auswahl von Teilausdr@"ucken auszuschlie@ss{}en.
353 Das Schl@"usselwort @code{allbut} kann auch zusammen mit dem Kommando
354 @code{kill} verwendet werden. @code{kill(allbut(@var{a_1}, @var{a_2}, ...))}
355 hat denselben Effekt wie @code{kill(all)} mit der Ausnahme, dass die Symbole
356 @var{a_1}, @var{a_2}, @dots{} von @code{kill} ausgenommen werden. Siehe die
357 Funktion @mrefdot{kill}
359 Beispiele:
361 @example
362 (%i1) expr : e + d + c + b + a;
363 (%o1) e + d + c + b + a
364 (%i2) part (expr, [2, 5]);
365 (%o2) d + a
367 (%i3) expr : e + d + c + b + a;
368 (%o3) e + d + c + b + a
369 (%i4) part (expr, allbut (2, 5));
370 (%o4) e + c + b
371 @end example
373 Das Schl@"usselwort @code{allbut} kann zusammen mit dem Kommando @code{kill}
374 verwendet werden.
376 @example
377 (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
378 (%o1) [11, 22, 33, 44, 55]
379 (%i2) kill (allbut (cc, dd));
380 (%o0) done
381 (%i1) [aa, bb, cc, dd];
382 (%o1) [aa, bb, 33, 44]
383 @end example
384 @end defvr
386 @c --- 13.10.2010 DK -----------------------------------------------------------
387 @anchor{args}
388 @deffn {Funktion} args (@var{expr})
390 Die Funktion @code{args} gibt eine Liste mit den Argumenten des Hauptoperators
391 des Ausdrucks @var{expr} zur@"uck.
393 Die Anordnung der Argumente der Ergebnisliste wird von der Optionsvariablen
394 @code{inflag} beeinflu@ss{}t. Hat @code{inflag} den Wert @code{true}, ist die
395 Anordnung entsprechend der internen Darstellung des Ausdrucks @var{expr}.
396 Ansonsten ist die Anordnung wie in der externen Darstellung f@"ur die Anzeige.
397 Siehe die Optionsvariable @mrefdot{inflag}
399 @code{args(@var{expr})} ist @"aquivalent zu
400 @code{substpart("[", @var{expr}, 0)}. Siehe auch @mref{substpart} und
401 @mrefdot{op}
403 Beispiele:
405 @example
406 (%i1) args(gamma_incomplete(a,x));
407 (%o1) [a, x]
408 (%i2) args(x+y+z);
409 (%o2) [z, y, x]
410 (%i3) args(x+y+z),inflag:true;
411 (%o3) [x, y, z]
412 (%i4) args(x+2*a);
413 (%o4) [x, 2 a]
414 @end example
415 @end deffn
417 @c --- 31.03.2011 DK -----------------------------------------------------------
418 @anchor{atom}
419 @deffn {Funktion} atom (@var{expr})
421 Gibt den Wert @code{true} zur@"uck, wenn das Argument @var{expr} ein Atom ist.
422 Atome sind ganze Zahlen, Gleitkommazahlen, Zeichenketten und Symbole. Siehe
423 auch die Funktionen @mref{symbolp} und @mrefdot{listp}
425 @c TODO: ATOM(5.0B0) IST ATOM, ABER NICHT ATOM(1/2). DAS IST INKONSISTENT.
427 Beispiele:
429 @example
430 (%i1) atom(5);
431 (%o1) true
432 (%i2) atom(5.0);
433 (%o2) true
434 (%i3) atom(5.0b0);
435 (%o3) true
436 (%i4) atom(1/2);
437 (%o4) false
438 (%i5) atom('a);
439 (%o5) true
440 (%i6) atom(2*x);
441 (%o6) false
442 (%i7) atom("string");
443 (%o7) true
444 @end example
445 @end deffn
447 @c --- 13.10.2010 DK -----------------------------------------------------------
448 @anchor{box}
449 @deffn {Funktion} box (@var{expr})
450 @deffnx {Funktion} box (@var{expr}, @var{a})
452 Die Funktion @code{box(@var{expr})} umschlie@ss{}t den Ausdruck @var{expr} in
453 der Ausgabe mit einem Rahmen, wenn @code{display2d} den Wert @code{true} hat.
454 Ansonsten ist der R@"uckgabewert ein Ausdruck mit @code{box} als Operator und
455 @var{expr} als Argument.
457 @code{box(@var{expr}, @var{a})} umschlie@ss{}t @var{expr} mit einem Rahmen, der
458 mit einer Marke @var{a} bezeichnet ist. Ist die Marke l@"anger als der Rahmen,
459 werden Zeichen abgeschnitten.
461 Die Funktion @code{box} wertet ihre Argumente aus. Die eingerahmten Ausdr@"ucke
462 werden dagegen nicht mehr ausgewertet.
464 Die Optionsvariable @mref{boxchar} enth@"alt das Zeichen, das von den Funktionen
465 @code{box} sowie @mref{dpart} und @mref{lpart} verwendet wird, um den Rahmen
466 auszugeben.
468 Beispiele:
470 @example
471 (%i1) box (a^2 + b^2);
472 """""""""
473 " 2 2"
474 (%o1) "b + a "
475 """""""""
476 (%i2) a : 1234;
477 (%o2) 1234
478 (%i3) b : c - d;
479 (%o3) c - d
480 (%i4) box (a^2 + b^2);
481 """"""""""""""""""""
482 " 2 "
483 (%o4) "(c - d) + 1522756"
484 """"""""""""""""""""
485 (%i5) box (a^2 + b^2, term_1);
486 term_1""""""""""""""
487 " 2 "
488 (%o5) "(c - d) + 1522756"
489 """"""""""""""""""""
490 (%i6) 1729 - box (1729);
491 """"""
492 (%o6) 1729 - "1729"
493 """"""
494 @end example
495 @end deffn
497 @c --- 13.10.2010 DK -----------------------------------------------------------
498 @anchor{boxchar}
499 @defvr {Optionsvariable} boxchar
500 Standardwert: @code{"}
502 Die Optionsvariable @code{boxchar} enth@"alt das Zeichen, welches von den
503 Funktionen @mref{box} sowie @mref{dpart} und @mref{lpart} genutzt wird, um
504 einen Rahmen auszugeben.
506 Die Rahmen werden immer mit dem aktuellen Wert von @code{boxchar} ausgegeben.
507 Das Zeichen @code{boxchar} wird nicht zusammen mit dem eingerahmten Ausdruck
508 gespeichert.
509 @end defvr
511 @c --- 13.10.2010 DK -----------------------------------------------------------
512 @anchor{collapse}
513 @deffn {Funktion} collapse (@var{expr})
514 @deffnx {Funktion} collapse ([@var{expr_1}, @var{expr_2}, @dots{}])
516 Komprimiert einen Ausdruck @var{expr}, indem gemeinsame Teilausdr@"ucke
517 denselben Speicher nutzen. @code{collapse} wird von der Funktion
518 @code{optimize} aufgerufen. @code{collapse} kann auch mit einer Liste
519 aufgerufen werden, die mehrere Argumente enth@"alt.
521 @c TODO: ES FEHLT EIN BEISPIEL.
523 Siehe auch die Funktion @mrefdot{optimize}
524 @end deffn
526 @c --- 21.10.2010 DK -----------------------------------------------------------
527 @anchor{dispform}
528 @deffn {Funktion} dispform (@var{expr})
529 @deffnx {Funktion} dispform (@var{expr}, all)
531 @code{dispform} formatiert den Ausdruck @var{expr} von der internen Darstellung
532 in eine externe Darstellung, wie sie f@"ur die Anzeige des Ausdrucks ben@"otigt
533 wird. Bei der Formatierung sind Optionsvariablen wie @mref{dispflag} und
534 @mref{powerdisp} wirksam.
536 Beispiele f@"ur die interne und externe Darstellung von Ausdr@"ucken sind:
538 @example
539 Interne Darstellung Externe Darstellung
540 ------------------------------------------------------------
541 -x : ((MTIMES) -1 $x) ((MMINUS) $x)
542 sqrt(x) : ((MEXPT) $x ((RAT) 1 2)) ((%SQRT) $X)
543 a/b : ((MTIMES) $A ((MEXPT) $B -1)) ((MQUOTIENT) $A $B)
544 @end example
546 @code{dispform(@var{expr})} gibt die externe Darstellung nur f@"ur den ersten
547 Operator im Ausdruck zur@"uck. @code{dispform(@var{expr}, all)} gibt die
548 externe Darstellung aller Operatoren im Ausdruck @var{expr} zur@"uck.
550 Siehe auch @mrefcomma{part} @mref{inpart} und @mrefdot{inflag}
552 Beispiel:
554 Die Funktion @code{dispform} kann genutzt werden, um die Wurzelfunktion in
555 einem Ausdruck zu substituieren. Die Wurzelfunktion ist nur in der externen
556 Darstellung eines Ausdruckes vorhanden:
558 @example
559 (%i1) expr: sqrt(5)/(5+sqrt(2));
560 sqrt(5)
561 (%o1) -----------
562 sqrt(2) + 5
563 (%i2) subst(f,sqrt,expr);
564 sqrt(5)
565 (%o2) -----------
566 sqrt(2) + 5
567 (%i3) subst(f,sqrt,dispform(expr));
568 f(5)
569 (%o3) -----------
570 sqrt(2) + 5
571 (%i4) subst(f,sqrt,dispform(expr,all));
572 f(5)
573 (%o4) --------
574 f(2) + 5
575 @end example
576 @end deffn
578 @c --- 15.10.2010 DK -----------------------------------------------------------
579 @anchor{disolate}
580 @deffn {Funktion} disolate (@var{expr}, @var{x_1}, @dots{}, @var{x_n})
582 Die Funktion @code{disolate} arbeitet @"ahnlich wie die Funktion @code{isolate}.
583 Teilausdr@"ucke im Ausdruck @var{expr}, die die Variablen @var{x_1}, @dots{},
584 @var{x_n} nicht enthalten, werden durch Zwischenmarken @code{%t1}, @code{%t2},
585 @dots{} ersetzt. Im Unterschied zu der Funktion @code{isolate} kann die
586 Funktion @code{disolate} Teilausdr@"ucke zu mehr als einer Variablen aus einem
587 Ausdruck isolieren.
589 Die Ersetzung von Teilausdr@"ucken durch Zwischenmarken kann mit der
590 Optionsvariable @code{isolate_wrt_times} kontrolliert werden. Hat die
591 Optionsvariable @code{isolate_wrt_times} den Wert @code{true}, werden
592 Ersetzungen in Produkten ausgef@"uhrt. Der Standardwert ist @code{false}.
593 Siehe @mref{isolate_wrt_times} f@"ur Beispiele.
595 Die Optionsvariable @mref{exptisolate} hat im Unterschied zur Funktion
596 @code{isolate} keinen Einfluss auf die Ersetzung von Teilausdr@"ucken durch
597 Zwischenmarken.
599 @code{disolate} wird automatisch aus der Datei
600 @file{share/simplification/disol.mac} geladen. Das Kommando
601 @code{demo(disol)$} zeigt Beispiele.
603 Siehe auch die Funktion @mrefdot{isolate}
605 Beispiel:
607 @example
608 (%i1) expr:a*(e*(g+f)+b*(d+c));
609 (%o1) a (e (g + f) + b (d + c))
610 (%i2) disolate(expr,a,b,e);
611 (%t2) d + c
613 (%t3) g + f
615 (%o3) a (%t3 e + %t2 b)
616 @end example
617 @end deffn
619 @c --- 15.10.2010 DK -----------------------------------------------------------
620 @anchor{dpart}
621 @deffn {Funktion} dpart (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
623 W@"ahlt wie die Funktion @code{part} einen Teilausdruck aus, gibt aber den
624 vollst@"andigen Ausdruck zur@"uck, wobei der ausgew@"ahlte Teilausdruck
625 eingerahmt ist. Der Rahmen ist Teil des zur@"uckgegebenen Ausdrucks.
627 Siehe auch @mrefcomma{part} @mref{inpart} und @mref{lpart} sowie @mrefdot{box}
629 Beispiel:
631 @example
632 (%i1) dpart (x+y/z^2, 1, 2, 1);
633 y
634 (%o1) ---- + x
635 2
636 """
637 "z"
638 """
639 @end example
640 @end deffn
642 @c --- 15.10.2010 DK -----------------------------------------------------------
643 @anchor{exptisolate}
644 @defvr {Optionsvariable} exptisolate
645 Standardwert: @code{false}
647 Hat @code{exptisolate} den Wert @code{true}, dann sucht die Funktion
648 @code{isolate} auch in den Exponenten von Zahlen oder Symbolen nach
649 Teilausdr@"ucken zu einer Variablen.
651 Siehe die Funktion @mref{isolate} f@"ur Beispiele.
652 @end defvr
654 @c --- 15.10.2010 DK -----------------------------------------------------------
655 @anchor{exptsubst}
656 @defvr {Optionsvariable} exptsubst
657 Standardwert: @code{false}
659 Die Optionsvariable @code{exptsubst} kontrolliert die Substitution von
660 Ausdr@"ucken mit der Exponentialfunktion durch die Funktionen @mref{subst} und
661 @mrefdot{psubst}
663 Beispiele:
665 @example
666 (%i1) subst(y,%e^x,%e^(a*x)),exptsubst:false;
667 a x
668 (%o1) %e
669 (%i2) subst(y,%e^x,%e^(a*x)),exptsubst:true;
670 a
671 (%o2) y
672 @end example
673 @end defvr
675 @c --- 15.10.2010 DK -----------------------------------------------------------
676 @anchor{freeof}
677 @deffn {Funktion} freeof (@var{x}, @var{expr})
678 @deffnx {Funktion} freeof (@var{x_1}, @dots{}, @var{x_n}, @var{expr})
680 @code{freeof(@var{x}, @var{expr})} gibt das Ergebnis @code{true} zur@"uck, wenn
681 das Argument @var{x} nicht im Ausdruck @var{expr} enthalten ist. Ansonsten ist
682 der R@"uckgabewert @code{false}.
684 @code{freeof(@var{x_1}, ..., @var{x_n}, @var{expr})} gibt das Ergebnis
685 @code{true} zur@"uck, wenn keines der Argumente @var{x_1}, @var{x_2}, @dots{}
686 im Ausdruck @var{expr} enthalten ist.
688 Die Argumente @var{x_1}, @dots{}, @var{x_n} k@"onnen die Namen von Funktionen
689 und Variablen sein, indizierte Namen, die Namen von Operatoren oder allgemeine
690 Ausdr@"ucke. Die Funktion @code{freeof} wertet die Argumente aus.
692 Bei der Pr@"ufung, ob ein Teilausdruck @var{x} im Ausdruck @var{expr} enthalten
693 ist, untersucht die Funktion @code{freeof} den Ausdruck @var{expr} in der
694 vorliegenden Form (nach Auswertung und Vereinfachung) und versucht nicht
695 herauszufinden, ob der Teilausdruck in einem @"aquivalenten Ausdruck enth@"alten
696 w@"are.
698 @code{freeof} ignoriert Dummy-Variablen. Dummy-Variablen sind Variablen, die
699 au@ss{}erhalb eines Ausdrucks nicht in Erscheinung treten. Folgende
700 Dummy-Variablen werden von @code{freeof} ignoriert: der Index einer Summe oder
701 eines Produktes, die unabh@"angige Variable in einem Grenzwert, die
702 Integrationsvariable eines bestimmten Integrals oder einer
703 Laplacetransformation, formale Variablen in @mref{at}- oder
704 @mref{lambda}-Ausdr@"ucke, lokale Variablen eines Blocks oder einer
705 @mref{do}-Schleife.
707 Das unbestimmte Integral ist @i{nicht} frei von der Integrationsvariablen.
709 Beispiele:
711 Argumente sind Namen von Funktionen, Variablen, indizierten Variablen,
712 Operatoren und Ausdr@"ucke. @code{freeof(a, b, expr)} ist @"aquivalent zu
713 @code{freeof(a, expr) and freeof(b, expr)}.
715 @example
716 (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
717 @group
718 d + c 3
719 (%o1) cos(a ) b z
720 1
721 @end group
722 (%i2) freeof(z, expr);
723 (%o2) false
724 (%i3) freeof(cos, expr);
725 (%o3) false
726 (%i4) freeof(a[1], expr);
727 (%o4) false
728 (%i5) freeof(cos (a[1]), expr);
729 (%o5) false
730 (%i6) freeof(b^(c+d), expr);
731 (%o6) false
732 (%i7) freeof("^", expr);
733 (%o7) false
734 (%i8) freeof(w, sin, a[2], sin (a[2]), b*(c+d), expr);
735 (%o8) true
736 @end example
738 Die Funktion @code{freeof} wertet die Argumente aus.
740 @example
741 (%i1) expr: (a+b)^5$
742 (%i2) c: a$
743 (%i3) freeof(c, expr);
744 (%o3) false
745 @end example
747 @code{freeof} betrachtet keine @"aquivalenten Ausdr@"ucke. Vereinfachungen
748 k@"onnen einen @"aquivalenten Ausdruck liefern, der jedoch den Teilausdruck
749 nicht mehr enth@"alt.
751 @example
752 (%i1) expr: (a+b)^5$
753 (%i2) expand(expr);
754 5 4 2 3 3 2 4 5
755 (%o2) b + 5 a b + 10 a b + 10 a b + 5 a b + a
756 (%i3) freeof(a+b, %);
757 (%o3) true
758 (%i4) freeof(a+b, expr);
759 (%o4) false
760 @end example
762 Die Exponentialfunktion @code{exp(x)} wird von Maxima sofort zu @code{%e^x}
763 vereinfacht. Der Name @code{exp} der Exponentialfunktion ist daher nicht in
764 einem Ausdruck enthalten.
766 @example
767 (%i5) exp(x);
768 x
769 (%o5) %e
770 (%i6) freeof(exp, exp (x));
771 (%o6) true
772 @end example
774 Eine Summe ist frei von dem Index und ein bestimmtes Integral ist frei von der
775 Integrationsvariablen. Ein unbestimmtes Integral ist nicht frei von der
776 Integrationsvariablen.
778 @example
779 (%i1) freeof(i, 'sum (f(i), i, 0, n));
780 (%o1) true
781 (%i2) freeof(x, 'integrate (x^2, x, 0, 1));
782 (%o2) true
783 (%i3) freeof(x, 'integrate (x^2, x));
784 (%o3) false
785 @end example
786 @end deffn
788 @c --- 15.10.2010 DK -----------------------------------------------------------
789 @anchor{inflag}
790 @defvr {Optionsvariable} inflag
791 Standardwert: @code{false}
793 Hat die Optionsvariable @code{inflag} den Wert @code{true}, wird von Funktionen,
794 die Teile eines Ausdrucks @code{expr} extrahieren, die interne Form des
795 Ausdrucks @code{expr} betrachtet.
797 Die Anordnung der Argumente der internen Darstellung unterscheidet sich zum
798 Beispiel f@"ur die Addition von der externen Darstellung f@"ur die Anzeige.
799 Daher hat @code{first(x+y)} das Ergebnis @code{x}, wenn @code{inflag} den Wert
800 @code{true} hat, und @code{y}, wenn @code{inflag} den Wert @code{false} hat.
801 Der Ausdruck @code{first(y+x)} gibt in beiden F@"allen dasselbe Ergebnis.
803 Hat @code{inflag} den Wert @code{true}, entsprechen die Funktionen @code{part}
804 und @code{substpart} den Funktionen @code{inpart} und @code{substinpart}.
806 Folgende Funktionen werden von der Optionsvariablen @code{inflag} beeinflusst:
807 @mrefcomma{part} @mrefcomma{substpart} @mrefcomma{first} @mrefcomma{rest}@w{}
808 @mrefcomma{last} @mrefcomma{length} die Konstruktion @mref{for} @dots{}
809 @code{in}, @mrefcomma{map} @mrefcomma{fullmap} @mrefcomma{maplist}@w{}
810 @mrefcomma{reveal} @mrefcomma{pickapart} @mref{args} und @mrefdot{op}
811 @end defvr
813 @c --- 15.10.2010 DK -----------------------------------------------------------
814 @anchor{inpart}
815 @deffn {Funktion} inpart (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
817 Die Funktion @code{inpart} ist @"ahnlich wie @code{part}, arbeitet aber mit der
818 internen Darstellung eines Ausdruckes und nicht mit der externen Darstellung
819 f@"ur die Anzeige. Da keine Formatierung vorgenommen wird, ist die Funktion
820 @code{inpart} schneller als @code{part}.
822 Immer dann, wenn sich die interne und die externe Darstellung eines Ausdrucks
823 voneinander unterscheiden, haben die Funktionen @code{inpart} und @code{part}
824 verschiedene Ergebnisse. Dies trifft zu f@"ur die Anordnung der Argumente einer
825 Addition, der Subtraktion und Division sowie zum Beispiel f@"ur die
826 Wurzelfunktion.
828 Ist das letzte Argument einer @code{part}-Funktion eine Liste mit Indizes,
829 werden mehrere Teilausdr@"ucke heraus gepickt. So hat
830 @code{inpart(x + y + z, [1, 3])} das Ergebnis @code{z+x}.
832 Siehe auch @mrefcomma{part} @mref{dpart} und @mrefdot{lpart}
834 Beispiele:
836 @example
837 (%i1) x + y + w*z;
838 (%o1) w z + y + x
839 (%i2) inpart (%, 3, 2);
840 (%o2) z
841 (%i3) part (%th (2), 1, 2);
842 (%o3) z
843 (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
844 g(x + 1)
845 (%o4) limit f(x)
846 x -> 0-
847 (%i5) inpart (%, 1, 2);
848 (%o5) g(x + 1)
849 @end example
850 @end deffn
852 @c --- 15.10.2010 DK -----------------------------------------------------------
853 @anchor{isolate}
854 @deffn {Funktion} isolate (@var{expr}, @var{x})
856 Teilausdr@"ucke im Ausdruck @var{expr}, die die Variable @var{x} nicht
857 enthalten, werden durch Zwischenmarken @code{%t1}, @code{%t2}, @dots{} ersetzt.
858 Dies kann genutzt werden, um die weitere Auswertung und Vereinfachung dieser
859 Teilausdr@"ucke zu verhindern. Die Ersetzung der Teilausdr@"ucke kann durch
860 eine Auswertung des Ausdrucks r@"uckg@"angig gemacht werden.
862 Die Ersetzung von Teilausdr@"ucken kann mit den Optionsvariablen
863 @mref{exptisolate} und @mref{isolate_wrt_times} kontrolliert werden. Hat die
864 Optionsvariable @code{exptisolate} den Wert @code{true}, werden Ersetzungen auch
865 f@"ur die Exponentiation ausgef@"uhrt. Die Basis muss dabei eine Zahl oder ein
866 Symbol wie @code{%e} sein. Hat die Optionsvariable @code{isolate_wrt_times} den
867 Wert @code{true}, werden Ersetzungen in Produkten ausgef@"uhrt. Siehe
868 @code{isolate_wrt_times} f@"ur Beispiele.
870 Die Ersetzung von Teilausdr@"ucken f@"ur mehrere Variable kann mit der Funktion
871 @code{disolate} ausgef@"uhrt werden. Siehe @mrefdot{disolate}
873 Beispiele:
875 @example
876 (%i1) (b+a)^4*(x*((d+c)^2+2*x)+1);
877 4 2
878 (%o1) (b + a) (x (2 x + (d + c) ) + 1)
879 (%i2) isolate(%,x);
881 2
882 (%t2) (d + c)
885 4
886 (%t3) (b + a)
888 (%o3) %t3 (x (2 x + %t2) + 1)
889 (%i4) ratexpand(%);
890 2
891 (%o4) 2 %t3 x + %t2 %t3 x + %t3
892 (%i5) ev(%);
893 4 2 4 2 4
894 (%o5) 2 (b + a) x + (b + a) (d + c) x + (b + a)
895 (%i6) (b+a)*(b+a+x)^2*%e^(b+a*x+x^2);
896 2
897 2 x + a x + b
898 (%o6) (b + a) (x + b + a) %e
899 (%i7) ev(isolate(%,x),exptisolate:true);
901 (%t7) b + a
904 b
905 (%t8) %e
907 2
908 2 x + a x
909 (%o8) %t7 %t8 (x + %t7) %e
910 @end example
911 @end deffn
913 @c --- 15.10.2010 DK -----------------------------------------------------------
914 @anchor{isolate_wrt_times}
915 @defvr {Optionsvariable} isolate_wrt_times
916 Standardwert: @code{false}
918 Hat die Optionsvariable @code{isolate_wrt_times} den Wert @code{true}, f@"uhren
919 die Funktionen @code{isolate} und @code{disolate} auch Ersetzungen in Produkten
920 aus.
922 Siehe auch die Funktionen @mref{isolate} und @mrefdot{disolate}
924 Beispiele:
926 @example
927 (%i1) isolate_wrt_times: true$
928 (%i2) isolate (expand ((a+b+c)^2), c);
930 (%t2) 2 a
933 (%t3) 2 b
936 2 2
937 (%t4) b + 2 a b + a
939 2
940 (%o4) c + %t3 c + %t2 c + %t4
941 (%i4) isolate_wrt_times: false$
942 (%i5) isolate (expand ((a+b+c)^2), c);
943 2
944 (%o5) c + 2 b c + 2 a c + %t4
945 @end example
946 @end defvr
948 @c --- 15.10.2010 DK -----------------------------------------------------------
949 @anchor{listconstvars}
950 @defvr {Optionsvariable} listconstvars
951 Standardwert: @code{false}
953 Hat die Optionsvariable @code{listconstvars} den Wert @code{true}, werden
954 Konstante wie @mrefcomma{%e} @mref{%pi} und Variablen, die als konstant
955 deklariert sind, von der Funktion @mref{listofvars} in die Ergebnisliste
956 aufgenommen. Der Standardwert von @code{listconstvars} ist @code{false} und
957 Konstante werden ignoriert.
958 @end defvr
960 @c --- 15.10.2010 DK -----------------------------------------------------------
961 @anchor{listdummyvars}
962 @defvr {Optionsvariable} listdummyvars
963 Standardwert: @code{true}
965 Hat @code{listdummyvars} den Wert @code{false}, werden die Dummy-Variablen eines
966 Ausdrucks von der Funktion @mref{listofvars} ignoriert. Dummy-Variablen sind
967 zum Beispiel der Index einer Summe, die Grenzwertvariable oder die
968 Integrationsvariable eines bestimmten Integrals.
970 Beispiele:
972 @example
973 (%i1) listdummyvars: true$
974 (%i2) listofvars ('sum(f(i), i, 0, n));
975 (%o2) [i, n]
976 (%i3) listdummyvars: false$
977 (%i4) listofvars ('sum(f(i), i, 0, n));
978 (%o4) [n]
979 @end example
980 @end defvr
982 @c --- 15.10.2010 DK -----------------------------------------------------------
983 @anchor{listofvars}
984 @deffn {Funktion} listofvars (@var{expr})
986 Die Funktion @code{listofvars} gibt eine Liste der Variablen zur@"uck, die im
987 Ausdruck @var{expr} enthalten sind.
989 Hat die Optionsvariable @mref{listconstvars} den Wert @code{true}, werden auch
990 Konstante wie @mrefcomma{%e} @mref{%pi} und @mref{%i} sowie als konstant
991 deklarierte Variable in die Liste aufgenommen. Der Standardwert von
992 @code{listconstvars} ist @code{false}.
994 Siehe entsprechend die Optionsvariable @mref{listdummyvars} f@"ur
995 Dummy-Variablen.
997 Beispiel:
999 @example
1000 (%i1) listofvars (f (x[1]+y) / g^(2+a));
1001 (%o1) [g, a, x , y]
1002 1
1003 @end example
1004 @end deffn
1006 @c --- 15.10.2010 DK -----------------------------------------------------------
1007 @anchor{lfreeof}
1008 @deffn {Funktion} lfreeof (@var{list}, @var{expr})
1010 F@"ur jedes Element @var{m} der Liste @var{list} wird die Funktion
1011 @code{freeof} aufgerufen. @code{lfreeof} hat den R@"uckgabewert @code{true},
1012 wenn keines der Elemente der Liste @var{list} im Ausdruck @code{expr} enthalten
1013 ist. Ansonsten ist der R@"uckgabewert @code{false}.
1015 Siehe auch die Funktion @mrefdot{freeof}
1016 @end deffn
1018 @c --- 15.10.2010 DK -----------------------------------------------------------
1019 @anchor{lpart}
1020 @deffn {Funktion} lpart (@var{label}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
1022 Die Funktion @code{lpart} ist @"ahnlich zu @code{dpart}, verwendet aber einen
1023 Rahmen, der mit einer Marke gekennzeichnet ist.
1025 Siehe auch @mrefcomma{part} @mref{inpart} und @mrefdot{dpart}
1026 @end deffn
1028 @c --- 04.04.2011 DK -----------------------------------------------------------
1029 @anchor{mainvar}
1030 @defvr {Eigenschaft} mainvar
1032 Die Deklaration einer Variablen als eine Hauptvariable mit der Funktion
1033 @mref{declare} @"andert deren Anordnung in einem Ausdruck der kanonisch geordnet
1034 ist. Hauptvariable sind bez@"uglich der Funktionen @mref{ordergreatp} und
1035 @mref{orderlessp} stets gr@"o@ss{}er als alle anderen Symbole, Konstanten und
1036 Zahlen.
1038 @c TODO: DIE FUNKTION PROPERTIES HAT KEINEN EINTRAG FUER MAINVAR
1040 Beispiel:
1042 @example
1043 (%i1) sort([9, 1, %pi, g, t, a]);
1044 (%o1) [1, 9, %pi, a, g, t]
1046 (%i2) declare(a, mainvar)$
1047 (%i3) sort([9, 1, %pi, g, t, a]);
1048 (%o3) [1, 9, %pi, g, t, a]
1049 @end example
1050 @end defvr
1052 @c --- 18.02.2011 DK -----------------------------------------------------------
1053 @anchor{noun}
1054 @defvr {Eigenschaft} noun
1056 @code{noun} ist eine der Optionen des Kommandos @mref{declare}. Wird eine
1057 Funktion als @code{noun} deklariert, wird diese als Substantivform behandelt
1058 und nicht ausgewertet.
1060 Ein Symbol @code{f}, dass als @code{noun} deklariert wird, wird in die
1061 Informationsliste @mref{aliases} eingetragen und die R@"uckgabe der Funktion
1062 @mref{properties} enth@"alt den Eintrag @code{noun}.
1064 Beispiel:
1066 @example
1067 (%i1) factor (12345678);
1068 2
1069 (%o1) 2 3 47 14593
1070 (%i2) declare (factor, noun);
1071 (%o2) done
1072 (%i3) factor (12345678);
1073 (%o3) factor(12345678)
1074 (%i4) ''%, nouns;
1075 2
1076 (%o4) 2 3 47 14593
1077 @end example
1078 @end defvr
1080 @c --- 18.10.2010 DK -----------------------------------------------------------
1081 @anchor{noundisp}
1082 @defvr {Optionsvariable} noundisp
1083 Standardwert: @code{false}
1085 Hat @code{noundisp} den Wert @code{true}, werden Substantivformen mit einem
1086 vorangestelltem Hochkomma angezeigt. Diese Optionsvariable hat immer den Wert
1087 @code{true}, wenn die Definition von Funktionen angezeigt wird.
1088 @end defvr
1090 @c --- 15.10.2010 DK -----------------------------------------------------------
1091 @anchor{nounify}
1092 @deffn {Funktion} nounify (@var{f})
1094 Die Funktion @code{nounify} gibt den Namen einer Funktion @var{f} in einer
1095 Substantivform zur@"uck. Der Name @var{f} ist ein Symbol oder eine
1096 Zeichenkette.
1098 Einige Funktionen geben eine Substantivform zur@"uck, wenn die Funktion nicht
1099 ausgewertet werden kann. Wird einem Funktionsaufruf wie zum Beispiel
1100 @code{'f(x)} oder @code{'(f(x))} ein Hochkomma vorangestellt, wird ebenfalls
1101 eine Substantivform zur@"uckgegeben.
1103 Siehe auch die Funktion @mrefdot{verbify}
1104 @end deffn
1106 @c --- 15.10.2010 DK -----------------------------------------------------------
1107 @anchor{nterms}
1108 @deffn {Funktion} nterms (@var{expr})
1110 Die Funktion @code{nterms} gibt die Anzahl der Terme des Ausdrucks @var{expr}
1111 zur@"uck, wobei der Ausdruck als vollst@"andig expandiert angenommen wird, ohne
1112 dass Terme gek@"urzt oder zusammengefasst werden.
1114 Ausdr@"ucke wie @code{sin(@var{expr})}, @code{sqrt(@var{expr})} oder
1115 @code{exp(@var{expr})} werden dabei als ein Term gez@"ahlt.
1116 @end deffn
1118 @c --- 15.10.2010 DK -----------------------------------------------------------
1119 @anchor{op}
1120 @deffn {Funktion} op (@var{expr})
1122 Die Funktion @code{op} gibt den Hauptoperator des Ausdrucks @var{expr} zur@"uck.
1123 @code{op(@var{expr})} ist @"aquivalent zu @code{part(@var{expr}, 0)}.
1125 Ist der Hauptoperator des Ausdrucks @var{expr} ein Operator wie "+", "*" oder
1126 "/" wird der Name des Operators als Zeichenkette zur@"uckgegeben. Andernfalls
1127 wird ein Symbol zur@"uckgegeben.
1129 @code{op} beachtet den Wert der Optionsvariablen @mrefdot{inflag} @code{op}
1130 wertet die Argumente aus. Siehe auch @mrefdot{args}
1132 Beispiele:
1134 @example
1135 (%i1) stringdisp: true$
1136 (%i2) op (a * b * c);
1137 (%o2) "*"
1138 (%i3) op (a * b + c);
1139 (%o3) "+"
1140 (%i4) op ('sin (a + b));
1141 (%o4) sin
1142 (%i5) op (a!);
1143 (%o5) "!"
1144 (%i6) op (-a);
1145 (%o6) "-"
1146 (%i7) op ([a, b, c]);
1147 (%o7) "["
1148 (%i8) op ('(if a > b then c else d));
1149 (%o8) "if"
1150 (%i9) op ('foo (a));
1151 (%o9) foo
1152 (%i10) prefix (foo);
1153 (%o10) "foo"
1154 (%i11) op (foo a);
1155 (%o11) "foo"
1156 (%i12) op (F [x, y] (a, b, c));
1157 (%o12) F
1158 x, y
1159 (%i13) op (G [u, v, w]);
1160 (%o13) G
1161 @end example
1162 @end deffn
1164 @c --- 15.10.2010 DK -----------------------------------------------------------
1165 @anchor{operatorp}
1166 @deffn {Funktion} operatorp (@var{expr}, @var{op})
1167 @deffnx {Funktion} operatorp (@var{expr}, [@var{op_1}, @dots{}, @var{op_n}])
1169 Das Kommando @code{operatorp(@var{expr}, @var{op})} gibt @code{true} zur@"uck,
1170 wenn @var{op} der Hauptoperator des Ausdrucks @var{expr} ist.
1172 @code{operatorp(@var{expr}, [@var{op_1}, ..., @var{op_n}])} gibt @code{true}
1173 zur@"uck, wenn einer der Operatoren @var{op_1}, @dots{}, @var{op_n} der
1174 Hauptoperator des Ausdrucks @var{expr} ist.
1175 @end deffn
1177 @c --- 15.10.2010 DK -----------------------------------------------------------
1178 @anchor{option_opsubst}
1179 @defvr {Optionsvariable} opsubst
1181 @c TODO: DAS MUSS BESSER FORMULIERT WERDEN.
1183 Hat die Optionsvariable @code{opsubst} den Wert @code{false}, f@"uhrt die
1184 Funktion @mref{subst} keine Substitution in einen Operator eines Ausdrucks aus.
1185 Zum Beispiel hat @code{(opsubst: false, subst(x^2, r, r+r[0]))} das Ergebnis
1186 @code{x^2+r[0]}.
1187 @end defvr
1189 @c --- 15.10.2010 DK -----------------------------------------------------------
1190 @anchor{optimize}
1191 @deffn {Funktion} optimize (@var{expr})
1193 Die Funktion @code{optimize} gibt einen Ausdruck zur@"uck, der dasselbe Ergebnis
1194 und dieselben Seiteneffekte wie @var{expr} hat, der jedoch effizienter
1195 ausgewertet werden kann. Im neuen Ausdruck wird die mehrfache Berechnung
1196 gleicher Teilausdr@"ucke vermieden und gleiche Teilausdr@"ucke werden
1197 zusammengefasst.
1199 Siehe auch die Funktion @mrefdot{collapse}
1201 @c TODO: HIER EIN BEISPIEL ERGAENZEN.
1203 @code{example(optimize)} zeigt ein Beispiel.
1204 @end deffn
1206 @c --- 15.10.2010 DK -----------------------------------------------------------
1207 @anchor{optimprefix}
1208 @defvr {Optionsvariable} optimprefix
1209 Standardwert: @code{%}
1211 Die Optionsvariable @code{optimprefix} enth@"alt den Pr@"afix, der von der
1212 Funktion @mref{optimize} benutzt wird, um einen Teilausdruck zu benennen.
1213 @end defvr
1215 @c --- 15.10.2010 DK -----------------------------------------------------------
1216 @anchor{ordergreat}
1217 @anchor{orderless}
1218 @deffn {Funktion} ordergreat (@var{v_1}, @dots{}, @var{v_n})
1219 @deffnx {Funktion} orderless (@var{v_1}, @dots{}, @var{v_n})
1221 Die Funktion @code{ordergreat} @"andert die kanonische Anordnung der Symbole so,
1222 dass @var{v_1} > @var{v_2} > @dots{} > @var{v_n}. Weiterhin ist @var{v_n}
1223 kleiner als jedes andere Symbol, das nicht in der Liste enthalten ist.
1225 @code{orderless} @"andert die kanonische Anordnung der Symbole so, dass
1226 @var{v_1} < @var{v_2} < @dots{} < @var{v_n}. Weiterhin ist @var{v_n}
1227 gr@"o@ss{}er als jedes andere Symbol, das nicht in der Liste enthalten ist.
1229 Die durch @code{ordergreat} und @code{orderless} definierte Ordnung wird durch
1230 @mref{unorder} wieder aufgehoben. @code{ordergreat} und @code{orderless}
1231 k@"onnen jeweils nur einmal aufgerufen werden, solange nicht mit @code{unorder}
1232 zuvor die definierte Ordnung aufgehoben wird.
1234 Siehe auch @mrefcomma{ordergreatp} @mref{orderlessp} und @mrefdot{mainvar}
1235 @end deffn
1237 @c --- 15.10.2010 DK -----------------------------------------------------------
1238 @anchor{ordergreatp}
1239 @anchor{orderlessp}
1240 @deffn {Funktion} ordergreatp (@var{expr_1}, @var{expr_2})
1241 @deffnx {Funktion} orderlessp (@var{expr_1}, @var{expr_2})
1243 Die Funktion @code{ordergreatp} gibt @code{true} zur@"uck, wenn in der
1244 kanonischen Ordnung von Maxima @var{expr_1} gr@"o@ss{}er als @var{expr_2} ist.
1245 Ansonsten ist das Ergebnis @code{false}.
1247 Die Funktion @code{orderlessp} gibt @code{true} zur@"uck, wenn in der
1248 kanonischen Ordnung von Maxima @var{expr_1} kleiner als @var{expr_2} ist.
1249 Ansonsten ist das Ergebnis @code{false}.
1251 Alle Maxima-Atome und Ausdr@"ucke sind vergleichbar unter @code{ordergreatp} und
1252 @code{orderlessp}. Die kanonische Ordnung von Atomen ist folgenderma@ss{}en:
1254 @flushleft
1255 Numerische Konstanten <
1256 deklarierte Konstanten <
1257 deklarierte Skalare <
1258 erstes Argument von @code{orderless} <
1259 weitere Argumente von @code{orderless} <
1260 letztes Argument von @code{orderless} <
1261 Variablen beginnend mit a, ... <
1262 Variablen beginnend mit Z <
1263 letzte Argument von @code{ordergreat} <
1264 weitere Argumente von @code{ordergreat} <
1265 erste Argument von @code{ordergreat} <
1266 deklarierte Hauptvariablen.
1267 @end flushleft
1269 Die Ordnung f@"ur Ausdr@"ucke, die keine Atome sind, wird von der f@"ur Atome
1270 abgeleitet. F@"ur die Operatoren @code{"+"}, @code{"*"} und @code{"^"} kann die
1271 Ordnung nicht einfach beschrieben werden. Andere Operatoren, Funktionen und
1272 Ausdr@"ucke werden angeordnet nach den Argumenten, dann nach den Namen.
1273 Bei Ausdr@"ucken mit Indizes wird der Name des Symbols als Operator und der
1274 Index als Argument betrachtet.
1276 Die kanonische Ordnung der Ausdr@"ucke wird modifiziert durch die Funktionen
1277 @mref{ordergreat} und @mref{orderless} sowie der Deklarationen
1278 @mrefcomma{mainvar} @mref{constant} und @mrefdot{scalar}
1280 Siehe auch @mrefdot{sort}
1282 Beispiele:
1284 Ordne Symbole und Konstanten. @mref{%pi} wird nicht nach dem numerischen Wert
1285 sortiert, sondern wie eine Konstante.
1287 @example
1288 (%i1) stringdisp : true;
1289 (%o1) true
1290 (%i2) sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, "bar", 4.0, 4b0]);
1291 (%o2) [3, 3.0, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]
1292 @end example
1294 Anwendung der Funktionen @code{ordergreat} und @code{orderless}.
1296 @example
1297 (%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]);
1298 (%o1) [A, E, G, H, J, K, M, P, S, T, W]
1299 (%i2) ordergreat (S, J);
1300 (%o2) done
1301 (%i3) orderless (M, H);
1302 (%o3) done
1303 (%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]);
1304 (%o4) [M, H, A, E, G, K, P, T, W, J, S]
1305 @end example
1307 Anwendung der Deklarationen @code{mainvar}, @code{constant} und @code{scalar}.
1309 @example
1310 (%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1311 (%o1) [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1]
1312 (%i2) declare (aa, mainvar);
1313 (%o2) done
1314 (%i3) declare ([baz, quux], constant);
1315 (%o3) done
1316 (%i4) declare ([A1, B1], scalar);
1317 (%o4) done
1318 (%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1319 (%o5) [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]
1320 @end example
1322 Ordne nicht atomare Ausdr@"ucke.
1324 @example
1325 (%i1) sort ([f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]);
1326 (%o1) [f(1), g(1), g(1, 2), f(2), f(2, 1), g(n), f(n, 1)]
1327 (%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
1328 (%o2) [1, foo(1), X , k, foo(k), X ]
1329 1 k
1330 @end example
1331 @end deffn
1333 @c --- 20.03.2011 DK -----------------------------------------------------------
1334 @anchor{ordermagnitudep}
1335 @deffn {Funktion} ordermagnitudep (@var{expr_1}, @var{expr_2})
1337 Ist eine Aussagefunktion, die das Ergebnis @code{true} hat, wenn die Argumente
1338 @var{expr_1} und @var{expr_2} Zahlen, Konstante oder konstante Ausdr@"ucke
1339 repr@"asentieren und @var{expr_1} kleiner als @var{expr_2} ist. Sind die
1340 Argumente nicht der Gr@"o@ss{}e nach vergleichbar, wird die Ordnung durch die
1341 Aussagefunktion @mref{orderlessp} bestimmt.
1343 Wird die Aussagefunktion @code{ordermagnitudep} als Argument der Funktion
1344 @mref{sort} verwendet, werden die Elemente einer Liste nach der Gr@"o@ss{}e
1345 sortiert.
1347 Beispiele:
1349 @example
1350 (%i1) ordermagnitudep(1, 2);
1351 (%o1) true
1352 (%i2) ordermagnitudep(%e, %pi);
1353 (%o2) true
1354 (%i3) sort([%e, %pi, sin(1), 0, 1, 2, 3, 4]);
1355 (%o3) [0, 1, 2, 3, 4, %e, %pi, sin(1)]
1356 (%i4) sort([%e, %pi, sin(1), 0, 1, 2, 3, 4], ordermagnitudep);
1357 (%o4) [0, sin(1), 1, 2, %e, 3, %pi, 4]
1358 @end example
1359 @end deffn
1361 @c --- 15.10.2010 DK -----------------------------------------------------------
1362 @anchor{part}
1363 @deffn {Funktion} part (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
1365 Die Funktion @code{part} gibt einen Teilausdruck des Ausdrucks @var{expr}
1366 zur@"uck. Der Ausdruck @var{expr} wird zuvor in das Format f@"ur die Anzeige
1367 umgewandelt.
1369 Der Teilausdruck wird durch die Indizes @var{n_1}, @dots{}, @var{n_k}
1370 ausgew@"ahlt. Zuerst wird der Teilausdruck @var{n_1} ermittelt, von diesem der
1371 Teilausdruck @var{n_2}, u.s.w. Der zum Index @var{n_k} zuletzt gewonnene
1372 Teilausdruck ist dann das Ergebnis.
1374 @code{part} kann auch verwendet werden, um ein Element einer Liste oder die
1375 Zeile einer Matrix zu erhalten.
1377 Das letzte Argument einer @code{part}-Funktion kann eine Liste mit Indizes sein.
1378 In diesem Fall werden alle angegebenen Teilausdr@"ucke als Ergebnis
1379 zur@"uckgegeben. Zum Beispiel hat das Kommando @code{part(x + y + z, [1, 3])}
1380 das Ergebnis @code{z+x}.
1382 Die Systemvariable @mref{piece} enth@"alt den letzten Ausdruck, der bei der
1383 Verwendung einer @code{part}-Funktion ausgew@"ahlt wurde.
1385 Hat die Optionsvariable @mref{partswitch} den Wert @code{true}, wird @code{end}
1386 zur@"uckgegeben, wenn versucht wurde, einen Teilausdruck zu bilden, der nicht
1387 existiert, andernfalls wird eine Fehlermeldung ausgegeben.
1389 Siehe auch @mrefcomma{inpart} @mrefcomma{substpart} @mrefcomma{substinpart}@w{}
1390 @mref{dpart} und @mrefdot{lpart}
1392 Beispiele:
1394 @example
1395 (%i1) part(z+2*y+a,2);
1396 (%o1) 2 y
1397 (%i2) part(z+2*y+a,[1,3]);
1398 (%o2) z + a
1399 (%i3) part(z+2*y+a,2,1);
1400 (%o3) 2
1401 @end example
1403 @code{example(part)} zeigt weitere Beispiele.
1404 @end deffn
1406 @c --- 15.10.2010 DK -----------------------------------------------------------
1407 @anchor{partition}
1408 @deffn {Funktion} partition (@var{expr}, @var{var})
1410 Die Funktion @code{partition} gibt eine Liste mit zwei Ausdr@"ucken zur@"uck.
1411 Ist das Argument @var{expr} ein Produkt enth@"alt das erste Element die
1412 Faktoren, die die Variable @code{var} enthalten, und das zweite Element
1413 enth@"alt die @"ubrigen Faktoren. Entsprechend enth@"alt das erste Element die
1414 Terme einer Summe oder die Elemente einer Liste, die die Variable @var{var}
1415 enthalten, und das zweite Elemente die verbleibende Terme der Summe oder
1416 Elemente der Liste.
1418 @example
1419 (%i1) partition (2*a*x*f(x), x);
1420 (%o1) [2 a, x f(x)]
1421 (%i2) partition (a+b, x);
1422 (%o2) [b + a, 0]
1423 (%i3) partition ([a, b, f(a), c], a);
1424 (%o3) [[b, c], [a, f(a)]]
1425 @end example
1426 @end deffn
1428 @c --- 15.10.2010 DK -----------------------------------------------------------
1429 @anchor{partswitch}
1430 @defvr {Optionsvariable} partswitch
1431 Standardwert: @code{false}
1433 Hat die Optionsvariable @code{partswitch} den Wert @code{true}, wird @code{end}
1434 zur@"uckgegeben, wenn versucht wird, einen Teilausdruck zu bilden, der nicht
1435 existiert, andernfalls wird eine Fehlermeldung ausgegeben.
1436 @end defvr
1438 @c --- 15.10.2010 DK -----------------------------------------------------------
1439 @anchor{pickapart}
1440 @deffn {Funktion} pickapart (@var{expr}, @var{n})
1442 Den Teilausdr@"ucken in einer Tiefe @var{n} eines verschachtelten Ausdrucks
1443 werden Zwischenmarken zugewiesen. @var{n} ist eine ganze positive Zahl. Die
1444 R@"uckgabe von @code{pickapart} ist ein @"aquivalenter Ausdruck, der die
1445 Zwischenmarken enth@"alt.
1447 Siehe auch @mrefcomma{part} @mrefcomma{dpart} @mrefcomma{lpart}@w{}
1448 @mref{inpart} und @mrefdot{reveal}
1450 Beispiele:
1452 @example
1453 (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
1454 @group
1455 2
1456 sin(x ) b + a
1457 (%o1) - log(sqrt(x + 1) + 1) + ------- + -----
1458 3 2
1459 @end group
1460 (%i2) pickapart (expr, 0);
1462 2
1463 sin(x ) b + a
1464 (%t2) - log(sqrt(x + 1) + 1) + ------- + -----
1465 3 2
1467 (%o2) %t2
1468 (%i3) pickapart (expr, 1);
1470 (%t3) - log(sqrt(x + 1) + 1)
1473 2
1474 sin(x )
1475 (%t4) -------
1476 3
1479 b + a
1480 (%t5) -----
1481 2
1483 (%o5) %t5 + %t4 + %t3
1484 (%i5) pickapart (expr, 2);
1486 (%t6) log(sqrt(x + 1) + 1)
1489 2
1490 (%t7) sin(x )
1493 (%t8) b + a
1495 %t8 %t7
1496 (%o8) --- + --- - %t6
1497 2 3
1498 (%i8) pickapart (expr, 3);
1500 (%t9) sqrt(x + 1) + 1
1503 2
1504 (%t10) x
1506 @group
1507 b + a sin(%t10)
1508 (%o10) ----- - log(%t9) + ---------
1509 2 3
1510 @end group
1511 (%i10) pickapart (expr, 4);
1513 (%t11) sqrt(x + 1)
1515 2
1516 sin(x ) b + a
1517 (%o11) ------- + ----- - log(%t11 + 1)
1518 3 2
1519 (%i11) pickapart (expr, 5);
1521 (%t12) x + 1
1523 2
1524 sin(x ) b + a
1525 (%o12) ------- + ----- - log(sqrt(%t12) + 1)
1526 3 2
1527 (%i12) pickapart (expr, 6);
1528 2
1529 sin(x ) b + a
1530 (%o12) ------- + ----- - log(sqrt(x + 1) + 1)
1531 3 2
1532 @end example
1533 @end deffn
1535 @c --- 15.10.2010 DK -----------------------------------------------------------
1536 @anchor{piece}
1537 @defvr {Systemvariable} piece
1539 Die Systemvariable @code{piece} enth@"alt den letzten Ausdruck, der bei der
1540 Verwendung einer @code{part}-Funktion ausgew@"ahlt wurde.
1542 Siehe auch @mref{part} und @mrefdot{inpart}
1543 @end defvr
1545 @c --- 15.10.2010 DK -----------------------------------------------------------
1546 @anchor{psubst}
1547 @deffn {Funktion} psubst (@var{list}, @var{expr})
1548 @deffnx {Funktion} psubst (@var{a}, @var{b}, @var{expr})
1550 @code{psubst(@var{a}, @var{b}, @var{expr})} ist identisch mit @code{subst}.
1551 Siehe @mrefdot{subst}
1553 Im Unterschied zu @code{subst} f@"uhrt die Funktion @code{psubst} Substitutionen
1554 parallel aus, wenn das erste Argument @var{list} eine Liste mit Gleichungen ist.
1556 Siehe auch die Funktion @mrefcomma{sublis} um Substitutionen parallel
1557 auszuf@"uhren.
1559 Beispiel:
1561 Das erste Beispiel zeigt die parallele Substitution mit @code{psubst}. Das
1562 zweite Beispiel zeigt das Ergebnis f@"ur die Funktion @code{subst}. In diesem
1563 Fall werden die Substitutionen nacheinander ausgef@"uhrt.
1565 @example
1566 (%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b));
1567 (%o4) sin(b) + sin(a)
1568 (%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b));
1569 (%o5) 2 sin(a)
1570 @end example
1571 @end deffn
1573 @c --- 15.10.2010 DK -----------------------------------------------------------
1574 @anchor{rembox}
1575 @need 800
1576 @deffn {Funktion} rembox (@var{expr}, unlabelled)
1577 @deffnx {Funktion} rembox (@var{expr}, @var{label})
1578 @deffnx {Funktion} rembox (@var{expr})
1580 Die Funktion @code{rembox} entfernt Rahmen aus dem Ausdruck @var{expr}.
1581 @code{rembox(@var{expr}, unlabelled)} entfernt alle Rahmen, die keine Marke
1582 haben. @code{rembox(@var{expr}, @var{label})} entfernt nur Rahmen, die mit der
1583 Marke @var{label} gekennzeichnet sind. @code{rembox(@var{expr})} entfernt alle
1584 Rahmen.
1586 Rahmen werden mit den Funktionen @mrefcomma{box} @mref{dpart} und
1587 @mref{lpart} einem Ausdruck hinzugef@"ugt.
1589 Beispiele:
1591 @example
1592 (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
1593 a d - b c
1594 (%o1) sin(%pi x) + ---------
1595 2
1596 h
1598 (%i2) dpart (dpart (expr, 1, 1), 2, 2);
1599 """"""" a d - b c
1600 (%o2) sin("%pi x") + ---------
1601 """"""" """"
1602 " 2"
1603 "h "
1604 """"
1606 (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
1607 FOO""""""""""" BAR""""""""
1608 " """"""" " "a d - b c"
1609 (%o3) "sin("%pi x")" + "---------"
1610 " """"""" " " """" "
1611 """""""""""""" " " 2" "
1612 " "h " "
1613 " """" "
1614 """""""""""
1616 (%i4) rembox (expr2, unlabelled);
1617 @group
1618 BAR""""""""
1619 FOO""""""""" "a d - b c"
1620 (%o4) "sin(%pi x)" + "---------"
1621 """""""""""" " 2 "
1622 " h "
1623 """""""""""
1625 @end group
1626 (%i5) rembox (expr2, FOO);
1627 @group
1628 BAR""""""""
1629 """"""" "a d - b c"
1630 (%o5) sin("%pi x") + "---------"
1631 """"""" " """" "
1632 " " 2" "
1633 " "h " "
1634 " """" "
1635 """""""""""
1637 @end group
1638 (%i6) rembox (expr2, BAR);
1639 @group
1640 FOO"""""""""""
1641 " """"""" " a d - b c
1642 (%o6) "sin("%pi x")" + ---------
1643 " """"""" " """"
1644 """""""""""""" " 2"
1645 "h "
1646 """"
1648 @end group
1649 (%i7) rembox (expr2);
1650 a d - b c
1651 (%o7) sin(%pi x) + ---------
1652 2
1653 h
1654 @end example
1655 @end deffn
1657 @c --- 28.08.2010 DK -----------------------------------------------------------
1658 @anchor{reveal}
1659 @deffn {Funktion} reveal (@var{expr}, @var{depth})
1661 Ersetzt Teile des Ausdrucks @var{expr} in der ganzzahligen Tiefe @var{depth}
1662 durch eine beschreibende Zusammenfassung:
1664 @itemize @bullet
1665 @item
1666 Summen und Differenzen werden durch @code{Sum(@var{n})} ersetzt, wobei @var{n}
1667 die Anzahl der Terme der Summe oder Differenz ist.
1669 @item
1670 Produkte werden durch @code{Product(@var{n})} ersetzt, wobei @var{n} die Anzahl
1671 der Faktoren des Produktes ist.
1673 @item
1674 Exponentiationen werden durch @code{Expt} ersetzt.
1676 @item
1677 Quotienten werden durch @code{Quotient} ersetzt.
1679 @item
1680 Die Negation wird durch @code{Negterm} ersetzt.
1682 @item
1683 Listen werden durch @code{List(@var{n})} ersetzt, wobei @var{n} die Anzahl der
1684 Elemente der Liste ist.
1685 @end itemize
1687 Ist @var{depth} gr@"o@ss{}er oder gleich der maximalen Tiefe des Ausdrucks
1688 @var{expr}, gibt @code{reveal} den Ausdruck @var{expr} unver@"andert zur@"uck.
1690 @code{reveal} wertet die Argumente aus. @code{reveal} gibt die
1691 Zusammenfassung zur@"uck.
1693 Beispiele:
1695 @example
1696 (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
1697 @group
1698 2 2
1699 b - 2 a b + a
1700 (%o1) -------------------------
1701 b + a 2 b 2 a
1702 2 %e + %e + %e
1703 @end group
1704 (%i2) reveal (e, 1);
1705 (%o2) Quotient
1706 (%i3) reveal (e, 2);
1707 Sum(3)
1708 (%o3) ------
1709 Sum(3)
1710 (%i4) reveal (e, 3);
1711 Expt + Negterm + Expt
1712 (%o4) ------------------------
1713 Product(2) + Expt + Expt
1714 (%i5) reveal (e, 4);
1715 2 2
1716 b - Product(3) + a
1717 (%o5) ------------------------------------
1718 Product(2) Product(2)
1719 2 Expt + %e + %e
1720 (%i6) reveal (e, 5);
1721 2 2
1722 b - 2 a b + a
1723 (%o6) --------------------------
1724 Sum(2) 2 b 2 a
1725 2 %e + %e + %e
1726 (%i7) reveal (e, 6);
1727 2 2
1728 b - 2 a b + a
1729 (%o7) -------------------------
1730 b + a 2 b 2 a
1731 2 %e + %e + %e
1732 @end example
1733 @end deffn
1735 @c --- 15.10.2010 DK -----------------------------------------------------------
1736 @anchor{sublis}
1737 @deffn {Funktion} sublis (@var{list}, @var{expr})
1739 F@"uhrt im Unterschied zu der Funktion @mref{subst} die Substitutionen der
1740 Liste @var{list} parallel und nicht nacheinander aus.
1742 Mit der Optionsvariablen @mref{sublis_apply_lambda} wird die Vereinfachung
1743 von Lamda-Ausdr@"ucken kontrolliert, nachdem die Substitution ausgef@"uhrt
1744 wurde.
1746 Siehe auch die Funktion @mrefcomma{psubst} um parallele Substitutionen
1747 auszuf@"uhren.
1749 Beispiele:
1751 @example
1752 (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
1753 (%o1) sin(b) + cos(a)
1754 @end example
1755 @end deffn
1757 @c --- 15.10.2010 DK -----------------------------------------------------------
1758 @anchor{sublis_apply_lambda}
1759 @need 800
1760 @defvr {Optionsvariable} sublis_apply_lambda
1761 Standardwert: @code{true}
1763 Kontrolliert, ob Lambda-Ausdr@"ucke nach einer Substitution ausgewertet werden.
1764 Hat @code{sublis_apply_lambda} den Wert @code{true} werden Lambda-Ausdr@"ucke
1765 ausgewertet. Ansonsten verbleiben diese nach der Substitution im Ausdruck.
1766 @end defvr
1768 @c -----------------------------------------------------------------------------
1769 @anchor{subnumsimp}
1770 @defvr {Option variable} subnumsimp
1771 Default value: @code{false}
1773 If @code{true} then the functions @mref{subst} and @mref{psubst} can substitute
1774 a subscripted variable @code{f[x]} with a number, when only the symbol @code{f}
1775 is given.
1777 See also @mrefdot{subst}
1779 @example
1780 (%i1) subst(100,g,g[x]+2);
1782 subst: cannot substitute 100 for operator g in expression g
1783 x
1784 -- an error. To debug this try: debugmode(true);
1786 (%i2) subst(100,g,g[x]+2),subnumsimp:true;
1787 (%o2) 102
1788 @end example
1789 @end defvr
1791 @c --- 15.10.2010 DK -----------------------------------------------------------
1792 @anchor{subst}
1793 @deffn {Funktion} subst (@var{a}, @var{b}, @var{c})
1795 Substituiert @var{a} f@"ur @var{b} in den Ausdruck @var{c}. Das Argument
1796 @var{b} muss ein Atom oder ein vollst@"andiger Teilausdruck von @var{c} sein.
1797 Zum Beispiel ist @code{x+y+z} ein vollst@"andiger Teilausdruck von
1798 @code{2*(x+y+z)/w}, nicht aber @code{x+y}. Hat @var{b} nicht diese Eigenschaft,
1799 dann k@"onnen m@"oglicherweise die Funktionen @mref{substpart} oder
1800 @mref{ratsubst} angewendet werden.
1802 Hat @var{b} die Form @code{e/f}, kann @code{subst(a*f, e, c)} verwendet werden.
1803 Ist @code{b} von der Form @code{e^(1/f)}, dann kann @code{subst(a^f, e, c)}
1804 verwendet werden. Die Funktion @code{subst} erkennt auch den Ausdruck
1805 @code{x^y} in @code{x^-y}, so dass @code{subst(a, sqrt(x), 1/sqrt(x))} das
1806 Ergebnis @code{1/a} hat. @var{a} und @var{b} k@"onnen auch die Namen von
1807 Operatoren oder Funktionen sein. Soll die unabh@"angige Variable in
1808 Ausdr@"ucken mit Ableitungen substituiert werden, sollte die Funktion
1809 @mref{at} verwendet werden.
1811 @code{subst} ist der Alias-Name f@"ur @code{substitute}.
1813 @code{subst(@var{eq_1}, @var{expr})} und @code{subst([@var{eq_1}, ...,
1814 @var{eq_k}], @var{expr})} sind weitere m@"ogliche Formen. @var{eq_i} sind
1815 Gleichungen, die angeben, welche Substitutionen auszuf@"uhren sind. F@"ur
1816 jede Gleichung wird die rechte Seite der Gleichung f@"ur die linke Seite in den
1817 Ausdruck @var{expr} substituiert.
1819 Hat die Optionsvariable @mref{exptsubst} den Wert @code{true}, wird eine
1820 Substitution wie @code{y} f@"ur @code{%e^x} in einem Ausdruck der Form
1821 @code{%e^(a*x)} nicht ausgef@"uhrt.
1823 Hat die Optionsvariable @mxref{option_opsubst, opsubst} den Wert @code{false},
1824 f@"uhrt die Funktion @code{subst} keine Substitution in einen Operator eines
1825 Ausdrucks aus. Zum Beispiel hat @code{(opsubst: false, subst(x^2, r, r+r[0]))}
1826 das Ergebnis @code{x^2+r[0]}.
1828 Beispiele:
1830 @example
1831 (%i1) subst (a, x+y, x + (x+y)^2 + y);
1832 2
1833 (%o1) y + x + a
1834 (%i2) subst (-%i, %i, a + b*%i);
1835 (%o2) a - %i b
1836 @end example
1838 @noindent
1839 Weitere Beispiele werden mit @code{example(subst)} angezeigt.
1840 @end deffn
1842 @c --- 15.10.2010 DK -----------------------------------------------------------
1843 @anchor{substinpart}
1844 @deffn {Funktion} substinpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
1846 Die Funktion @code{substinpart} ist vergleichbar mit @mrefdot{substpart}@w{}
1847 @code{substinpart} wirkt jedoch auf die interne Darstellung des Ausdrucks
1848 @var{expr}.
1850 Beispiele:
1852 @example
1853 (%i1) x . 'diff (f(x), x, 2);
1854 @group
1855 2
1856 d
1857 (%o1) x . (--- (f(x)))
1858 2
1859 dx
1860 @end group
1861 (%i2) substinpart (d^2, %, 2);
1862 2
1863 (%o2) x . d
1864 (%i3) substinpart (f1, f[1](x + 1), 0);
1865 (%o3) f1(x + 1)
1866 @end example
1867 @end deffn
1869 @c --- 15.10.2010 DK -----------------------------------------------------------
1870 @anchor{substpart}
1871 @deffn {Funktion} substpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
1873 Substituiert @var{x} f@"ur den Teilausdruck, der mit den restlichen Argumenten
1874 der Funktion @code{substpart} ausgew@"ahlt wird. Es wird der neue Ausdruck
1875 @var{expr} zur@"uckgegeben. @var{x} kann auch der Name eines Operators sein,
1876 der f@"ur einen Operator im Ausdruck @var{expr} substituiert wird. Zum Beispiel
1877 hat @code{substpart("+", a*b, 0)} das Ergebnis @code{b + a}).
1879 Mit dem Wert @code{true} f@"ur die Optionsvariable @mrefcomma{inflag} verh@"alt
1880 sich die Funktion @code{substpart} wie @mrefdot{substinpart}
1882 Beispiele:
1884 @example
1885 (%i1) 1/(x^2 + 2);
1886 1
1887 (%o1) ------
1888 2
1889 x + 2
1890 (%i2) substpart (3/2, %, 2, 1, 2);
1891 @group
1892 1
1893 (%o2) --------
1894 3/2
1895 x + 2
1896 @end group
1897 (%i3) a*x + f(b, y);
1898 (%o3) a x + f(b, y)
1899 (%i4) substpart ("+", %, 1, 0);
1900 (%o4) x + f(b, y) + a
1901 @end example
1902 @end deffn
1904 @c --- 12.11.2010 DK -----------------------------------------------------------
1905 @anchor{symbolp}
1906 @deffn {Funktion} symbolp (@var{expr})
1908 Gibt @code{true} zur@"uck, wenn @var{expr} ein Symbol ist, ansonsten
1909 @code{false}. Das Kommando @code{symbolp(x)} ist @"aquivalent zu
1910 @code{atom(x) and not numberp(x)}.
1912 Siehe auch @nrefdot{Bezeichner}
1913 @end deffn
1915 @c --- 15.10.2010 DK -----------------------------------------------------------
1916 @anchor{unorder}
1917 @deffn {Funktion} unorder ()
1919 L@"oscht die Ordnung, die mit dem letzten Aufruf der Funktionen
1920 @code{ordergreat} oder @code{orderless} erzeugt wurde.
1922 Siehe auch @mref{ordergreat} und @mrefdot{orderless}
1924 Beispiele:
1926 @example
1927 (%i1) unorder();
1928 (%o1) []
1929 (%i2) b*x + a^2;
1930 2
1931 (%o2) b x + a
1932 (%i3) ordergreat (a);
1933 (%o3) done
1934 (%i4) b*x + a^2;
1935 %th(1) - %th(3);
1936 2
1937 (%o4) a + b x
1938 (%i5) unorder();
1939 2 2
1940 (%o5) a - a
1941 @end example
1942 @end deffn
1944 @c --- 15.10.2010 DK -----------------------------------------------------------
1945 @anchor{verbify}
1946 @deffn {Funktion} verbify (@var{f})
1948 Gibt das Verb des Symbols @var{f} zur@"uck. Siehe auch das Kapitel
1949 @nrefcomma{Substantive und Verben} sowie @mref{noun} und @mrefdot{nounify}
1951 Beispiele:
1953 @example
1954 (%i1) verbify ('foo);
1955 (%o1) foo
1956 (%i2) :lisp $%
1957 $FOO
1958 (%i2) nounify (foo);
1959 (%o2) foo
1960 (%i3) :lisp $%
1961 %FOO
1962 @end example
1963 @end deffn
1965 @c --- End of file Expressions.de.texi -----------------------------------------