Next: Funktionen und Variablen der Ausgabe, Previous: Einführung in die Kommandozeile, Up: Kommandozeile [Contents][Index]

### 4.2 Funktionen und Variablen der Eingabe

Operator: ;

  Mit dem Semikolon `;` wird die Eingabe eines Maxima-Ausdrucks auf der Konsole und in einer Datei abgeschlossen. Es können mehrere Ausdrücke mit einem Semikolon als Abschluss auf einer Zeile eingegeben werden. Siehe auch `$`.

  Beispiele:

      (%i1) a:10;
      (%o1)                          10
      (%i2) a+b;
      (%o2)                        b + 10
      (%i3) x:10; x+y;
      (%o3)                          10
      (%o4)                        y + 10

Operator: $

  Das Dollarzeichen schließt wie das Semikolon die Eingabe eines Ausdruckes auf der Konsole und in einer Datei ab. Im Unterschied zum Semikolon wird die Ausgabe des Ergebnisses unterdrückt. Das Ergebnis wird jedoch weiterhin einer Ausgabemarke `%o` zugewiesen und die Systemvariable `%` enthält das Ergebnis. Siehe auch `;`.

  Beispiele:

      (%i1) expand((a+b)^2)$

      (%i2) %;
                                2            2
      (%o2)                    b  + 2 a b + a
      (%i3) a:10$ a+b$

      (%i5) %o3;
      (%o5)                          10
      (%i6) %o4;
      (%o6)                        b + 10

Systemvariable: __

  Während einer laufenden Auswertung enthält die Systemvariable `__` den zuletzt vom Parser eingelesenen Ausdruck expr. Der Ausdruck expr wird der Systemvariablen `__` vor der Auswertung und Vereinfachung zugewiesen.

  Die Systemvariable `__` wird von den Funktionen `batch` und `load` erkannt. Wird eine Datei mit der Funktion `batch` ausgeführt, hat `__` dieselbe Bedeutung wie bei der Eingabe in einer Kommandozeile. Wird eine Datei mit dem Namen `filename` mit der Funktion `load` geladen, enthält `__` den Ausdruck `load(filename)`. Das ist die letzte Eingabe in der Kommandozeile.

  Siehe auch die Systemvariablen `_` und `%`.

  Beispiele:

      (%i1) print ("I was called as: ", __)$
      I was called as:  print(I was called as, __)

      (%i2) foo (__);
      (%o2)                     foo(foo(__))

      (%i3) g (x) := (print ("Current input expression =", __), 0)$
      (%i4) [aa : 1, bb : 2, cc : 3]$
      (%i5) (aa + bb + cc)/(dd + ee + g(x))$

                                  cc + bb + aa
      Current input expression = --------------
                                 g(x) + ee + dd

Systemvariable: _

  Die Systemvariable `_` enthält den zuletzt eingegebenen Ausdruck expr. Der Ausdruck expr wird der Systemvariablen `_` vor der Auswertung und Vereinfachung zugewiesen.

  Die Systemvariable `_` wird von den Funktionen `batch` und `load` erkannt. Wird eine Datei mit der Funktion `batch` ausgeführt, hat `_` dieselbe Bedeutung wie bei der Eingabe in einer Kommandozeile. Wird eine Datei mit der Funktion `load` geladen, enthält `_` das zuletzt in der Kommandozeile eingegebene Kommando.

  Siehe auch die Systemvariablen `__` und `%`.

  Beispiele:

  Die Funktion `cabs` wird ausgewertet und nicht vereinfacht. Das Beispiel zeigt, dass die Systemvariable `_` den zuletzt eingelesenen Ausdruck vor der Auswertung enthält.

      (%i1) cabs(1+%i);
      (%o1)                        sqrt(2)
      (%i2) _;
      (%o2)                     cabs(%i + 1)

  Die Funktion `abs` vereinfacht einen Ausdruck. Wird der Inhalt der Systemvariablen `_` ausgegeben, wird das für die Ausgabe vereinfachte Ergebnis angezeigt. Mit der Funktion `string` wird der Inhalt der Systemvariablen `_` vor der Ausgabe in ein Zeichenkette umgewandelt, um den nicht vereinfachten Wert sichtbar zu machen.

      (%i3) abs(1+%i);
      (%o3)                        sqrt(2)
      (%i4) _;
      (%o4)                        sqrt(2)
      (%i5) abs(1+%i);
      (%o5)                        sqrt(2)
      (%i6) string(_);
      (%o6)                       abs(1+%i)

Systemvariable: %

  Die Systemvariable `%` enthält das Ergebnis des zuletzt von Maxima ausgewerteten und vereinfachten Ausdrucks. `%` enhält das letzte Ergebnis auch dann, wenn die Ausgabe des Ergebnisses durch Abschluss der Eingabe mit einem Dollarzeichen `$` unterdrückt wurde.

  Die Systemvariable `%` wird von den Funktionen `batch` und `load` erkannt. Wird eine Datei mit der Funktion `batch` ausgeführt, hat `%` dieselbe Bedeutung wie bei der Eingabe in einer Kommandozeile. Wird eine Datei mit der Funktion `load` geladen, enthält `%` das letzte Ergebnis des Ausdrucks, der auf der Konsole eingegeben wurde.

  Siehe auch die Systemvariablen `_`, `__` und `%th`.

Systemvariable: %%

  In zusammengesetzten Ausdrücken, wie in Ausdrücken mit `block` oder `lambda` oder in Ausdrücken der Gestalt `(s_1, ..., s_n)`, enthält die Systemvariable `%%` das Ergebnis des vorhergehenden Ausdrucks. Für den ersten Ausdruck oder außerhalb eines zusammengesetzten Ausdrucks ist `%%` nicht definiert.

  Die Systemvariable `%%` wird von `batch` und `load` erkannt und hat dieselbe Bedeutung wie bei der Eingabe in der Konsole. Siehe auch die Systemvariable `%` und die Funktion `%th`.

  Beispiele:

  Auf die im ersten Ausdruck berechnete Stammfunktion wird im zweiten Ausdruck mit `%%` Bezug genommen, um das Integral an der oberen und unteren Grenze auszuwerten.

      (%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
                                     21
      (%o1)                          --
                                     2

  Ein zusammengesetzter Ausdruck kann weitere zusammengesetzte Ausdrücke enthalten. `%%` enthält dabei jeweils das Ergebnis des letzten Ausdrucks. Das folgende Beispiel hat das Ergebnis `7*a^n`.

      (%i3) block (block (a^n, %%*42), %%/6);
                                       n
      (%o3)                         7 a

  Der Wert der Systemvariablen `%%` kann nach einer Unterbrechung mit dem Kommando `break` inspiziert werden. In diesem Beispiel hat die Systemvariable `%%` den Wert 42.

      (%i4) block (a: 42, break ())$
      Entering a Maxima break point. Type 'exit;' to resume.
      _%%;
      42
      _

Funktion: %th (n)

  Die Funktion `%th` liefert das n-te vorhergehende Ergebnis. Dies ist dann nützlich, wenn wie in Batch-Dateien die absolute Zeilennummer der letzten Ausgabemarken nicht bekannt ist.

  Die Funktion `%th` wird von den Funktionen `batch` und `load` erkannt. Wird eine Datei mit `batch` ausgeführt, hat `%th` dieselbe Bedeutung wie bei der Eingabe in der Konsole. Wird eine Datei mit der Funktion `load` geladen, enthält `%th` das letzte Ergebnis der Eingabe in der Konsole.

  Siehe auch `%` und `%%`.

  Beispiel:

  Das Beispiel zeigt, wie die letzten 5 eingegebenen Werte mit der Funktion `%th` aufsummiert werden.

      (%i1) 1;2;3;4;5;
      (%o1)                           1
      (%o2)                           2
      (%o3)                           3
      (%o4)                           4
      (%o5)                           5
      (%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
      (%o6)                          15

Spezielles Symbol: ?

  Wird dem Namen einer Funktion oder Variablen ein `?` als Präfix vorangestellt, wird der Name als ein Lisp-Symbol interpretiert. Zum Beispiel bedeutet `?round` die Lisp-Funktion `ROUND`. Siehe Lisp und Maxima für weitere Ausführungen zu diesem Thema.

  Die Eingabe `? word` ist eine Kurzschreibweise für das Kommando `describe("word")`. Das Fragezeichen muss am Anfang einer Eingabezeile stehen, damit Maxima die Eingabe als eine Anfrage nach der Dokumentation interpretiert. Siehe auch `describe`.

Spezielles Symbol: ??

  Die Eingabe `?? word` ist eine Kurzschreibweise für das Kommando `describe("word", inexact)`. Die Fragezeichen müssen am Anfang einer Eingabezeile stehen, damit Maxima die Eingabe als eine Anfrage nach der Dokumentation interpretiert. Siehe auch `describe`.

Optionsvariable: inchar

  Standardwert: `%i`

  Die Optionsvariable `inchar` enthält den Präfix der Eingabemarken. Maxima erzeugt die Eingabemarken automatisch aus dem Präfix `inchar` und der Zeilennummer `linenum`.

  Der Optionsvariablen `inchar` kann eine Zeichenkette oder ein Symbol zugewiesen werden, die auch mehr als ein Zeichen haben können. Da Maxima intern nur das erste Zeichen berücksichtigt, sollten sich die Präfixe `inchar`, `outchar` und `linechar` im ersten Zeichen voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie zum Beispiel `kill(inlabels)` nicht wie erwartet.

  Siehe auch die Funktion und Systemvariable `labels` sowie die Optionsvariablen `outchar` und `linechar`.

  Beispiele:

      (%i1) inchar: "input";
      (%o1)                         input
      (input2) expand((a+b)^3);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (input3)

Systemvariable: infolists

  Die Systemvariable `infolists` enthält eine Liste der Informationslisten, die Maxima zur Verfügung stellt. Diese sind:

  `labels`

    Enthält die Marken `%i`, `%o` und `%t`, denen bisher ein Ausdruck zugewiesen wurde.

  `values`

    Enthält die vom Nutzer mit den Operatoren `:` oder `::` definierten Variablen.

  `functions`

    Enthält die vom Nutzer mit dem Operator `:=` oder der Funktion `define` definierten Funktionen.

  `arrays`

    Enthält die mit den Operatoren `:`, `::` oder `:=` definierten Arrays oder Array-Funktionen.

  `macros`

    Enthält die vom Nutzer mit dem Operator `::=` definierten Makros.

  `myoptions`

    Enthält die Optionsvariablen, die vom Nutzer bisher einen neuen Wert erhalten haben.

  `rules`

    Enthält die vom Nutzer mit den Funktionen `tellsimp`, `tellsimpafter`, `defmatch` oder `defrule` definierten Regeln.

  `aliases`

    Enthält die Symbole, die einen vom Nutzer definierten Alias-Namen mit der Funktion `alias` erhalten haben. Weiterhin erzeugen die Funktionen `ordergreat` und `orderless` sowie eine Deklaration als `noun` mit der Funktion `declare` Alias-Namen, die in die Liste eingetragen werden.

  `dependencies`

    Enthält alle Symbole, für die mit den Funktionen `depends` oder `gradef` eine Abhängigkeit definiert ist.

  `gradefs`

    Enthält die Funktionen, für die der Nutzer mit der Funktion `gradef` eine Ableitung definiert hat.

  `props`

    Enthält die Symbole, die eine Eigenschaft mit der Funktion `declare` erhalten haben.

  `let_rule_packages`

    Enthält die vom Nutzer definierten `let`-Regeln.

Funktion: kill (a_1, …, a_n)
Funktion: kill (labels)
Funktion: kill (inlabels, outlabels, linelabels)
Funktion: kill (n)
Funktion: kill ([m, n])
Funktion: kill (values, functions, arrays, …)
Funktion: kill (all)
Funktion: kill (allbut (a_1, …, a_n))

  Die Funktion `kill` entfernt alle Zuweisungen (Werte, Funktionen, Arrays oder Regeln) und Eigenschaften von den Argumenten a_1, …, a_n. Ein Argument a_k kann ein Symbol oder ein einzelnes Array-Element sein. Ist a_k ein einzelnes Array-Element, entfernt `kill` die Zuweisungen an dieses Element, ohne die anderen Elemente des Arrays zu beeinflussen.

  `kill` kennt verschiedene spezielle Argumente, die auch kombiniert werden können wie zum Beispiel `kill(inlabels, functions, allbut(foo, bar))`.

  `kill(labels)` entfernt alle Zuweisungen an Eingabe-, Ausgabe- und Zwischenmarken. `kill(inlabels)` entfernt nur die Zuweisungen an Eingabemarken, die mit dem aktuellen Wert von `inchar` beginnen. Entsprechend entfernt `kill(outlabels)` die Zuweisungen an die Ausgabemarken, die mit dem aktuellen Wert von `outchar` beginnen und `kill(linelabels)` die Zuweisungen an die Zwischenmarken, die mit dem aktuellen Wert von `linechar` beginnen.

  `kill(n)`, wobei n eine ganze Zahl ist, entfernt die Zuweisungen an die n letzten Eingabe- und Ausgabemarken. `kill([m, n])` entfernt die Zuweisungen an die Eingabe- und Ausgabemarken mit den Nummern von m bis n.

  `kill(infolist)`, wobei infolist eine Informationsliste wie zum Beispiel `values`, `functions` oder `arrays` ist, entfernt die Zuweisungen an allen Einträgen der Liste infolist. Siehe auch `infolists`.

  `kill(all)` entfernt die Zuweisungen an die Einträge in sämtlichen Informationslisten. `kill(all)` setzt keine Optionsvariablen auf ihre Standardwerte zurück. Siehe die Funktion `reset`, um Optionsvariablen auf ihre Standwerte zurückzusetzen.

  `kill(allbut(a_1, ..., a_n))` entfernt alle Zuweisungen bis auf Zuweisungen an die Variablen a_1, …, a_n. `kill(allbut(infolist))` entfernt alle Zuweisungen bis auf denen in der Informationsliste infolist.

  `kill(symbol)` entfernt sämtliche Zuweisungen und Eigenschaften des Symbols symbol. Im Gegensatz dazu entfernen `remvalue`, `remfunction`, `remarray` und `remrule` jeweils eine spezielle Eigenschaft eines Symbols.

  `kill` wertet die Argumente nicht aus. Der Quote-Quote-Operator `''` kann die Auswertung erzwingen. `kill` gibt immer `done` zurück.

Funktion: labels (symbol)
Systemvariable: labels

  Die Funktion `labels` gibt eine Liste der Eingabe-, Ausgabe- und Zwischenmarken zurück, die mit dem Argument symbol beginnen. Typischerweise ist symbol der Wert von `inchar`, `outchar` oder `linechar`. Dabei kann das Prozentzeichen fortgelassen werden. So haben zum Beispiel die Kommandos `labels(i)` und `labels(%i)` dasselbe Ergebnis.

  Wenn keine Marke mit symbol beginnt, gibt `labels` eine leere Liste zurück.

  Die Funktion `labels` wertet das Argument nicht aus. Mit dem Quote-Quote-Operator `''` kann die Auswertung erzwungen werden. Zum Beispiel gibt das Kommando `labels(''inchar)` die Marken zurück, die mit dem aktuellen Buchstaben für die Eingabemarken beginnen.

  Die Systemvariable `labels` ist eine Informationsliste, die die Eingabe-, Ausgabe- und Zwischenmarken enthält. In der Liste sind auch die Marken enthalten, die vor einer Änderung von `inchar`, `outchar` oder `linechar` erzeugt wurden.

  Standardmäßig zeigt Maxima das Ergebnis jeder Eingabe an, wobei dem Ergebnis eine Ausgabemarke hinzugefügt wird. Die Anzeige der Ausgabe wird durch die Eingabe eines abschließenden `$` (Dollarzeichen) statt eines `;` (Semikolon) unterdrückt. Dabei wird eine Ausgabemarke erzeugt und das Ergebnis zugewiesen, jedoch nicht angezeigt. Die Marke kann aber in der gleichen Art und Weise wie bei angezeigten Ausgabemarken referenziert werden. Siehe auch `%`, `%%` und `%th`.

  Einige Funktionen erzeugen Zwischenmarken. Die Optionsvariable `programmode` kontrolliert, ob zum Beispiel `solve` und einige andere Funktionen Zwischenmarken erzeugen, anstatt eine Liste von Ausdrücken zurückzugeben. Andere Funktionen wie zum Beispiel `ldisplay` erzeugen stets Zwischenmarken.

  Siehe auch `infolists`.

Optionsvariable: linechar

  Standardwert: `%t`

  Die Optionsvariable `linechar` enthält den Präfix der Zwischenmarken. Maxima generiert die Zwischenmarken automatisch aus `linechar`.

  Der Optionsvariablen `linechar` kann eine Zeichenkette oder ein Symbol zugewiesen werden, die auch mehr als ein Zeichen haben können. Da Maxima intern nur das erste Zeichen berücksichtigt, sollten sich die Präfixe `inchar`, `outchar` und `linechar` im ersten Zeichen voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie `kill(inlabels)` nicht wie erwartet.

  Die Ausgabe von Zwischenmarken kann mit verschiedenen Optionsvariablen kontrolliert werden. Siehe `programmode` und `labels`.

Systemvariable: linenum

  Enthält die Zeilennummer der aktuellen Ein- und Ausgabemarken. Die Zeilennummer wird von Maxima automatisch erhöht. Siehe auch `labels`, `inchar` und `outchar`.

Systemvariable: myoptions

  `myoptions` ist eine Informationsliste, die die Optionsvariablen enthält, die vom Nutzer während einer Sitzung geändert wurden. Die Variable verbleibt in der Liste, auch wenn sie wieder auf den Standardwert zurückgesetzt wird.

Optionsvariable: nolabels

  Standardwert: `false`

  Hat `nolabels` den Wert `true`, werden die Eingabe- und Ausgabemarken zwar angezeigt, ihnen werden aber keine Eingaben und Ergebnisse zugewiesen und sie werden nicht der Informationsliste `labels` hinzugefügt. Andernfalls werden den Marken die Eingabe und die Ergebnisse zugewiesen und in die Informationsliste `labels` eingetragen.

  Zwischenmarken `%t` werden durch `nolabels` nicht beeinflusst. Den Marken werden unabhängig vom Wert, den `nolabels` hat, Zwischenergebnisse zugewiesen und sie werden in die Informationsliste `labels` eingetragen.

  Siehe auch `labels`.

Optionsvariable: optionset

  Standardwert: `false`

  Hat `optionset` den Wert `true`, gibt Maxima eine Meldung aus, wenn einer Optionsvariablen ein Wert zugewiesen wird.

  Beispiel:

      (%i1) optionset:true;
      assignment: assigning to option optionset
      (%o1)                         true
      (%i2) gamma_expand:true;
      assignment: assigning to option gamma_expand
      (%o2)                         true

Optionsvariable: outchar

  Standardwert: `%o`

  Die Optionsvariable `outchar` enthält den Präfix der Ausgabemarken. Maxima generiert die Ausgabemarken automatisch aus `outchar` und `linenum`.

  Der Optionsvariablen `outchar` kann eine Zeichenkette oder ein Symbol zugewiesen werden, die auch mehr als ein Zeichen haben können. Da Maxima intern nur das erste Zeichen berücksichtigt, sollten sich die Präfixe `inchar`, `outchar` und `linechar` im ersten Zeichen voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie `kill(inlabels)` nicht wie erwartet.

  Siehe auch `labels`.

  Beispiele:

      (%i1) outchar: "output";
      (output1)                    output
      (%i2) expand((a+b)^3);
                           3        2      2      3
      (output2)           b  + 3 a b  + 3 a  b + a
      (%i3)

Funktion: playback ()
Funktion: playback (n)
Funktion: playback ([m, n])
Funktion: playback ([m])
Funktion: playback (input)
Funktion: playback (slow)
Funktion: playback (time)
Funktion: playback (grind)

  Zeigt Eingaben, Ergebnisse und Zwischenergebnisse an, ohne diese neu zu berechnen. `playback` zeigt nur die Eingaben und Ergebnisse an, die Marken zugewiesen wurden. Andere Ausgaben, wie zum Beispiel durch `print`, `describe` oder Fehlermeldungen, werden nicht angezeigt. Siehe auch `labels`.

  `playback()` zeigt sämtliche Eingaben und Ergebnisse an, die bis dahin erzeugt wurden. Ein Ergebnis wird auch dann angezeigt, wenn die Ausgabe mit `$` unterdrückt war.

  `playback(n)` zeigt die letzten n Ausdrücke an. Jeder Eingabe-, Ausgabe- und Zwischenausdruck zählt dabei als ein Ausdruck. `playback([m, n])` zeigt die Eingabe-, Ausgabe- und Zwischenausdrücke mit den Zahlen von m bis einschließlich n an. `playback([m])` ist äquivalent zu `playback([m, m])`. Die Ausgabe ist ein Paar von Ein- und Ausgabeausdrücken.

  `playback(input)` zeigt sämtliche Eingabeausdrücke an, die bis dahin erzeugt wurden.

  `playback(slow)` macht nach jeder Ausgabe eine Pause und wartet auf eine Eingabe. Dieses Verhalten ist vergleichbar mit der Funktion `demo`.

  `playback(time)` zeigt für jeden Ausdruck die für die Berechnung benötigte Zeit an.

  `playback(grind)` zeigt die Eingabeausdrücke in dem gleichen Format an, wie die Funktion `grind`. Ausgabeausdrücke werden von der Option `grind` nicht beeinflusst. Siehe auch `grind`.

  Die Argumente können kombiniert werden, wie zum Beispiel im folgenden Kommando `playback([5, 10], grind, time, slow)`.

  `playback` wertet die Argumente nicht aus. `playback` gibt stets `done` zurück.

Optionsvariable: prompt

  Standardwert: `_`

  Die Optionsvariable `prompt` enthält das Zeichen für die Eingabeaufforderung der Funktionen `demo` und `playback` sowie nach einer Unterbrechung, wie zum Beispiel durch das Kommando `break`.

Funktion: quit ()

  Das Kommando `quit()` beendet eine Maxima-Sitzung.

  Mit der Tastatureingabe `control-c` oder `Strg-c` kann in der Konsole die Verarbeitung abgebrochen werden. Standardmäßig wird die Maxima-Sitzung fortgesetzt. Hat die globale Lisp-Variable `*debugger-hook*` den Wert `nil`, wird der Lisp-Debugger gestartet. Siehe Fehlersuche.

Funktion: read (expr_1, …, expr_n)

  Gibt die Ausdrücke expr_1, … expr_n auf der Konsole aus, liest sodann einen Ausdruck von der Konsole ein und wertet diesen aus. Die Eingabe des Ausdrucks wird mit den Zeichen `;` oder `$` beendet.

  Siehe auch `readonly`.

  Beispiele:

      (%i1) foo: 42$
      (%i2) foo: read ("foo is", foo, " -- enter new value.")$
      foo is 42  -- enter new value.
      (a+b)^3;
      (%i3) foo;
                                           3
      (%o3)                         (b + a)

Funktion: readonly (expr_1, …, expr_n)

  Gibt die Ausdrücke expr_1, … expr_n auf der Konsole aus, liest sodann einen Ausdruck von der Konsole ein und gibt den eingelesenen Ausdruck zurück ohne diesen auszuwerten. Die Eingabe des Ausdrucks wird mit den Zeichen `;` oder `$` beendet.

  Siehe auch `read`.

  Beispiele:

      (%i1) aa: 7$
      (%i2) foo: readonly ("Enter an expression:");
      Enter an expression:
      2^aa;
                                        aa
      (%o2)                            2
      (%i3) foo: read ("Enter an expression:");
      Enter an expression:
      2^aa;
      (%o3)                            128

Funktion: reset ()

  `reset()` setzt globale Maxima- und Lisp-Variablen und Optionen auf ihre Standardwerte zurück. Maxima legt eine interne Liste mit den Standardwerten von globalen Variablen an. Alle Variablen, die in dieser Liste enthalten sind, werden auf ihre Standardwerte zurückgesetzt. Nicht alle globalen Variablen sind mit ihren Standwerten in diese Liste eingetragen. Daher kann `reset` die Anfangswerte stets nur unvollständig wiederherstellen.

  `reset(arg_1, ..., arg_n)` setzt die Variablen arg_1, …, arg_n auf ihren Standardwert zurück.

  `reset` gibt eine Liste mit den Variablen zurück, die auf ihren Standardwert zurückgesetzt wurden. Ist die Liste leer, wurden keine Variablen zurückgesetzt.

  Siehe auch `reset_verbosely`.

Funktion: reset_verbosely ()
Funktion: reset_verbosely (arg_1, …, arg_n)

  Entspricht der Funktion `reset`. Im Unterschied zu `reset` wird zu jeder Variable, die zurückgesetzt wird, zusätzlich der Standardwert angezeigt.

  Siehe `reset`.

Optionsvariable: showtime

  Standardwert: `false`

  Hat `showtime` den Wert `true`, werden die interne Rechenzeit und die gesamte verstrichene Zeit zu jeder Ausgabe angezeigt.

  Die Rechenzeit wird unabhängig vom Wert der Optionsvariablen `showtime` nach jeder Auswertung eines Ausdruckes in den Ausgabemarken abgespeichert. Daher können die Funktionen `time` und `playback` die Rechenzeit auch dann anzeigen, wenn `showtime` den Wert `false` hat.

  Siehe auch `timer`.

Funktion: to_lisp ()

  Wechselt zu einer Lisp-Sitzung. `(to-maxima)` wechselt von der Lisp-Sitzung zurück in die Maxima-Sitzung.

  Beispiel:

  Definiere eine Funktion und wechsle zu Lisp. Die Definition wird von der Eigenschaftsliste gelesen. Dann wird die Definition der Funktion geholt, faktorisiert und in der Variablen `$result` gespeichert. Die Variable kann nach der Rückkehr in Maxima genutzt werden.

      (%i1) f(x):=x^2+x;
                                        2
      (%o1)                    f(x) := x  + x
      (%i2) to_lisp();
      Type (to-maxima) to restart, ($quit) to quit Maxima.
      MAXIMA> (symbol-plist '$f)
      (MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X)
                                   ((MPLUS) ((MEXPT) $X 2) $X))))
      MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
      ((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
      MAXIMA> (to-maxima)
      Returning to Maxima
      (%o2)                         true
      (%i3) result;
      (%o3)                       x (x + 1)

Systemvariable: values

  Anfangswert: `[]`

  `values` ist eine Informationsliste, die die Variablen enthält, die vom Nutzer mit den Operatoren `:` oder `::` einen Wert erhalten haben. Wird der Wert einer Variablen mit den Kommandos `kill`, `remove` oder `remvalue` entfernt, wird die Variable von der Liste `values` entfernt.

  Siehe auch `functions` für die Informationsliste mit den vom Nutzer definierten Funktionen sowie `infolists`.

  Beispiele:

      (%i1) [a:99, b::a-90, c:a-b, d, f(x):= x^2];
                                                 2
      (%o1)              [99, 9, 90, d, f(x) := x ]
      (%i2) values;
      (%o2)                       [a, b, c]
      (%i3) [kill(a), remove(b,value), remvalue(c)];
      (%o3)                   [done, done, [c]]
      (%i4) values;
      (%o4)                          []

Next: Funktionen und Variablen der Ausgabe, Previous: Einführung in die Kommandozeile, Up: Kommandozeile [Contents][Index]