| blob | d8485940faa987fd53a035917aa12afd62a92919 |
1 @c -----------------------------------------------------------------------------
2 @c File : Command.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Command.texi revision 10.08.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 15.10.2010
8 @c Revision : 10.08.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 die Kommandozeile::
15 * Funktionen und Variablen der Eingabe::
16 * Funktionen und Variablen der Ausgabe::
17 @end menu
19 @c -----------------------------------------------------------------------------
20 @node Einf@"uhrung in die Kommandozeile, Funktionen und Variablen der Eingabe, Kommandozeile, Kommandozeile
21 @section Einf@"uhrung in die Kommandozeile
22 @c -----------------------------------------------------------------------------
24 @subheading Konsole
26 F@"ur Maxima sind verschiedene Nutzeroberfl@"achen erh@"altlich. Oberfl@"achen,
27 die je nach Betriebssystem bereits mit der Installation von Maxima zur
28 Verf@"ugung stehen, sind wxMaxima, Xmaxima, Imaxima und die Konsole.
30 Die Konsole (oder das Terminal) arbeitet in einem Textmodus. F@"ur die Ausgabe
31 in einem grafischen Modus mit einer men@"ugesteuerten Eingabe m@"ussen andere
32 Nutzeroberfl@"achen verwendet werden.
34 In dieser Dokumentation wird ausschlie@ss{}lich die Konsole eingesetzt, die
35 unter allen Betriebssystemen zur Verf@"ugung steht. Der Nutzer kann alle
36 Maxima-Funktionen in einer Konsole nutzen. Im Textmodus der Konsole
37 werden die Ergebnisse in der Regel in einem 2D-Modus dargestellt. F@"ur die
38 Ausgabe von Funktionsgraphen werden von Maxima Hilfsprogramme wie GNUPlot
39 aufgerufen.
41 @subheading Eingabe, Auswertung, Vereinfachung und Ausgabe
43 Jede Eingabe des Nutzers in einer Konsole bis zur Ausgabe eines Ergebnisses auf
44 der Konsole kann in vier Phasen eingeteilt werden:
46 @enumerate
47 @item
48 Von der Tastatur oder aus einer Datei wird ein Ausdruck eingelesen und vom
49 Parser in eine interne Darstellung umgewandelt. In dieser 1.@w{ }Phase werden
50 inbesondere Operatoren wie "+", "/" oder "do" behandelt.
52 @item
53 Der vom Parser eingelesene Ausdruck wird von Maxima in der 2.@w{ }Phase
54 ausgewertet. Dabei werden Variablen durch ihren Wert ersetzt und Funktionen wie
55 die Substitution oder Integration eines Ausdrucks ausgef@"uhrt. Das Ergebnis
56 dieser Phase ist ein ausgewerteter Ausdruck.
58 @item
59 Der ausgewertete Ausdruck wird in der 3.@w{ }Phase von Maxima vereinfacht.
60 Dabei werden Ausdr@"ucke wie @code{a+a} zu @code{2*a} oder @code{sin(%pi/2)} zu
61 @code{1} vereinfacht.
63 @item
64 Das Ergebnis ist ein ausgewerteter und vereinfachter Ausdruck. Zuletzt wird
65 dieses Ergebnis in der 4.@w{ }Phase f@"ur die Anzeige vorbereitet und auf der
66 Konsole ausgegeben.
67 @end enumerate
69 Der Nutzer kann auf jede einzelne Phase Einflu@ss{} nehmen. Verschiedene
70 Kapitel der Dokumentation befassen sich mit diesen M@"oglichkeiten. In diesem
71 Kapitel werden die Kommandos und M@"oglichkeiten zusammengestellt, die sich mit
72 der Eingabe und Ausgabe auf der Konsole befassen. In @ref{Auswertung} wird
73 beschrieben wie auf die Auswertung und in @ref{Vereinfachung} wie auf die
74 Vereinfachung einer Eingabe Einfluss genommen werden kann.
76 @subheading Marken
78 Maxima speichert alle Eingaben in den Marken @code{%i} und die Ausgaben in den
79 Marken @code{%o} ab. Die Marken erhalten eine laufende Nummer. Weiterhin
80 erzeugen einige Funktionen Zwischenmarken @code{%t}. Andere Systemvariablen
81 speichern das letzte Ergebnis oder die letzte Eingabe ab. Folgende Symbole
82 bezeichnen Variablen und Funktionen f@"ur die Verwaltung der Marken:
84 @verbatim
85 __ _
86 % %% %th
87 inchar linechar outchar
88 linenum nolabels
89 @end verbatim
91 @subheading Informationslisten
93 Maxima verwaltet Informationslisten. Die verf@"ugbaren Informationslisten sind
94 in der Systemvariablen @mref{infolists} enthalten. In diesem Kapitel werden die
95 Informationslisten @mrefcomma{labels} @mref{values} und
96 @mref{myoptions} erl@"autert. Wird eine Optionsvariable vom Nutzer gesetzt,
97 kontrolliert die Optionsvariable @mref{optionset} die Ausgabe weiterer
98 Informationen. Folgende Symbole bezeichnen Variablen und Funktionen f@"ur
99 Informationslisten und Optionsvariablen:
101 @verbatim
102 infolists labels values
103 myoptions optionset
104 @end verbatim
106 Weitere Informationslisten, die in anderen Kapiteln erl@"autert werden, sind:
108 @verbatim
109 functions arrays macros
110 rules aliases dependencies
111 gradefs props let_rule_packages
112 structures
113 @end verbatim
115 @subheading L@"oschen und R@"ucksetzen
117 Um eine Maxima-Umgebung herzustellen, in der keine Variablen oder Funktionen
118 definiert sind, oder um einzelne Zuweisungen, Eigenschaften oder Definitionen
119 zu entfernen, kennt Maxima die folgenden Funktionen:
121 @verbatim
122 kill reset reset_verbosely
123 @end verbatim
125 @subheading Weitere Kommandos der Kommandozeile
127 Mit den Symbolen @mref{?} und @mref{??} kann Dokumentation abgerufen werden.
128 Wird @code{?} einem Bezeichner als Pr@"afix vorangestellt, wird der Bezeichner
129 als Lisp-Symbol interpretiert. Mit weiteren Kommandos kann eine Maxima-Sitzung
130 beendet oder zu einer Lisp-Sitzung gewechselt werden. Das Zeichen f@"ur die
131 Eingabeaufforderung einer Unterbrechung kann ge@"andert werden. Die Zeit f@"ur
132 jede einzelne Berechnung kann angezeigt werden und die Ergebnisse einer Sitzung
133 k@"onnen wiederholt ausgegeben werden. Maxima kennt hierf@"ur die folgenden
134 Symbole:
136 @verbatim
137 ? ??
138 playback prompt showtime
139 quit to_lisp
140 @end verbatim
142 Die Funktionen @mref{read} und @mref{readonly} geben Ausdr@"ucke auf der Konsole
143 aus und lesen dann die Eingabe des Nutzers ein:
145 @verbatim
146 read readonly
147 @end verbatim
149 @subheading Ausgabe auf der Konsole
151 F@"ur die Ausgabe werden Ausdr@"ucke von einer internen Darstellung in eine
152 externe Darstellung transformiert. Zum Beispiel hat die Eingabe @code{sqrt(x)}
153 eine interne Darstellung, die dem Ausdruck @code{x^(1/2)} entspricht. F@"ur die
154 Ausgabe wird die interne Darstellung in einen Ausdruck transformiert, die der
155 Ausgabe @code{sqrt(x)} entspricht. Dieses Verhalten wird von der
156 Optionsvariablen @mref{sqrtdispflag} kontrolliert. Siehe @ref{Ausdr@"ucke}
157 f@"ur Funktionen, die die interne und externe Darstellung von Ausdr@"ucken
158 unterscheiden.
160 Folgende Optionsvariablen und Symbole kontrollieren die Ausgabe auf der Konsole:
162 @verbatim
163 %edispflag absboxchar display2d
164 display_format_internal exptdispflag
165 expt nexpt ibase
166 linel lispdisp negsumdispflag
167 obase pfeformat powerdisp
168 sqrtdispflag stardisp ttyoff
169 @end verbatim
171 Mit folgenden Funktionen kann die Ausgabe auf der Konsole formatiert werden:
173 @verbatim
174 disp display dispterms
175 grind ldisp ldisplay
176 print
177 @end verbatim
179 @c -----------------------------------------------------------------------------
180 @node Funktionen und Variablen der Eingabe, Funktionen und Variablen der Ausgabe, Einf@"uhrung in die Kommandozeile, Kommandozeile
181 @section Funktionen und Variablen der Eingabe
182 @c -----------------------------------------------------------------------------
184 @c --- 14.02.2011 DK -----------------------------------------------------------
185 @anchor{;}
186 @defvr {Operator} ;
188 Mit dem Semikolon @code{;} wird die Eingabe eines Maxima-Ausdrucks auf der
189 Konsole und in einer Datei abgeschlossen. Es k@"onnen mehrere Ausdr@"ucke mit
190 einem Semikolon als Abschluss auf einer Zeile eingegeben werden. Siehe auch
191 @mrefdot{$}
193 Beispiele:
195 @example
196 (%i1) a:10;
197 (%o1) 10
198 (%i2) a+b;
199 (%o2) b + 10
200 (%i3) x:10; x+y;
201 (%o3) 10
202 (%o4) y + 10
203 @end example
204 @end defvr
206 @c --- 14.02.2011 DK -----------------------------------------------------------
207 @anchor{$}
208 @defvr {Operator} $
210 Das Dollarzeichen schlie@ss{}t wie das Semikolon die Eingabe eines Ausdruckes
211 auf der Konsole und in einer Datei ab. Im Unterschied zum Semikolon wird die
212 Ausgabe des Ergebnisses unterdr@"uckt. Das Ergebnis wird jedoch weiterhin
213 einer Ausgabemarke @mxref{outchar,%o} zugewiesen und die Systemvariable
214 @mref{%} enth@"alt das Ergebnis. Siehe auch @mrefdot{;}
216 Beispiele:
218 @example
219 (%i1) expand((a+b)^2)$
221 (%i2) %;
222 2 2
223 (%o2) b + 2 a b + a
224 (%i3) a:10$ a+b$
226 (%i5) %o3;
227 (%o5) 10
228 (%i6) %o4;
229 (%o6) b + 10
230 @end example
231 @end defvr
233 @c --- 29.12.2010 DK -----------------------------------------------------------
234 @anchor{__}
235 @defvr {Systemvariable} __
236 @ifinfo
237 @vrindex Aktuelle Eingabe
238 @end ifinfo
240 W@"ahrend einer laufenden Auswertung enth@"alt die Systemvariable @code{__} den
241 zuletzt vom Parser eingelesenen Ausdruck @var{expr}. Der Ausdruck @var{expr}
242 wird der Systemvariablen @code{__} vor der Auswertung und Vereinfachung
243 zugewiesen.
245 Die Systemvariable @code{__} wird von den Funktionen @mref{batch} und
246 @mref{load} erkannt. Wird eine Datei mit der Funktion @code{batch}
247 ausgef@"uhrt, hat @code{__} dieselbe Bedeutung wie bei der Eingabe in einer
248 Kommandozeile. Wird eine Datei mit dem Namen @code{filename} mit der Funktion
249 @code{load} geladen, enth@"alt @code{__} den Ausdruck
250 @code{load(@var{filename})}. Das ist die letzte Eingabe in der Kommandozeile.
252 Siehe auch die Systemvariablen @mref{_} und @mrefdot{%}
254 Beispiele:
256 @example
257 (%i1) print ("I was called as: ", __)$
258 I was called as: print(I was called as, __)
260 (%i2) foo (__);
261 (%o2) foo(foo(__))
263 (%i3) g (x) := (print ("Current input expression =", __), 0)$
264 (%i4) [aa : 1, bb : 2, cc : 3]$
265 (%i5) (aa + bb + cc)/(dd + ee + g(x))$
267 cc + bb + aa
268 Current input expression = --------------
269 g(x) + ee + dd
270 @end example
271 @end defvr
273 @c --- 29.12.2010 DK -----------------------------------------------------------
274 @anchor{_}
275 @defvr {Systemvariable} _
276 @ifinfo
277 @vrindex Letzte Eingabe
278 @end ifinfo
280 Die Systemvariable @code{_} enth@"alt den zuletzt eingegebenen Ausdruck
281 @var{expr}. Der Ausdruck @var{expr} wird der Systemvariablen @code{_} vor der
282 Auswertung und Vereinfachung zugewiesen.
284 Die Systemvariable @code{_} wird von den Funktionen @mref{batch} und
285 @mref{load} erkannt. Wird eine Datei mit der Funktion @code{batch}@w{}
286 ausgef@"uhrt, hat @code{_} dieselbe Bedeutung wie bei der Eingabe in einer
287 Kommandozeile. Wird eine Datei mit der Funktion @code{load} geladen, enth@"alt
288 @code{_} das zuletzt in der Kommandozeile eingegebene Kommando.
290 Siehe auch die Systemvariablen @mref{__} und @mrefdot{%}
292 Beispiele:
294 Die Funktion @mref{cabs} wird ausgewertet und nicht vereinfacht. Das Beispiel
295 zeigt, dass die Systemvariable @code{_} den zuletzt eingelesenen Ausdruck vor
296 der Auswertung enth@"alt.
298 @example
299 (%i1) cabs(1+%i);
300 (%o1) sqrt(2)
301 (%i2) _;
302 (%o2) cabs(%i + 1)
303 @end example
305 Die Funktion @mref{abs} vereinfacht einen Ausdruck. Wird der Inhalt der
306 Systemvariablen @code{_} ausgegeben, wird das f@"ur die Ausgabe vereinfachte
307 Ergebnis angezeigt. Mit der Funktion @mref{string} wird der Inhalt der
308 Systemvariablen @code{_} vor der Ausgabe in ein Zeichenkette umgewandelt, um
309 den nicht vereinfachten Wert sichtbar zu machen.
311 @example
312 (%i3) abs(1+%i);
313 (%o3) sqrt(2)
314 (%i4) _;
315 (%o4) sqrt(2)
316 (%i5) abs(1+%i);
317 (%o5) sqrt(2)
318 (%i6) string(_);
319 (%o6) abs(1+%i)
320 @end example
321 @end defvr
323 @c --- 21.10.2010 DK -----------------------------------------------------------
324 @anchor{%}
325 @defvr {Systemvariable} %
326 @ifinfo
327 @vrindex Letzte Ausgabe
328 @end ifinfo
330 Die Systemvariable @code{%} enth@"alt das Ergebnis des zuletzt von Maxima
331 ausgewerteten und vereinfachten Ausdrucks. @code{%} enh@"alt das letzte
332 Ergebnis auch dann, wenn die Ausgabe des Ergebnisses durch Abschluss der Eingabe
333 mit einem Dollarzeichen @mref{$} unterdr@"uckt wurde.
335 Die Systemvariable @code{%} wird von den Funktionen @mref{batch} und
336 @mref{load} erkannt. Wird eine Datei mit der Funktion @code{batch}
337 ausgef@"uhrt, hat @code{%} dieselbe Bedeutung wie bei der Eingabe in einer
338 Kommandozeile. Wird eine Datei mit der Funktion @code{load} geladen, enth@"alt
339 @code{%} das letzte Ergebnis des Ausdrucks, der auf der Konsole eingegeben
340 wurde.
342 Siehe auch die Systemvariablen @mrefcomma{_} @mref{__} und @mrefdot{%th}
343 @end defvr
345 @c --- 27.07.2013 VvN ----------------------------------------------------------
346 @anchor{%%}
347 @defvr {Systemvariable} %%
348 @ifinfo
349 @vrindex Letztes Ergebnis in zusammengesetzten Anweisungen
350 @end ifinfo
352 In zusammengesetzten Ausdr@"ucken, wie in Ausdr@"ucken mit @mref{block} oder
353 @mref{lambda} oder in Ausdr@"ucken der Gestalt @code{(@var{s_1}, ..., @var{s_n})},
354 enth@"alt die Systemvariable @code{%%} das Ergebnis des
355 vorhergehenden Ausdrucks. F@"ur den ersten Ausdruck oder au@ss{}erhalb eines
356 zusammengesetzten Ausdrucks ist @code{%%} nicht definiert.
358 Die Systemvariable @code{%%} wird von @mref{batch} und @mref{load} erkannt und
359 hat dieselbe Bedeutung wie bei der Eingabe in der Konsole. Siehe auch die
360 Systemvariable @mref{%} und die Funktion @mrefdot{%th}
362 Beispiele:
364 Auf die im ersten Ausdruck berechnete Stammfunktion wird im zweiten Ausdruck
365 mit @code{%%} Bezug genommen, um das Integral an der oberen und unteren Grenze
366 auszuwerten.
368 @example
369 @group
370 (%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
371 21
372 (%o1) --
373 2
374 @end group
375 @end example
377 Ein zusammengesetzter Ausdruck kann weitere zusammengesetzte Ausdr@"ucke
378 enthalten. @code{%%} enth@"alt dabei jeweils das Ergebnis des letzten
379 Ausdrucks. Das folgende Beispiel hat das Ergebnis @code{7*a^n}.
381 @example
382 (%i3) block (block (a^n, %%*42), %%/6);
383 n
384 (%o3) 7 a
385 @end example
387 Der Wert der Systemvariablen @code{%%} kann nach einer Unterbrechung mit dem
388 Kommando @mref{break} inspiziert werden. In diesem Beispiel hat die
389 Systemvariable @code{%%} den Wert 42.
391 @example
392 (%i4) block (a: 42, break ())$
393 Entering a Maxima break point. Type 'exit;' to resume.
394 _%%;
395 42
396 _
397 @end example
398 @end defvr
400 @c --- 29.12.2010 DK -----------------------------------------------------------
401 @anchor{%th}
402 @deffn {Funktion} %th (@var{n})
403 @ifinfo
404 @fnindex n-te vorhergehende Ausgabe
405 @end ifinfo
407 Die Funktion @code{%th} liefert das n-te vorhergehende Ergebnis. Dies ist dann
408 n@"utzlich, wenn wie in Batch-Dateien die absolute Zeilennummer der letzten
409 Ausgabemarken nicht bekannt ist.
411 Die Funktion @code{%th} wird von den Funktionen @mref{batch} und
412 @mref{load} erkannt. Wird eine Datei mit @code{batch} ausgef@"uhrt, hat
413 @code{%th} dieselbe Bedeutung wie bei der Eingabe in der Konsole. Wird eine
414 Datei mit der Funktion @code{load} geladen, enth@"alt @code{%th} das letzte
415 Ergebnis der Eingabe in der Konsole.
417 Siehe auch @mref{%} und @mrefdot{%%}
419 Beispiel:
421 Das Beispiel zeigt, wie die letzten 5 eingegebenen Werte mit der Funktion
422 @code{%th} aufsummiert werden.
424 @example
425 (%i1) 1;2;3;4;5;
426 (%o1) 1
427 (%o2) 2
428 (%o3) 3
429 (%o4) 4
430 (%o5) 5
431 (%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
432 (%o6) 15
433 @end example
434 @end deffn
436 @c --- 08.09.2010 DK -----------------------------------------------------------
437 @anchor{?}
438 @deffn {Spezielles Symbol} ?
439 @ifinfo
440 @fnindex Erhalte Dokumentation
441 @end ifinfo
443 Wird dem Namen einer Funktion oder Variablen ein @code{?} als Pr@"afix
444 vorangestellt, wird der Name als ein Lisp-Symbol interpretiert. Zum Beispiel
445 bedeutet @code{?round} die Lisp-Funktion @code{ROUND}. Siehe
446 @ref{Lisp und Maxima} f@"ur weitere Ausf@"uhrungen zu diesem Thema.
448 Die Eingabe @code{? word} ist eine Kurzschreibweise f@"ur das Kommando
449 @code{describe("word")}. Das Fragezeichen muss am Anfang einer Eingabezeile
450 stehen, damit Maxima die Eingabe als eine Anfrage nach der Dokumentation
451 interpretiert. Siehe auch @mrefdot{describe}
452 @end deffn
454 @c --- 08.09.2010 DK -----------------------------------------------------------
455 @anchor{??}
456 @deffn {Spezielles Symbol} ??
457 @ifinfo
458 @fnindex Erhalte Dokumentation (ungenaue Suche)
459 @end ifinfo
461 Die Eingabe @code{?? word} ist eine Kurzschreibweise f@"ur das Kommando
462 @code{describe("word", inexact)}. Die Fragezeichen m@"ussen am Anfang einer
463 Eingabezeile stehen, damit Maxima die Eingabe als eine Anfrage nach der
464 Dokumentation interpretiert. Siehe auch @mrefdot{describe}
465 @end deffn
467 @c --- 08.09.2010 DK -----------------------------------------------------------
468 @anchor{inchar}
469 @need 1000
470 @defvr {Optionsvariable} inchar
471 Standardwert: @code{%i}
473 Die Optionsvariable @code{inchar} enth@"alt den Pr@"afix der Eingabemarken.
474 Maxima erzeugt die Eingabemarken automatisch aus dem Pr@"afix @code{inchar} und
475 der Zeilennummer @mrefdot{linenum}
477 Der Optionsvariablen @code{inchar} kann eine Zeichenkette oder ein Symbol
478 zugewiesen werden, die auch mehr als ein Zeichen haben k@"onnen. Da Maxima
479 intern nur das erste Zeichen ber@"ucksichtigt, sollten sich die Pr@"afixe
480 @code{inchar}, @code{outchar} und @code{linechar} im ersten Zeichen voneinander
481 unterscheiden. Ansonsten funktionieren einige Kommandos wie zum Beispiel
482 @code{kill(inlabels)} nicht wie erwartet.
484 Siehe auch die Funktion und Systemvariable @mref{labels} sowie die
485 Optionsvariablen @mref{outchar} und @mrefdot{linechar}
487 Beispiele:
489 @example
490 (%i1) inchar: "input";
491 (%o1) input
492 (input2) expand((a+b)^3);
493 3 2 2 3
494 (%o2) b + 3 a b + 3 a b + a
495 (input3)
496 @end example
497 @end defvr
499 @c --- 08.09.2010 DK -----------------------------------------------------------
500 @anchor{infolists}
501 @defvr {Systemvariable} infolists
503 Die Systemvariable @code{infolists} enth@"alt eine Liste der Informationslisten,
504 die Maxima zur Verf@"ugung stellt. Diese sind:
506 @table @code
507 @item labels
508 Enth@"alt die Marken @code{%i}, @code{%o} und @code{%t}, denen bisher ein
509 Ausdruck zugewiesen wurde.
511 @item values
512 Enth@"alt die vom Nutzer mit den Operatoren @mref{:} oder @mref{::} definierten
513 Variablen.
515 @item functions
516 Enth@"alt die vom Nutzer mit dem Operator @mref{:=} oder der Funktion
517 @mref{define} definierten Funktionen.
519 @item arrays
520 Enth@"alt die mit den Operatoren @code{:}, @code{::} oder @code{:=} definierten
521 Arrays oder Array-Funktionen.
523 @item macros
524 Enth@"alt die vom Nutzer mit dem Operator @mref{::=} definierten Makros.
526 @item myoptions
527 Enth@"alt die Optionsvariablen, die vom Nutzer bisher einen neuen Wert erhalten
528 haben.
530 @item rules
531 Enth@"alt die vom Nutzer mit den Funktionen @mrefcomma{tellsimp}@w{}
532 @mrefcomma{tellsimpafter} @mref{defmatch} oder @mref{defrule}@w{}
533 definierten Regeln.
535 @item aliases
536 Enth@"alt die Symbole, die einen vom Nutzer definierten Alias-Namen mit der
537 Funktion @mref{alias} erhalten haben. Weiterhin erzeugen die Funktionen
538 @mref{ordergreat} und @mref{orderless} sowie eine Deklaration als
539 @mref{noun} mit der Funktion @mref{declare} Alias-Namen, die in die Liste
540 eingetragen werden.
542 @item dependencies
543 Enth@"alt alle Symbole, f@"ur die mit den Funktionen @mref{depends} oder
544 @mref{gradef} eine Abh@"angigkeit definiert ist.
546 @item gradefs
547 Enth@"alt die Funktionen, f@"ur die der Nutzer mit der Funktion
548 @mref{gradef} eine Ableitung definiert hat.
550 @item props
551 Enth@"alt die Symbole, die eine Eigenschaft mit der Funktion
552 @mref{declare} erhalten haben.
554 @item let_rule_packages
555 Enth@"alt die vom Nutzer definierten @mref{let}-Regeln.
557 @c TODO: BESCHREIBUNG DER LISTE STRUCTURES FEHLT.
559 @end table
560 @end defvr
562 @c --- 08.09.2010 DK -----------------------------------------------------------
563 @anchor{kill}
564 @deffn {Funktion} kill (@var{a_1}, @dots{}, @var{a_n})
565 @deffnx {Funktion} kill (labels)
566 @deffnx {Funktion} kill (inlabels, outlabels, linelabels)
567 @deffnx {Funktion} kill (@var{n})
568 @deffnx {Funktion} kill ([@var{m}, @var{n}])
569 @deffnx {Funktion} kill (values, functions, arrays, @dots{})
570 @deffnx {Funktion} kill (all)
571 @deffnx {Funktion} kill (allbut (@var{a_1}, @dots{}, @var{a_n}))
573 Die Funktion @code{kill} entfernt alle Zuweisungen (Werte, Funktionen, Arrays
574 oder Regeln) und Eigenschaften von den Argumenten @var{a_1}, @dots{}, @var{a_n}.
575 Ein Argument @var{a_k} kann ein Symbol oder ein einzelnes Array-Element sein.
576 Ist @var{a_k} ein einzelnes Array-Element, entfernt @code{kill} die Zuweisungen
577 an dieses Element, ohne die anderen Elemente des Arrays zu beeinflussen.
579 @code{kill} kennt verschiedene spezielle Argumente, die auch kombiniert werden
580 k@"onnen wie zum Beispiel @code{kill(inlabels, functions, allbut(foo, bar))}.
582 @code{kill(labels)} entfernt alle Zuweisungen an Eingabe-, Ausgabe- und
583 Zwischenmarken. @code{kill(inlabels)} entfernt nur die Zuweisungen an
584 Eingabemarken, die mit dem aktuellen Wert von @mref{inchar} beginnen.
585 Entsprechend entfernt @code{kill(outlabels)} die Zuweisungen an die
586 Ausgabemarken, die mit dem aktuellen Wert von @mref{outchar} beginnen und
587 @code{kill(linelabels)} die Zuweisungen an die Zwischenmarken, die mit dem
588 aktuellen Wert von @mref{linechar} beginnen.
590 @code{kill(@var{n})}, wobei @var{n} eine ganze Zahl ist, entfernt die
591 Zuweisungen an die @var{n} letzten Eingabe- und Ausgabemarken.
592 @code{kill([@var{m}, @var{n}])} entfernt die Zuweisungen an die Eingabe- und
593 Ausgabemarken mit den Nummern von @var{m} bis @var{n}.
595 @code{kill(@var{infolist})}, wobei @var{infolist} eine Informationsliste wie zum
596 Beispiel @mrefcomma{values} @mref{functions} oder @mref{arrays} ist, entfernt
597 die Zuweisungen an allen Eintr@"agen der Liste @var{infolist}. Siehe auch
598 @mrefdot{infolists}
600 @code{kill(all)} entfernt die Zuweisungen an die Eintr@"age in s@"amtlichen
601 Informationslisten. @code{kill(all)} setzt keine Optionsvariablen auf ihre
602 Standardwerte zur@"uck. Siehe die Funktion @mrefcomma{reset} um
603 Optionsvariablen auf ihre Standwerte zur@"uckzusetzen.
605 @code{kill(allbut(@var{a_1}, ..., @var{a_n}))} entfernt alle Zuweisungen bis
606 auf Zuweisungen an die Variablen @var{a_1}, @dots{}, @var{a_n}.
607 @code{kill(allbut(@var{infolist}))} entfernt alle Zuweisungen bis auf denen in
608 der Informationsliste @var{infolist}.
610 @code{kill(@var{symbol})} entfernt s@"amtliche Zuweisungen und Eigenschaften
611 des Symbols @w{@var{symbol}}. Im Gegensatz dazu entfernen
612 @mrefcomma{remvalue} @mrefcomma{remfunction} @mref{remarray} und
613 @mref{remrule} jeweils eine spezielle Eigenschaft eines Symbols.
615 @code{kill} wertet die Argumente nicht aus. Der
616 @nxref{'', Quote-Quote-Operator} @code{''} kann die Auswertung erzwingen.
617 @code{kill} gibt immer @code{done} zur@"uck.
618 @end deffn
620 @c --- 23.10.2010 DK -----------------------------------------------------------
621 @anchor{labels}
622 @deffn {Funktion} labels (@var{symbol})
623 @deffnx {Systemvariable} labels
625 Die Funktion @code{labels} gibt eine Liste der Eingabe-, Ausgabe- und
626 Zwischenmarken zur@"uck, die mit dem Argument @var{symbol} beginnen.
627 Typischerweise ist @var{symbol} der Wert von
628 @mrefcomma{inchar} @mref{outchar} oder @mrefdot{linechar} Dabei kann das
629 Prozentzeichen fortgelassen werden. So haben zum Beispiel die Kommandos
630 @code{labels(i)} und @code{labels(%i)} dasselbe Ergebnis.
632 Wenn keine Marke mit @var{symbol} beginnt, gibt @code{labels} eine leere Liste
633 zur@"uck.
635 Die Funktion @code{labels} wertet das Argument nicht aus. Mit dem
636 @nxref{'', Quote-Quote-Operator} @code{''} kann die Auswertung erzwungen
637 werden. Zum Beispiel gibt das Kommando @code{labels(''inchar)} die Marken
638 zur@"uck, die mit dem aktuellen Buchstaben f@"ur die Eingabemarken beginnen.
640 Die Systemvariable @code{labels} ist eine Informationsliste, die die Eingabe-,
641 Ausgabe- und Zwischenmarken enth@"alt. In der Liste sind auch die Marken
642 enthalten, die vor einer @"Anderung von @code{inchar}, @code{outchar} oder
643 @code{linechar} erzeugt wurden.
645 Standardm@"a@ss{}ig zeigt Maxima das Ergebnis jeder Eingabe an, wobei dem
646 Ergebnis eine Ausgabemarke hinzugef@"ugt wird. Die Anzeige der Ausgabe wird
647 durch die Eingabe eines abschlie@ss{}enden @mref{$} (Dollarzeichen) statt eines
648 @mref{;} (Semikolon) unterdr@"uckt. Dabei wird eine Ausgabemarke erzeugt und
649 das Ergebnis zugewiesen, jedoch nicht angezeigt. Die Marke kann aber in der
650 gleichen Art und Weise wie bei angezeigten Ausgabemarken referenziert werden.
651 Siehe auch @mrefcomma{%} @mref{%%} und @mrefdot{%th}
653 Einige Funktionen erzeugen Zwischenmarken. Die Optionsvariable
654 @mref{programmode} kontrolliert, ob zum Beispiel @mref{solve} und einige andere
655 Funktionen Zwischenmarken erzeugen, anstatt eine Liste von Ausdr@"ucken
656 zur@"uckzugeben. Andere Funktionen wie zum Beispiel @mref{ldisplay} erzeugen
657 stets Zwischenmarken.
659 Siehe auch @mrefdot{infolists}
660 @end deffn
662 @c --- 23.10.2010 DK -----------------------------------------------------------
663 @anchor{linechar}
664 @defvr {Optionsvariable} linechar
665 Standardwert: @code{%t}
667 Die Optionsvariable @code{linechar} enth@"alt den Pr@"afix der Zwischenmarken.
668 Maxima generiert die Zwischenmarken automatisch aus @code{linechar}.
670 Der Optionsvariablen @code{linechar} kann eine Zeichenkette oder ein Symbol
671 zugewiesen werden, die auch mehr als ein Zeichen haben k@"onnen. Da Maxima
672 intern nur das erste Zeichen ber@"ucksichtigt, sollten sich die Pr@"afixe
673 @mrefcomma{inchar} @mref{outchar} und @code{linechar} im ersten Zeichen
674 voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie
675 @code{kill(inlabels)} nicht wie erwartet.
677 Die Ausgabe von Zwischenmarken kann mit verschiedenen Optionsvariablen
678 kontrolliert werden. Siehe @mref{programmode} und @mrefdot{labels}
679 @end defvr
681 @c --- 08.09.2010 DK -----------------------------------------------------------
682 @anchor{linenum}
683 @defvr {Systemvariable} linenum
685 Enth@"alt die Zeilennummer der aktuellen Ein- und Ausgabemarken. Die
686 Zeilennummer wird von Maxima automatisch erh@"oht. Siehe auch
687 @mrefcomma{labels} @mref{inchar} und @mrefdot{outchar}
688 @end defvr
690 @c --- 23.10.2010 DK -----------------------------------------------------------
691 @anchor{myoptions}
692 @defvr {Systemvariable} myoptions
694 @code{myoptions} ist eine Informationsliste, die die Optionsvariablen enth@"alt,
695 die vom Nutzer w@"ahrend einer Sitzung ge@"andert wurden. Die Variable
696 verbleibt in der Liste, auch wenn sie wieder auf den Standardwert
697 zur@"uckgesetzt wird.
698 @end defvr
700 @c --- 23.10.2010 DK -----------------------------------------------------------
701 @anchor{nolabels}
702 @defvr {Optionsvariable} nolabels
703 Standardwert: @code{false}
705 Hat @code{nolabels} den Wert @code{true}, werden die Eingabe- und Ausgabemarken
706 zwar angezeigt, ihnen werden aber keine Eingaben und Ergebnisse zugewiesen und
707 sie werden nicht der Informationsliste @code{labels} hinzugef@"ugt. Andernfalls
708 werden den Marken die Eingabe und die Ergebnisse zugewiesen und in die
709 Informationsliste @code{labels} eingetragen.
711 Zwischenmarken @code{%t} werden durch @code{nolabels} nicht beeinflusst. Den
712 Marken werden unabh@"angig vom Wert, den @code{nolabels} hat, Zwischenergebnisse
713 zugewiesen und sie werden in die Informationsliste @code{labels} eingetragen.
715 Siehe auch @mrefdot{labels}
716 @end defvr
718 @c --- 08.09.2010 DK -----------------------------------------------------------
719 @anchor{optionset}
720 @defvr {Optionsvariable} optionset
721 Standardwert: @code{false}
723 Hat @code{optionset} den Wert @code{true}, gibt Maxima eine Meldung aus, wenn
724 einer Optionsvariablen ein Wert zugewiesen wird.
726 Beispiel:
728 @example
729 (%i1) optionset:true;
730 assignment: assigning to option optionset
731 (%o1) true
732 (%i2) gamma_expand:true;
733 assignment: assigning to option gamma_expand
734 (%o2) true
735 @end example
736 @end defvr
738 @c --- 23.10.2010 DK -----------------------------------------------------------
739 @anchor{outchar}
740 @defvr {Optionsvariable} outchar
741 Standardwert: @code{%o}
743 Die Optionsvariable @code{outchar} enth@"alt den Pr@"afix der Ausgabemarken.
744 Maxima generiert die Ausgabemarken automatisch aus @code{outchar} und
745 @mrefdot{linenum}
747 Der Optionsvariablen @code{outchar} kann eine Zeichenkette oder ein Symbol
748 zugewiesen werden, die auch mehr als ein Zeichen haben k@"onnen. Da Maxima
749 intern nur das erste Zeichen ber@"ucksichtigt, sollten sich die Pr@"afixe
750 @mrefcomma{inchar} @code{outchar} und @mref{linechar} im ersten Zeichen
751 voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie
752 @code{kill(inlabels)} nicht wie erwartet.
754 Siehe auch @mrefdot{labels}
756 Beispiele:
758 @example
759 (%i1) outchar: "output";
760 (output1) output
761 (%i2) expand((a+b)^3);
762 3 2 2 3
763 (output2) b + 3 a b + 3 a b + a
764 (%i3)
765 @end example
766 @end defvr
768 @c --- 23.10.2010 DK -----------------------------------------------------------
769 @anchor{playback}
770 @deffn {Funktion} playback ()
771 @deffnx {Funktion} playback (@var{n})
772 @deffnx {Funktion} playback ([@var{m}, @var{n}])
773 @deffnx {Funktion} playback ([@var{m}])
774 @deffnx {Funktion} playback (input)
775 @deffnx {Funktion} playback (slow)
776 @deffnx {Funktion} playback (time)
777 @deffnx {Funktion} playback (grind)
779 Zeigt Eingaben, Ergebnisse und Zwischenergebnisse an, ohne diese neu zu
780 berechnen. @code{playback} zeigt nur die Eingaben und Ergebnisse an, die Marken
781 zugewiesen wurden. Andere Ausgaben, wie zum Beispiel durch
782 @mrefcomma{print} @mref{describe} oder Fehlermeldungen, werden nicht angezeigt.
783 Siehe auch @mrefdot{labels}
785 @code{playback()} zeigt s@"amtliche Eingaben und Ergebnisse an, die bis dahin
786 erzeugt wurden. Ein Ergebnis wird auch dann angezeigt, wenn die Ausgabe mit
787 @mref{$} unterdr@"uckt war.
789 @code{playback(@var{n})} zeigt die letzten @var{n} Ausdr@"ucke an. Jeder
790 Eingabe-, Ausgabe- und Zwischenausdruck z@"ahlt dabei als ein Ausdruck.
791 @code{playback([@var{m}, @var{n}])} zeigt die Eingabe-, Ausgabe- und
792 Zwischenausdr@"ucke mit den Zahlen von @var{m} bis einschlie@ss{}lich @var{n}
793 an. @code{playback([@var{m}])} ist @"aquivalent zu @code{playback([@var{m},
794 @var{m}])}. Die Ausgabe ist ein Paar von Ein- und Ausgabeausdr@"ucken.
796 @code{playback(input)} zeigt s@"amtliche Eingabeausdr@"ucke an, die bis dahin
797 erzeugt wurden.
799 @code{playback(slow)} macht nach jeder Ausgabe eine Pause und wartet auf eine
800 Eingabe. Dieses Verhalten ist vergleichbar mit der Funktion @mrefdot{demo}
802 @code{playback(time)} zeigt f@"ur jeden Ausdruck die f@"ur die Berechnung
803 ben@"otigte Zeit an.
805 @code{playback(grind)} zeigt die Eingabeausdr@"ucke in dem gleichen Format an,
806 wie die Funktion @code{grind}. Ausgabeausdr@"ucke werden von der Option
807 @code{grind} nicht beeinflusst. Siehe auch @mrefdot{grind}
809 Die Argumente k@"onnen kombiniert werden, wie zum Beispiel im folgenden
810 Kommando @code{playback([5, 10], grind, time, slow)}.
812 @code{playback} wertet die Argumente nicht aus. @code{playback} gibt stets
813 @code{done} zur@"uck.
814 @end deffn
816 @c --- 23.10.2010 DK -----------------------------------------------------------
817 @anchor{prompt}
818 @defvr {Optionsvariable} prompt
819 Standardwert: @code{_}
821 Die Optionsvariable @code{prompt} enth@"alt das Zeichen f@"ur die
822 Eingabeaufforderung der Funktionen @mref{demo} und @mref{playback} sowie
823 nach einer Unterbrechung, wie zum Beispiel durch das Kommando @mrefdot{break}
824 @end defvr
826 @c --- 08.09.2010 DK -----------------------------------------------------------
827 @anchor{quit}
828 @deffn {Funktion} quit ([@var{returnwert}])
830 Die Funktion @code{quit()} beendet eine Maxima-Sitzung.
831 Die Funktion muss als @code{quit();} oder @code{quit()$}, nicht @code{quit} allein
832 aufgerufen werden.
833 @code{quit} kann einen Returnwert retournieren, wenn der Lisp-Compiler und das
834 Betriebssystem Returnwerte unterstützt.
835 Standardmässig wird der Wert 0 retourniert (meist als kein Fehler interpretiert).
836 @code{quit(1)} könnte der Shell daher einen Fehler anzeigen.
837 Das kann für Skripte nützlich sein, wo Maxima dadurch anzeigen kann,
838 dass Maxima irgendwas nicht berechnen konnte oder ein sonstiger Fehler
839 aufgetreten ist.
841 Mit der Tastatureingabe @kbd{control-c} oder @code{Strg-c} kann in der Konsole
842 die Verarbeitung abgebrochen werden. Stan@-dard@-m@"a@ss{}ig wird die
843 Maxima-Sitzung fortgesetzt. Hat die globale Lisp-Variable
844 @code{*debugger-hook*} den Wert @code{nil}, wird der Lisp-Debugger gestartet.
845 Siehe @ref{Fehlersuche}.
846 @end deffn
848 @c --- 23.10.2010 DK -----------------------------------------------------------
849 @anchor{read}
850 @deffn {Funktion} read (@var{expr_1}, @dots{}, @var{expr_n})
852 Gibt die Ausdr@"ucke @var{expr_1}, @dots{} @var{expr_n} auf der Konsole aus,
853 liest sodann einen Ausdruck von der Konsole ein und wertet diesen aus. Die
854 Eingabe des Ausdrucks wird mit den Zeichen @mref{;} oder @mref{$} beendet.
856 Siehe auch @mrefdot{readonly}
858 Beispiele:
860 @example
861 (%i1) foo: 42$
862 (%i2) foo: read ("foo is", foo, " -- enter new value.")$
863 foo is 42 -- enter new value.
864 (a+b)^3;
865 (%i3) foo;
866 3
867 (%o3) (b + a)
868 @end example
869 @end deffn
871 @c --- 28.08.2010 DK -----------------------------------------------------------
872 @anchor{readonly}
873 @deffn {Funktion} readonly (@var{expr_1}, @dots{}, @var{expr_n})
875 Gibt die Ausdr@"ucke @var{expr_1}, @dots{} @var{expr_n} auf der Konsole aus,
876 liest sodann einen Ausdruck von der Konsole ein und gibt den eingelesenen
877 Ausdruck zur@"uck ohne diesen auszuwerten. Die Eingabe des Ausdrucks wird mit
878 den Zeichen @mref{;} oder @mref{$} beendet.
880 Siehe auch @mrefdot{read}
882 Beispiele:
884 @example
885 (%i1) aa: 7$
886 (%i2) foo: readonly ("Enter an expression:");
887 Enter an expression:
888 2^aa;
889 aa
890 (%o2) 2
891 (%i3) foo: read ("Enter an expression:");
892 Enter an expression:
893 2^aa;
894 (%o3) 128
895 @end example
896 @end deffn
898 @c --- 23.10.2010 DK -----------------------------------------------------------
899 @anchor{reset}
900 @deffn {Funktion} reset ()
902 @code{reset()} setzt globale Maxima- und Lisp-Variablen und Optionen auf ihre
903 Standardwerte zur@"uck. Maxima legt eine interne Liste mit den Standardwerten
904 von globalen Variablen an. Alle Variablen, die in dieser Liste enthalten sind,
905 werden auf ihre Standardwerte zur@"uckgesetzt. Nicht alle globalen Variablen
906 sind mit ihren Standwerten in diese Liste eingetragen. Daher kann @code{reset}
907 die Anfangswerte stets nur unvollst@"andig wiederherstellen.
909 @code{reset(@var{arg_1, ..., arg_n})} setzt die Variablen @var{arg_1}, @dots{},
910 @var{arg_n} auf ihren Standardwert zur@"uck.
912 @code{reset} gibt eine Liste mit den Variablen zur@"uck, die auf ihren
913 Standardwert zur@"uckgesetzt wurden. Ist die Liste leer, wurden keine Variablen
914 zur@"uckgesetzt.
916 Siehe auch @mrefdot{reset_verbosely}
917 @end deffn
919 @c --- 08.09.2010 DK -----------------------------------------------------------
920 @anchor{reset_verbosely}
921 @deffn {Funktion} reset_verbosely ()
922 @deffnx {Funktion} reset_verbosely (@var{arg_1}, @dots{}, @var{arg_n})
924 Entspricht der Funktion @code{reset}. Im Unterschied zu @code{reset} wird zu
925 jeder Variable, die zur@"uckgesetzt wird, zus@"atzlich der Standardwert
926 angezeigt.
928 Siehe @mrefdot{reset}
929 @end deffn
931 @c --- 23.10.2010 DK -----------------------------------------------------------
932 @anchor{showtime}
933 @defvr {Optionsvariable} showtime
934 Standardwert: @code{false}
936 Hat @code{showtime} den Wert @code{true}, werden die interne Rechenzeit und die
937 gesamte verstrichene Zeit zu jeder Ausgabe angezeigt.
939 Die Rechenzeit wird unabh@"angig vom Wert der Optionsvariablen @code{showtime}
940 nach jeder Auswertung eines Ausdruckes in den Ausgabemarken abgespeichert.
941 Daher k@"onnen die Funktionen @mref{time} und @mref{playback} die Rechenzeit
942 auch dann anzeigen, wenn @code{showtime} den Wert @code{false} hat.
944 Siehe auch @mrefdot{timer}
945 @end defvr
947 @c --- 08.09.2010 DK -----------------------------------------------------------
948 @anchor{to_lisp}
949 @deffn {Funktion} to_lisp ()
951 Wechselt zu einer Lisp-Sitzung. @code{(to-maxima)} wechselt von der
952 Lisp-Sitzung zur@"uck in die Maxima-Sitzung.
954 Beispiel:
956 Definiere eine Funktion und wechsle zu Lisp. Die Definition wird von der
957 Eigenschaftsliste gelesen. Dann wird die Definition der Funktion geholt,
958 faktorisiert und in der Variablen @code{$result} gespeichert. Die Variable
959 kann nach der R@"uckkehr in Maxima genutzt werden.
961 @example
962 (%i1) f(x):=x^2+x;
963 2
964 (%o1) f(x) := x + x
965 (%i2) to_lisp();
966 Type (to-maxima) to restart, ($quit) to quit Maxima.
967 MAXIMA> (symbol-plist '$f)
968 (MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X)
969 ((MPLUS) ((MEXPT) $X 2) $X))))
970 MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
971 ((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
972 MAXIMA> (to-maxima)
973 Returning to Maxima
974 (%o2) true
975 (%i3) result;
976 (%o3) x (x + 1)
977 @end example
978 @end deffn
980 @c --- 08.09.2010 DK -----------------------------------------------------------
981 @anchor{values}
982 @defvr {Systemvariable} values
983 Anfangswert: @code{[]}
985 @code{values} ist eine Informationsliste, die die Variablen enth@"alt, die vom
986 Nutzer mit den Operatoren @mref{:} oder @mref{::} einen Wert erhalten haben.
987 Wird der Wert einer Variablen mit den Kommandos @mrefcomma{kill}@w{}
988 @mref{remove} oder @mref{remvalue} entfernt, wird die Variable von der Liste
989 @code{values} entfernt.
991 Siehe auch @mref{functions} f@"ur die Informationsliste mit den vom Nutzer
992 definierten Funktionen sowie @mrefdot{infolists}
994 Beispiele:
996 @c TODO: DAS FOLGENDE IST NICHT UEBERSETZT.
998 @c First, @code{values} shows the symbols @code{a}, @code{b}, and @code{c}, but
999 @c not @code{d}, it is not bound to a value, and not the user function @code{f}.
1000 @c The values are removed from the variables. @code{values} is the empty list.
1002 @example
1003 (%i1) [a:99, b::a-90, c:a-b, d, f(x):= x^2];
1004 2
1005 (%o1) [99, 9, 90, d, f(x) := x ]
1006 (%i2) values;
1007 (%o2) [a, b, c]
1008 (%i3) [kill(a), remove(b,value), remvalue(c)];
1009 (%o3) [done, done, [c]]
1010 (%i4) values;
1011 (%o4) []
1012 @end example
1013 @end defvr
1015 @c -----------------------------------------------------------------------------
1016 @node Funktionen und Variablen der Ausgabe, , Funktionen und Variablen der Eingabe, Kommandozeile
1017 @section Funktionen und Variablen der Ausgabe
1018 @c -----------------------------------------------------------------------------
1020 @c --- 15.10.2010 DK -----------------------------------------------------------
1021 @anchor{%edispflag}
1022 @defvr {Optionsvariable} %edispflag
1023 Standardwert: @code{false}
1025 Hat @code{%edispflag} den Wert @code{true}, zeigt Maxima die Exponentiation von
1026 @mref{%e} mit einem negativen Exponenten als Quotienten an. Siehe auch die
1027 Optionsvariable @mrefdot{exptdispflag}
1029 Beispiel:
1031 @example
1032 (%i1) %e^-10;
1033 - 10
1034 (%o1) %e
1035 (%i2) %edispflag:true$
1036 (%i3) %e^-10;
1037 1
1038 (%o3) ----
1039 10
1040 %e
1041 @end example
1042 @end defvr
1044 @c --- 28.08.2010 --------------------------------------------------------------
1045 @anchor{absboxchar}
1046 @defvr {Optionsvariable} absboxchar
1047 Standardwert: @code{!}
1049 Die Optionsvariable @code{absboxchar} enth@"alt das Zeichen, das von Maxima
1050 benutzt wird, um den Betrag eines Ausdruckes anzuzeigen, der mehr als eine
1051 Zeile ben@"otigt.
1053 Beispiel:
1055 @example
1056 (%i1) abs((x^3+1));
1057 ! 3 !
1058 (%o1) !x + 1!
1059 @end example
1060 @end defvr
1062 @c --- 15.10.2010 DK -----------------------------------------------------------
1063 @anchor{disp}
1064 @deffn {Funktion} disp (@var{expr_1}, @var{expr_2}, @dots{})
1066 Ist @"ahnlich wie die Funktion @mrefdot{display} Die Funktion @code{disp}
1067 zeigt jedoch keine Gleichungen sondern nur die Ergebnisse der Ausdr@"ucke
1068 @var{expr_1}, @var{expr_2}, @dots{} an.
1070 Siehe auch die Funktionen @mrefcomma{ldisp} @mref{display} und @mrefdot{print}
1072 Beispiele:
1074 @example
1075 (%i1) b[1,2]:x-x^2$
1076 (%i2) x:123$
1077 (%i3) disp(x, b[1,2], sin(1.0));
1078 123
1080 2
1081 x - x
1083 .8414709848078965
1085 (%o3) done
1086 @end example
1087 @end deffn
1089 @c --- 23.10.2010 DK -----------------------------------------------------------
1090 @anchor{display}
1091 @deffn {Funktion} display (@var{expr_1}, @var{expr_2}, @dots{})
1093 Die Variablen oder Ausdr@"ucke @var{expr_i} werden als eine Gleichung
1094 ausgegeben. Die linke Seite der Gleichung ist die Variable oder der Ausdruck
1095 @var{expr_i} und die rechte Seite der Wert der Variablen oder das Ergebnis des
1096 Ausdrucks. Die Argumente k@"onnen Variable, indizierte Variable oder Funktionen
1097 sein.
1099 Siehe auch die Funktionen @mrefcomma{ldisplay} @mref{disp} und @mrefdot{ldisp}
1101 Beispiele:
1103 @example
1104 (%i1) b[1,2]:x-x^2$
1105 (%i2) x:123$
1106 (%i3) display(x, b[1,2], sin(1.0));
1107 x = 123
1109 2
1110 b = x - x
1111 1, 2
1113 sin(1.0) = .8414709848078965
1115 (%o3) done
1116 @end example
1117 @end deffn
1119 @c --- 10.08.2010 DK -----------------------------------------------------------
1120 @anchor{display2d}
1121 @defvr {Optionsvariable} display2d
1122 Standardwert: @code{true}
1124 Hat @code{display2d} den Wert @code{false}, werden Ausdr@"ucke auf der Konsole
1125 linear und nicht zweidimensional angezeigt.
1127 Siehe auch die Optionsvariable @mrefcomma{leftjust} um Formeln linksb@"undig
1128 auszugeben.
1130 Beispiel:
1132 @example
1133 (%i1) x/(x^2+1);
1134 x
1135 (%o1) ------
1136 2
1137 x + 1
1138 (%i2) display2d:false$
1139 (%i3) x/(x^2+1);
1140 (%o3) x/(x^2+1)
1141 @end example
1142 @end defvr
1144 @c --- 23.10.2010 DK -----------------------------------------------------------
1145 @anchor{display_format_internal}
1146 @defvr {Optionsvariable} display_format_internal
1147 Standardwert: @code{false}
1149 Hat @code{display_format_internal} den Wert @code{true}, werden Ausdr@"ucke
1150 f@"ur die Anzeige nicht in die externe Darstellung transformiert. Die Ausgabe
1151 erfolgt wie in der internen Darstellung. Das entspricht der R@"uckgabe der
1152 Funktion @mrefdot{inpart}
1154 Siehe die Funktion @mref{dispform} f@"ur Beispiele, die den Unterschied zwischen
1155 der internen und der externen Darstellung zeigen.
1156 @end defvr
1158 @c --- 23.10.2010 --------------------------------------------------------------
1159 @anchor{dispterms}
1160 @deffn {Funktion} dispterms (@var{expr})
1162 Der Ausdruck @var{expr} wird zeilenweise ausgegeben. Auf der ersten Zeile wird
1163 der Operator des Ausdrucks @var{expr} ausgegeben. Dann werden die Argumente des
1164 Operators zeilenweise ausgegeben. Dies kann n@"utzlich sein, wenn ein Ausdruck
1165 sehr lang ist.
1167 Beispiel:
1169 @example
1170 (%i1) dispterms(2*a*sin(x)+%e^x);
1172 +
1174 2 a sin(x)
1176 x
1177 %e
1179 (%o1) done
1180 @end example
1181 @end deffn
1183 @c --- 23.10.2010 --------------------------------------------------------------
1184 @anchor{expt}
1185 @anchor{ncexpt}
1186 @defvr {Spezielles Symbol} expt (@var{a}, @var{b})
1187 @defvrx {Spezielles Symbol} ncexpt (@var{a}, @var{b})
1189 Ist ein Exponentialausdruck zu lang, um ihn als @code{@var{a}^@var{b}}
1190 anzuzeigen, wird stattdessen @code{expt(@var{a}, @var{b})} angezeigt.
1191 Entsprechend wird statt @code{@var{a}^^@var{b}}, @code{ncexpt(@var{a}, @var{b})}
1192 angezeigt. @code{expt} und @code{ncexpt} sind keine Funktionen und erscheinen
1193 nur in der Ausgabe.
1194 @end defvr
1196 @c --- 21.08.2010 --------------------------------------------------------------
1197 @anchor{exptdispflag}
1198 @defvr {Optionsvariable} exptdispflag
1199 Standardwert: @code{true}
1201 Hat die Optionsvariable @code{exptdispflag} den Wert @code{true}, werden
1202 Ausdr@"ucke mit einem negativen Exponenten als Quotient angezeigt. Siehe auch
1203 die Optionsvariable @mrefdot{%edispflag}
1205 Beispiele:
1207 @example
1208 (%i1) exptdispflag:true;
1209 (%o1) true
1210 (%i2) 10^-x;
1211 1
1212 (%o2) ---
1213 x
1214 10
1215 (%i3) exptdispflag:false;
1216 (%o3) false
1217 (%i4) 10^-x;
1218 - x
1219 (%o4) 10
1220 @end example
1221 @end defvr
1223 @c --- 28.08.2010 DK -----------------------------------------------------------
1224 @anchor{grind}
1225 @deffn {Funktion} grind (@var{expr})
1226 @deffnx {Optionsvariable} grind
1228 Die Funktion @code{grind} gibt den Ausdruck @var{expr} auf der Konsole in einer
1229 Form aus, die f@"ur die Eingabe in Maxima geeignet ist. @code{grind} gibt
1230 @code{done} zur@"uck.
1232 Ist @var{expr} der Name einer Funktion oder eines Makros, gibt @code{grind}
1233 die Definition der Funktion oder des Makros aus.
1235 Siehe auch die Funktion @mrefcomma{string} die einen Ausdruck als eine
1236 Zeichenkette zur@"uckgibt.
1238 Hat die Optionsvariable @code{grind} den Wert @code{true}, haben die Ergebnisse
1239 der Funktionen @mref{stringout} und @code{string} dasselbe Format wie die
1240 Funktion @code{grind}. Ansonsten werden keine spezielle Formatierungen
1241 von diesen Funktionen vorgenommen. Der Standardwert der Optionsvariablen
1242 @code{grind} ist @code{false}.
1244 @code{grind} kann auch ein Argument der Funktion @mref{playback} sein. In
1245 diesem Fall gibt @code{playback} die Eingabe im gleichen Format wie die Funktion
1246 @code{grind} aus.
1248 @code{grind} wertet das Argument aus.
1250 Beispiele:
1252 @example
1253 (%i1) aa + 1729;
1254 (%o1) aa + 1729
1255 (%i2) grind (%);
1256 aa+1729$
1257 (%o2) done
1258 (%i3) [aa, 1729, aa + 1729];
1259 (%o3) [aa, 1729, aa + 1729]
1260 (%i4) grind (%);
1261 [aa,1729,aa+1729]$
1262 (%o4) done
1263 (%i5) matrix ([aa, 17], [29, bb]);
1264 [ aa 17 ]
1265 (%o5) [ ]
1266 [ 29 bb ]
1267 (%i6) grind (%);
1268 matrix([aa,17],[29,bb])$
1269 (%o6) done
1270 (%i7) set (aa, 17, 29, bb);
1271 (%o7) @{17, 29, aa, bb@}
1272 (%i8) grind (%);
1273 @{17,29,aa,bb@}$
1274 (%o8) done
1275 (%i9) exp (aa / (bb + 17)^29);
1276 @group
1277 aa
1278 -----------
1279 29
1280 (bb + 17)
1281 (%o9) %e
1282 @end group
1283 (%i10) grind (%);
1284 %e^(aa/(bb+17)^29)$
1285 (%o10) done
1286 (%i11) expr: expand ((aa + bb)^10);
1287 @group
1288 10 9 2 8 3 7 4 6
1289 (%o11) bb + 10 aa bb + 45 aa bb + 120 aa bb + 210 aa bb
1290 5 5 6 4 7 3 8 2
1291 + 252 aa bb + 210 aa bb + 120 aa bb + 45 aa bb
1292 9 10
1293 + 10 aa bb + aa
1294 @end group
1295 (%i12) grind (expr);
1296 @group
1297 bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
1298 +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
1299 +10*aa^9*bb+aa^10$
1300 (%o12) done
1301 @end group
1302 (%i13) string (expr);
1303 (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
1304 +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
1305 bb+aa^10
1306 @end example
1307 @end deffn
1309 @c --- 28.08.2010 DK -----------------------------------------------------------
1310 @anchor{ibase}
1311 @defvr {Optionsvariable} ibase
1312 Standardwert: @code{10}
1314 @code{ibase} enth@"alt die Basis der ganzen Zahlen, welche von Maxima eingelesen
1315 werden.
1317 @code{ibase} kann eine ganze Zahl zwischen 2 und einschlie@ss{}lich 36
1318 zugewiesen werden. Ist @code{ibase} gr@"o@ss{}er als 10, werden die Zahlen 0
1319 bis 9 und die Buchstaben A, B, C, @dots{} f@"ur die Darstellung der Zahl in der
1320 Basis @code{ibase} herangezogen. Gro@ss{}e und kleine Buchstaben werden nicht
1321 unterschieden. Die erste Stelle muss immer eine Ziffer sein, damit Maxima den
1322 eingelesenen Ausdruck als eine Zahl interpretiert.
1324 Gleitkommazahlen werden immer zur Basis 10 interpretiert.
1326 Siehe auch @mrefdot{obase}
1328 Beispiele:
1330 @code{ibase} ist kleiner als 10.
1332 @example
1333 (%i1) ibase : 2 $
1334 (%i2) obase;
1335 (%o2) 10
1336 (%i3) 1111111111111111;
1337 (%o3) 65535
1338 @end example
1340 @code{ibase} ist gr@"o@ss{}er als 10. Die erste Stelle muss eine Ziffer sein.
1342 @example
1343 (%i1) ibase : 16 $
1344 (%i2) obase;
1345 (%o2) 10
1346 (%i3) 1000;
1347 (%o3) 4096
1348 (%i4) abcd;
1349 (%o4) abcd
1350 (%i5) symbolp (abcd);
1351 (%o5) true
1352 (%i6) 0abcd;
1353 (%o6) 43981
1354 (%i7) symbolp (0abcd);
1355 (%o7) false
1356 @end example
1358 Wird eine ganze Zahl mit einem Dezimalpunkt beendet, wird die Zahl als
1359 Gleitkommazahl interpretiert.
1361 @example
1362 (%i1) ibase : 36 $
1363 (%i2) obase;
1364 (%o2) 10
1365 (%i3) 1234;
1366 (%o3) 49360
1367 (%i4) 1234.;
1368 (%o4) 1234
1369 @end example
1370 @end defvr
1372 @c --- 23.10.2010 --------------------------------------------------------------
1373 @anchor{ldisp}
1374 @deffn {Funktion} ldisp (@var{expr_1}, @dots{}, @var{expr_n})
1376 Die Ausdr@"ucke @var{expr_1}, @dots{}, @var{expr_n} werden auf der Konsole
1377 ausgegeben. Dabei wird jedem Ausdruck eine Zwischenmarke zugewiesen. Die Liste
1378 der Zwischenmarken wird als Ergebnis zur@"uckgegeben.
1380 Siehe auch die Funktionen @mrefcomma{disp} @mref{display} und @mrefdot{ldisplay}
1382 @example
1383 @group
1384 (%i1) e: (a+b)^3;
1385 3
1386 (%o1) (b + a)
1387 @end group
1388 (%i2) f: expand (e);
1389 3 2 2 3
1390 (%o2) b + 3 a b + 3 a b + a
1391 (%i3) ldisp (e, f);
1392 3
1393 (%t3) (b + a)
1395 3 2 2 3
1396 (%t4) b + 3 a b + 3 a b + a
1398 (%o4) [%t3, %t4]
1399 (%i4) %t3;
1400 3
1401 (%o4) (b + a)
1402 (%i5) %t4;
1403 3 2 2 3
1404 (%o5) b + 3 a b + 3 a b + a
1405 @end example
1406 @end deffn
1408 @c --- 23.10.2010 --------------------------------------------------------------
1409 @anchor{ldisplay}
1410 @deffn {Funktion} ldisplay (@var{expr_1}, @dots{}, @var{expr_n})
1412 Die Ausdr@"ucke @var{expr_1}, @dots{}, @var{expr_n} werden als eine Gleichung
1413 der Form @code{lhs = rhs} ausgegeben. @code{lhs} ist eines der Argumente der
1414 Funktion @code{ldisplay} und @code{rhs} ist der Wert oder das Ergebnis des
1415 Argumentes. Im Unterschied zur Funktion @code{display} wird jeder Gleichung
1416 eine Zwischenmarke zugewiesen, die als Liste zur@"uckgegeben werden.
1418 Siehe auch @mrefcomma{display} @mref{disp} und @mrefdot{ldisp}
1420 Beispiele:
1422 @example
1423 (%i1) e: (a+b)^3;
1424 3
1425 (%o1) (b + a)
1426 (%i2) f: expand (e);
1427 3 2 2 3
1428 (%o2) b + 3 a b + 3 a b + a
1429 (%i3) ldisplay (e, f);
1430 3
1431 (%t3) e = (b + a)
1433 3 2 2 3
1434 (%t4) f = b + 3 a b + 3 a b + a
1436 (%o4) [%t3, %t4]
1437 (%i4) %t3;
1438 3
1439 (%o4) e = (b + a)
1440 (%i5) %t4;
1441 3 2 2 3
1442 (%o5) f = b + 3 a b + 3 a b + a
1443 @end example
1444 @end deffn
1446 @c --- 10.08.2011 DK -----------------------------------------------------------
1447 @anchor{leftjust}
1448 @defvr {Optionsvariable} leftjust
1449 Standardwert: @code{false}
1451 Hat die Optionsvariable @code{leftjust} den Wert @code{true}, werden Formeln
1452 linksb@"undig und nicht zentriert ausgegeben.
1454 Siehe auch die Optionsvariable @mrefcomma{display2d} um zwischen der
1455 1D- und 2D-Anzeige umzuschalten.
1457 Beispiel:
1459 @example
1460 (%i1) expand((x+1)^3);
1461 3 2
1462 (%o1) x + 3 x + 3 x + 1
1463 (%i2) leftjust:true$
1464 (%i3) expand((x+1)^3);
1465 3 2
1466 (%o3) x + 3 x + 3 x + 1
1467 @end example
1468 @end defvr
1470 @c --- 23.10.2010 --------------------------------------------------------------
1471 @need 800
1472 @anchor{linel}
1473 @defvr {Optionsvariable} linel
1474 Standardwert: @code{79}
1476 Die Optionsvariable @code{linel} enth@"alt die Anzahl der Zeichen einer Zeile
1477 der Ausgabe. @code{linel} k@"onnen beliebige positive ganze Zahlen zugewiesen
1478 werden, wobei sehr kleine oder gro@ss{}e Werte unpraktisch sein k@"onnen. Text,
1479 der von internen Funktionen ausgegeben wird, wie Fehlermeldungen oder Ausgaben
1480 der Hilfe, werden von @code{linel} nicht beeinflusst.
1481 @end defvr
1483 @c --- 21.08.2010 --------------------------------------------------------------
1484 @anchor{lispdisp}
1485 @defvr {Optionsvariable} lispdisp
1486 Standardwert: @code{false}
1488 Hat die Optionsvariable @code{lispdisp} den Wert @code{true}, werden
1489 Lisp-Symbole mit einem vorangestelltem Fragezeichen @code{?} angezeigt.
1491 Beispiele:
1493 @example
1494 (%i1) lispdisp: false$
1495 (%i2) ?foo + ?bar;
1496 (%o2) foo + bar
1497 (%i3) lispdisp: true$
1498 (%i4) ?foo + ?bar;
1499 (%o4) ?foo + ?bar
1500 @end example
1501 @end defvr
1503 @c --- 23.10.2010 --------------------------------------------------------------
1504 @anchor{negsumdispflag}
1505 @defvr {Optionsvariable} negsumdispflag
1506 Standardwert: @code{true}
1508 Hat @code{negsumdispflag} den Wert @code{true}, wird eine Differenz mit zwei
1509 Argumenten @code{x - y} als @code{x - y} und nicht als @code{-y + x} angezeigt.
1510 Hat @code{negsumdispflag} den Wert @code{false}, wird die Differenz als
1511 @code{-y + x} angezeigt.
1512 @end defvr
1514 @c --- 28.08.2010 DK -----------------------------------------------------------
1515 @anchor{obase}
1516 @need 800
1517 @defvr {Optionsvariable} obase
1518 Standardwert: @code{10}
1520 @code{obase} enth@"alt die Basis f@"ur ganze Zahlen f@"ur die Ausgabe von
1521 Maxima. @code{obase} kann eine ganze Zahl zwischen 2 und einschlie@ss{}lich 36
1522 zugewiesen werden. Ist @code{obase} gr@"o@ss{}er als 10, werden die Zahlen 0
1523 bis 9 und die Buchstaben A, B, C, @dots{} f@"ur die Darstellung der Zahl in der
1524 Basis @code{obase} herangezogen. Gro@ss{}e und kleine Buchstaben werden nicht
1525 unterschieden. Die erste Stelle ist immer eine Ziffer.
1527 Siehe auch @mrefdot{ibase}
1529 Beispiele:
1531 @example
1532 (%i1) obase : 2;
1533 (%o1) 10
1534 (%i2) 2^8 - 1;
1535 (%o10) 11111111
1536 (%i3) obase : 8;
1537 (%o3) 10
1538 (%i4) 8^8 - 1;
1539 (%o4) 77777777
1540 (%i5) obase : 16;
1541 (%o5) 10
1542 (%i6) 16^8 - 1;
1543 (%o6) 0FFFFFFFF
1544 (%i7) obase : 36;
1545 (%o7) 10
1546 (%i8) 36^8 - 1;
1547 (%o8) 0ZZZZZZZZ
1548 @end example
1549 @end defvr
1551 @c --- 21.08.2010 --------------------------------------------------------------
1552 @anchor{pfeformat}
1553 @defvr {Optionsvariable} pfeformat
1554 Standardwert: @code{false}
1556 Hat die Optionsvariable @code{pfeformat} den Wert @code{true}, werden Br@"uche
1557 mit ganzen Zahlen auf einer Zeile mit dem Zeichen @code{/} dargestellt. Ist
1558 der Nenner eine ganze Zahl, wird dieser als @code{1/n} vor den Ausdruck
1559 gestellt.
1561 Beispiele:
1563 @example
1564 (%i1) pfeformat: false$
1565 (%i2) 2^16/7^3;
1566 65536
1567 (%o2) -----
1568 343
1569 (%i3) (a+b)/8;
1570 b + a
1571 (%o3) -----
1572 8
1573 (%i4) pfeformat: true$
1574 (%i5) 2^16/7^3;
1575 (%o5) 65536/343
1576 (%i6) (a+b)/8;
1577 (%o6) 1/8 (b + a)
1578 @end example
1579 @end defvr
1581 @c --- 27.01.2011 DK -----------------------------------------------------------
1582 @anchor{powerdisp}
1583 @defvr {Optionsvariable} powerdisp
1584 Standardwert: @code{false}
1586 Hat @code{powerdisp} den Wert @code{true}, werden die Terme einer Summe mit
1587 steigender Potenz angezeigt. Der Standardwert ist @code{false} und die Terme
1588 werden mit fallender Potenz angezeigt.
1590 Beispiele:
1592 @example
1593 (%i1) powerdisp:true;
1594 (%o1) true
1595 (%i2) x^2+x^3+x^4;
1596 2 3 4
1597 (%o2) x + x + x
1598 (%i3) powerdisp:false;
1599 (%o3) false
1600 (%i4) x^2+x^3+x^4;
1601 4 3 2
1602 (%o4) x + x + x
1603 @end example
1604 @end defvr
1606 @c --- 23.10.2010 DK -----------------------------------------------------------
1607 @anchor{print}
1608 @deffn {Funktion} print (@var{expr_1}, @dots{}, @var{expr_n})
1610 Wertet die Argumente @var{expr_1}, @dots{}, @var{expr_n} nacheinander von links
1611 nach rechts aus und zeigt die Ergebnisse an. @code{print} gibt das Ergebnis des
1612 letzten Arguments als Ergebnis zur@"uck. @code{print} erzeugt keine
1613 Zwischenmarken.
1615 Siehe auch @mrefcomma{display} @mrefcomma{disp} @mref{ldisplay} und
1616 @mrefdot{ldisp} Siehe @mrefcomma{printfile} um den Inhalt einer Datei
1617 anzuzeigen.
1619 Beispiele:
1621 @example
1622 (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
1623 radcan (log (a^10/b)))$
1624 3 2 2 3
1625 (a+b)^3 is b + 3 a b + 3 a b + a log (a^10/b) is
1627 10 log(a) - log(b)
1628 (%i2) r;
1629 (%o2) 10 log(a) - log(b)
1630 (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
1631 radcan (log (a^10/b)))$
1632 (a+b)^3 is
1633 @group
1635 3 2 2 3
1636 b + 3 a b + 3 a b + a
1637 @end group
1639 log (a^10/b) is
1641 10 log(a) - log(b)
1642 @end example
1643 @end deffn
1645 @c --- 21.08.2010 --------------------------------------------------------------
1646 @anchor{sqrtdispflag}
1647 @defvr {Optionsvariable} sqrtdispflag
1648 Standardwert: @code{true}
1650 Hat die Optionsvariable den Wert @code{false}, wird die Wurzelfunktion als
1651 Exponentiation mit dem Exponenten @code{1/2} angezeigt.
1652 @end defvr
1654 @c --- 21.08.2010 --------------------------------------------------------------
1655 @anchor{stardisp}
1656 @defvr {Optionsvariable} stardisp
1657 Standardwert: @code{false}
1659 Hat die Optionsvariable @code{stardisp} den Wert @code{true}, wird die
1660 Multiplikation mit einem Stern @code{*} angezeigt.
1661 @end defvr
1663 @c --- 21.08.2010 --------------------------------------------------------------
1664 @anchor{ttyoff}
1665 @defvr {Optionsvariable} ttyoff
1666 Standardwert: @code{false}
1668 Hat die Optionsvariable @code{ttyoff} den Wert @code{true}, werden Ergebnisse
1669 nicht angezeigt. Die Ergebnisse werden weiter berechnet und sie werden
1670 Marken zugewiesen. Siehe @mrefdot{labels}
1672 Textausgaben von Funktionen, wie Fehlermeldungen und Ausgaben der Hilfe mit
1673 @mref{describe} werden nicht beeinflusst.
1674 @end defvr
1676 @c --- Ende Command.de.texi ----------------------------------------------------