Maxima Manual: 13. Eingabe und Ausgabe

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 13. Eingabe und Ausgabe

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 13.1 Kommentare

Ein Kommentar in der Maxima-Eingabe ist ein Text der von den Zeichen `/*` und `*/` eingeschlossen ist. Der Maxima-Parser behandelt einen Kommentar wie ein Zwischenraumzeichen, wenn ein Token eingelesen wird. Ein Token endet immer an einem Zwischenraumzeichen. Eine Eingabe wie `a/* foo */b` enthält die beiden Token `a` und `b` und nicht das einzelne Token `ab`. Ansonsten werden Kommentare von Maxima ignoriert. Kommentare werden im eingelesenen Ausdruck nicht gespeichert.

Kommentare können in beliebiger Tiefe verschachtelt werden. Die Begrenzungszeichen `/*` und `*/` müssen paarweise auftreten.

Beispiele:

    (%i1) /* aa is a variable of interest */  aa : 1234;
    (%o1)                         1234
    (%i2) /* Value of bb depends on aa */  bb : aa^2;
    (%o2)                        1522756
    (%i3) /* User-defined infix operator */  infix ("b");
    (%o3)                           b
    (%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
    (%o4)                         a b c
    (%i5) /* Comments /* can be nested /* to any depth */ */ */  1 + xyz;
    (%o5)                        xyz + 1

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 13.2 Dateien

Folgende Funktionen und Variablen arbeiten mit Dateien:

       appendfile           batch                 batchload
       closefile            file_output_append    filename_merge
       file_search          file_search_maxima    file_search_lisp
       file_search_demo     file_search_usage     file_search_tests
       file_type            file_type_lisp        file_type_maxima
       load                 load_pathname         loadfile
       loadprint            pathname_directory    pathname_name
       pathname_type        printfile             save
       stringout            with_stdout           writefile

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 13.3 Funktionen und Variablen für die Eingabe und Ausgabe

Funktion: appendfile (filename)

  Startet wie die Funktion `writefile` eine Aufzeichnung aller Ein- und Ausgaben der Konsole. Die Ein- und Ausgaben werden in die Datei filename geschrieben. Im Unterschied zu `writefile` werden die Daten immer an eine existierende Datei angehängt, wenn diese existiert. Existiert die Datei nicht, wird diese angelegt.

  Die Funktion `closefile` beendet die Aufzeichnung.

Funktion: batch (filename)
Funktion: batch (filename, option)

  Das Kommando `batch(filename)` liest Maxima-Ausdrücke aus der Datei filename ein, wertet diese aus und gibt die Ergebnisse auf der Konsole aus. `batch` sucht die Datei filename in den Verzeichnissen, die in der Liste `file_search_maxima` enthalten sind. Siehe auch die Funktion `file_search`.

  `batch(filename, `demo`)` entspricht dem Kommando `demo(filename)`. `batch` sucht für diesen Fall die Datei in der Liste der Verzeichnisse `file_search_demo`. Siehe auch die Funktion `demo`.

  `batch(filename, `test`)` entspricht dem Kommando `run_testsuite` mit der Option `display_all=true`. Im Unterschied zur Funktion `run_testsuite` sucht die Funktion `batch` die Datei filename in den Verzeichnissen der Liste `file_search_maxima` und nicht in der Liste `file_search_tests`.

  Die Maxima-Ausdrücke in der Datei werden wie auf der Konsole mit den Zeichen `;` oder `$` beendet. Die Systemvariable `%` und die Funktion `%th` beziehen sich auf vorhergehende Zeilen in der Datei. Die Datei kann `:lisp`-Unterbrechungskommandos enthalten. Leerzeichen, Tabulatoren, Zeilenschaltungen und Kommentare werden ignoriert. Eine geeignete Datei kann mit einem Texteditor oder der Funktion `stringout` erstellt werden.

  Den Ein- und Ausgaben werden jeweils Ein- und Ausgabemarken zugewiesen. Tritt während der Auswertung eines Ausdrucks ein Fehler auf, wird das Einlesen der Datei abgebrochen. Werden Eingaben vom Nutzer benötigt, wie zum Beispiel bei Fragen der Funktionen `asksign` oder `askinteger`, dann wartet `batch` auf die Antworten, um dann die Verarbeitung der Datei fortzusetzen.

  Die Verarbeitung von `batch` kann durch die Eingabe von `control-C` abgebrochen werden. Die weitere Reaktion auf einen Abbruch mit `control-C` hängt von der Lisp-Implementation ab.

  `batch` wertet die Argumente aus. `batch` gibt den Namen der Datei filename als Zeichenkette zurück, wenn die Funktion ohne zweites Argument oder mit der Option `demo` aufgerufen wird. Wird die Funktion mit der Option `test` aufgerufen, ist die Rückgabe eine leere Liste `[]` oder eine Liste, die filename und die Nummern der fehlgeschlagenen Tests enthält.

  Siehe auch die Funktionen `load` und `batchload`, um Dateien zu laden, sowie die Funktionen `run_testsuite` und `demo`.

Funktion: batchload (filename)

  Liest Ausdrücke aus der Datei filename ein und wertet diese aus, ohne die eingelesenen und ausgewerteten Ausdrücke anzuzeigen und ohne Zuweisung von Eingabe- und Ausgabemarken. Die Ausgabe von Fehlermeldungen oder sonstigem Text, der von Funktionen ausgegeben wird, wird nicht unterdrückt.

  Die Systemvariable `%` und die Funktion `%th` beziehen sich auf die letzte Eingabe auf der Konsole und nicht auf Zeilen oder Ergebnisse der Datei. Im Gegensatz zur Funktion `batch` darf eine Datei, die von `batchload` geladen wird, keine `:lisp`-Unterbrechungskommandos enthalten.

  `batchload` gibt eine Zeichenkette mit dem Pfad der Datei filename zurück. Siehe auch die Funktionen `batch` und `load`, um Dateien zu laden.

Funktion: closefile ()

  Beendet eine Aufzeichnung, die von den Funktionen `writefile` oder `appendfile` gestartet wurde, und schließt die Ausgabedatei.

Optionsvariable: file_output_append

  Standardwert: `false`

  Die Optionsvariable `file_output_append` kontrolliert, ob die Funktionen `save`, `stringout` oder `with_stdout`, die in eine Datei schreiben, diese löschen und neu anlegen oder die Daten anhängen. Wenn `file_output_append` den Wert `true` hat, werden die Daten an die existierende Datei angehängt. Ansonsten wird eine neue Datei erstellt.

  Plot-Funktionen und der Übersetzer erstellen grundsätzlich neue Dateien und die Funktionen `tex` und `appendfile` hängen die Ausgabe immer an eine bestehende Datei an.

Funktion: filename_merge (path, filename)

  Setzt einen Pfad aus path und filename zusammen. Endet path mit einer Zeichenkette der Form `###.something`, wird diese Zeichenkette durch `filename.something` ersetzt. Ansonsten wird der Endbestandteil durch filename ersetzt.

  Die Rückgabe ist ein Lisp-Dateiname.

  Beispiele:

      (%i1) filename_merge("user/", "myfile");
      (%o1)                      user/myfile

      (%i2) filename_merge("user/###.lisp", "myfile");
      (%o2)                   user/myfile.lisp

Funktion: file_search (filename)
Funktion: file_search (filename, pathlist)

  `file_search` sucht die Datei filename und gibt den Pfad als eine Zeichenkette zurück, wenn die Datei gefunden wurde. Ansonsten wird `false` zurückgegeben. `file_search(filename)` sucht in den Standardsuchverzeichnissen, die mit den Optionsvariablen `file_search_maxima`, `file_search_lisp` und `file_search_demo` spezifiziert werden.

  `file_search` prüft zuerst, ob die Datei `filename` existiert. Dann prüft `file_search`, ob die Datei anhand von Mustern im Dateinamen gefunden werden kann. Siehe `file_search_maxima` für die Suche von Dateien.

  Das Argument filename kann ein Name mit einer Pfadangabe oder allein der Dateiname sein. Sind in den Suchverzeichnissen Dateinamen mit Mustern enthalten, kann die Datei auch ohne Endung angegeben werden. Zum Beispiel finden die folgenden Kommandos dieselbe Datei, wenn `/home/wfs/special/###.mac` in der Liste `file_search_maxima` enthalten ist:

      file_search ("/home/wfs/special/zeta.mac");
      file_search ("zeta.mac");
      file_search ("zeta");

  `file_search(filename, pathlist)` sucht nur in den Verzeichnissen pathlist. Das Argument pathlist überschreibt die Standardsuchverzeichnisse. Auch ein einzelnes Verzeichnis muss als eine Liste übergeben werden.

  Die Standardsuchverzeichnisse können modifiziert werden. Siehe dazu auch `file_search_maxima`.

  `file_search` wird von der Funktion `load` mit den Verzeichnislisten `file_search_maxima` und `file_search_lisp` aufgerufen.

Optionsvariable: file_search_maxima
Optionsvariable: file_search_lisp
Optionsvariable: file_search_demo
Optionsvariable: file_search_usage
Optionsvariable: file_search_tests

  Diese Optionsvariablen bezeichnen Listen mit Verzeichnissen, die von Funktionen wie `load` und `demo` durchsucht werden, um eine Datei zu finden. Die Standardwerte bezeichnen verschiedene Verzeichnisse der Maxima-Installation.

  Diese Variablen können modifiziert werden, indem die Standardwerte ersetzt oder weitere Verzeichnisse angehängt werden. Zum Beispiel wird im Folgenden der Standardwert der Optionsvariablen `file_search_maxima` ersetzt:

      file_search_maxima: ["/usr/local/foo/###.mac",
          "/usr/local/bar/###.mac"]$

  In diesem Beispiel werden zwei weitere Verzeichnisse zu der Optionsvariablen `file_search_maxima` hinzugefügt:

      file_search_maxima: append (file_search_maxima,
          ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$

  Soll eine erweiterte Liste der Suchverzeichnisse nach jedem Start von Maxima zur Verfügung stehen, kann das obige Kommando in die Datei `maxima-init.mac` aufgenommen werden.

  Mehrere Dateiendungen und Pfade können mit Wildcard-Konstruktionen spezifiziert werden. Eine Zeichenkette `###` wird durch einen Dateinamen ersetzt. Werden mehrere Zeichenketten durch Kommata getrennt und mit geschweiften Klammern angegeben wie zum Beispiel `{foo, bar, baz}`, expandiert die Liste in mehrere Zeichenketten. Das folgende Beispiel expandiert für `neumann`

      "/home/{wfs,gcj}/###.{lisp,mac}"

  in `/home/wfs/neumann.lisp`, `/home/gcj/neumann.lisp`, `/home/wfs/neumann.mac` und `/home/gcj/neumann.mac`.

Funktion: file_type (filename)

  Gibt eine Vermutung über den Typ der Datei filename zurück. Es wird nur die Dateiendung betrachtet.

  Die Rückgabe ist das Symbol `maxima` oder `lisp`, wenn die Dateiendung einen der Werte der Optionsvariablen `file_type_maxima` oder der Optionsvariablen `file_type_lisp` entspricht. Ansonsten ist die Rückgabe das Symbol `object`.

  Siehe auch die Funktion `pathname_type`.

Optionsvariable: file_type_lisp

  Standardwert: `[l, lsp, lisp]`

  Die Optionsvariable `file_type_lisp` enthält die Dateiendungen, die Maxima als die Bezeichnung für eine Lisp-Datei annimmt.

  Siehe auch die Funktion `file_type`.

Optionsvariable: file_type_maxima

  Standardwert: `[mac, mc, demo, dem, dm1, dm2, dm3, dmt]`

  Die Optionsvariable `file_type_maxima` enthält die Dateiendungen, die Maxima als die Bezeichnung für eine Maxima-Datei annimmt.

  Siehe auch die Funktion `file_type`.

Funktion: load (filename)

  Wertet die Ausdrücke in der Datei filename aus, wodurch die Variablen, Funktionen und andere Objekte in Maxima geladen werden. Alle bisher zugewiesen Variablen und Definitionen werden überschrieben. Um die Datei zu finden, wird von `load` die Funktion `file_search` mit den Verzeichnislisten `file_search_maxima` und `file_search_lisp` aufgerufen. Ist `load` erfolgreich, wird der Dateiname zurückgegeben. Ansonsten gibt `load` eine Fehlermeldung aus.

  `load` verarbeitet Dateien mit Lisp-Code oder Maxima-Code. Dateien, die mit den Funktionen `save`, `translate_file` und `compile_file` erstellt wurden, enthalten Lisp-Code. Dateien, die mit `stringout` erstellt wurden, enthalten Maxima-Code. Die Ausgabedateien dieser Funktionen können mit `load` geladen werden. `load` ruft die Funktion `loadfile` auf, um Lisp-Dateien und `batchload` auf, um Maxima-Dateien zu verarbeiten.

  `load` erkennt keine `:lisp`-Unterbrechungskommandos in Maxima-Dateien. Die Systemvariablen `_`, `__` und `%` und die Funktion `%th` behalten jeweils ihren letzten Wert vor dem Aufruf von `load`.

  Siehe auch die Funktionen `loadfile`, `batch`, `batchload` und `demo`. `loadfile` verarbeitet Lisp-Dateien. `batch`, `batchload` und `demo` verarbeiten Maxima-Dateien.

  Siehe `file_search` für mehr Informationen, wie Maxima Dateien in Verzeichnissen findet. `load` wertet die Argumente aus.

Systemvariable: load_pathname

  Standardwert: `false`

  Wird eine Datei mit den Funktionen `load`, `loadfile` oder `batchload` geladen, enthält die Systemvariable `load_pathname` den Namen der Datei. Der Wert der Systemvariablen kann in der Datei, die geladen wird, ausgelesen werden.

  Beispiele:

  Ist eine Batch-Datei mit den Namen `test.mac` in dem Verzeichnis

      "/home/dieter/workspace/mymaxima/temp/"

  abgelegt und enthält die Datei die folgenden Befehle

      print("The value of load_pathname is: ", load_pathname)$
      print("End of batchfile")$

  dann wird das Folgende ausgegeben:

      (%i1) load("/home/dieter/workspace/mymaxima/temp/test.mac")$
      The value of load_pathname is:
                    /home/dieter/workspace/mymaxima/temp/test.mac
      End of batchfile

Funktion: loadfile (filename)

  Lädt die Datei filename und wertet die Lisp-Ausdrücke in der Datei aus. `filename` ruft nicht `file_search` auf, um eine Datei zu finden. Daher muss `filename` ein vollständiger Dateiname sein.

  `loadfile` kann Dateien verarbeiten, die mit den Funktionen `save`, `translate_file` und `compile_file` erzeugt wurden.

Optionsvariable: loadprint

  Standardwert: `true`

  `loadprint` kontrolliert, ob Meldungen ausgegeben werden, wenn eine Datei geladen wird.

  - Hat `loadprint` den Wert `true`, wird immer eine Meldung ausgegeben.
  - Hat `loadprint` den Wert `'loadfile`, wird eine Meldung ausgegeben, wenn die Datei mit der Funktion `loadfile` geladen wird.
  - Hat `loadprint` den Wert `'autoload`, wird eine Meldung ausgegeben, wenn eine Datei automatisch geladen wird.
  - Hat `loadprint` den Wert `false`, werden keine Meldungen beim Laden von Dateien ausgegeben.

Funktion: pathname_directory (pathname)
Funktion: pathname_name (pathname)
Funktion: pathname_type (pathname)

  Diese Funktionen geben die Bestandteile eines Pfadnamens zurück.

  Beispiele:

      (%i1) pathname_directory("/home/dieter/maxima/changelog.txt");
      (%o1)                 /home/dieter/maxima/
      (%i2) pathname_name("/home/dieter/maxima/changelog.txt");
      (%o2)                       changelog
      (%i3) pathname_type("/home/dieter/maxima/changelog.txt");
      (%o3)                          txt

Funktion: printfile (path)

  Druckt eine Datei mit dem Namen path auf der Konsole aus. path kann ein Symbol oder eine Zeichenkette sein. `printfile` sucht die Datei in den Verzeichnissen, die in der Optionsvariablen `file_search_usage` enthalten sind.

  `printfile` gibt path zurück, wenn die Datei existiert.

Funktion: save (filename, name_1, name_2, name_3, …)
Funktion: save (filename, values, functions, labels, …)
Funktion: save (filename, [m, n])
Funktion: save (filename, name_1=expr_1, …)
Funktion: save (filename, all)
Funktion: save (filename, name_1=expr_1, name_2=expr_2, …)

  Speichert die aktuellen Werte von name_1, name_2, name_3, …, in die Datei filename. Die Argumente sind die Namen von Variablen, Funktionen oder anderen Objekten. Argumente, die keinen Wert haben, werden ignoriert. `save` gibt den Namen der Datei `filename` zurück.

  `save` speichert die Daten in einem Lisp-Format. Die gespeicherten Daten können mit dem Kommando `load(filename)` zurückgelesen werden. Siehe `load`.

  Die Optionsvariable `file_output_append` kontrolliert, ob `save` die Daten an die Ausgabedatei anhängt, wenn diese bereits existiert, oder die Ausgabedatei zuvor löscht. Hat `file_output_append` den Wert `true`, werden die Daten angehängt. Ansonsten wird die Datei gelöscht und neu angelegt, wenn diese bereits existiert. Existiert die Ausgabedatei noch nicht, wird diese angelegt.

  `save(filename, values, functions, labels, ...)` speichert die Werte aller Einträge der Listen `values`, `functions`, `labels`, u.s.w. in die Ausgabedatei. Es kann jede der vorhandenen Informationslisten, die in der Systemvariablen `infolists` enthalten ist, als Argument übergeben werden. `values` enthält zum Beispiel alle vom Nutzer definierten Variablen.

  `save(filename, [m, n])` speichert die Werte der Eingabe- und Ausgabemarken von m bis n. m und n müssen ganze Zahlen sein. Die Eingabe- und Ausgabemarken können auch einzeln gespeichert werden, zum Beispiel mit dem Kommando `save("foo.1", %i42, %o42)`. `save(filename, labels)` speichert alle Eingabe- und Ausgabemarken. Beim Zurücklesen der Marken werden vorhandene Werte überschrieben.

  `save(filename, name_1 = expr_1, name_2 = expr_2, ...)` speichert die Werte expr_1, expr_2, …, unter den Namen name_1, name_2, … ab. Dies kann nützlich sein, um zum Beispiel die Werte von Marken unter einem neuen Namen abzuspeichern. Die rechte Seite der Gleichungen kann ein beliebiger ausgewerteter Ausdruck sein. Die neuen Namen werden der aktuellen Sitzung nicht hinzugefügt und nur in der Ausgabedatei gespeichert.

  Die verschiedenen Möglichkeiten der Funktion `save`, können miteinander kombiniert werden. Das Kommando `save(filename, aa, bb, cc=42, functions, [11,17])` ist dafür ein Beispiel.

  `save(filename, all)` speichert den aktuellen Zustand von Maxima in eine Ausgabedatei. Eingeschlossen sind alle nutzerdefinierten Variablen, Funktionen oder Arrays, einschließlich automatischer Definitionen. Die gespeicherten Daten enthalten auch die Werte von geänderten System- oder Optionsvariablen. Siehe dazu auch `myoptions`.

  `save` wertet das Argument filename aus. Alle anderen Argumente werden nicht ausgewertet.

Funktion: stringout (filename, expr_1, expr_2, expr_3, …)
Funktion: stringout (filename, [m, n])
Funktion: stringout (filename, input)
Funktion: stringout (filename, functions)
Funktion: stringout (filename, values)

  `stringout` schreibt Ausdrücke in einem Format in eine Datei, dass identisch mit dem Format der Eingabe ist. Die Datei kann als Eingabedatei für die Funktionen `batch` oder `demo` genutzt werden. Sie kann mit einem Texteditor für jeden Zweck editiert werden. `stringout` kann ausgeführt werden, wenn das Kommando `writefile` aktiv ist.

  Die Optionsvariable `file_output_append` kontrolliert, ob `stringout` die Daten an die Ausgabedatei anhängt, wenn diese bereits existiert oder die Ausgabedatei zuvor löscht. Hat `file_output_append` den Wert `true`, werden die Daten angehängt, wenn die Datei bereits existiert. Ansonsten wird die Datei gelöscht und neu angelegt. Existiert die Ausgabedatei noch nicht, wird diese angelegt.

  Die allgemeine Form von `stringout` schreibt die Werte eines oder mehrerer Ausdrücke in die Ausgabedatei. Ist ein Ausdruck eine Variable, wird nur der Wert der Variablen, nicht jedoch der Name der Variablen in die Ausgabedatei geschrieben. Ein nützlicher Spezialfall ist, dass die Werte der Eingabe- und Ausgabemarken (`%i1`, `%i2`, `%i3`, … und `%o1`, `%o2`, `%o3`, …) in die Datei geschrieben werden können.

  Hat die Optionsvariable `grind` den Wert `true`, wird die Ausgabe im Format der Funktion `grind` in die Ausgabedatei geschrieben. Ansonsten wird das Format der Funktion `string` für die Ausgabe genutzt.

  `stringout(filename, [m, n])` schreibt die Werte aller Eingabemarken von m bis n in die Ausgabedatei. `stringout(filename, input)` schreibt alle Eingabemarken in die Ausgabedatei. `stringout(filename, functions)` schreibt alle vom Nutzer definierten Funktionen, die in der Informationsliste `functions` enthalten sind, in die Ausgabedatei.

  `stringout(filename, values)` schreibt alle benuzterdefinierten Variablen, die in der Informationsliste `values` enthalten sind, in die Ausgabedatei. Die Variablen werden als eine Zuweisung, mit dem Namen der Variablen, dem Zuweisungsoperator `:` und dem Wert in die Datei geschrieben. Im Unterschied dazu, speichert die allgemeine Form der Funktion `stringout` die Variablen nicht als Zuweisung.

Funktion: with_stdout (f, expr_1, expr_2, expr_3, …)
Funktion: with_stdout (s, expr_1, expr_2, expr_3, …)

  `with_stdout` wertet Argumente expr_1, expr_2, expr_3, … aus und schreibt die Ergebnisse der Auswertung in die Ausgabedatei `f` oder in den Stream `s`. Die Ergebnisse werden nicht auf der Konsole ausgegeben.

  Die Optionsvariable `file_output_append` bestimmt, ob `with_stdout` die Daten an die Ausgabedatei anhängt oder die Ausgabedatei zuvor löscht. Hat `file_output_append` den Wert `true`, werden die Daten angehängt. Ansonsten wird die Datei gelöscht und neu angelegt. Existiert die Ausgabedatei noch nicht, wird diese angelegt.

  `with_stout` gibt das Ergebnis des letzten Argumentes zurück.

  Siehe auch `writefile`.

  Beispiel:

      (%i1) with_stdout ("tmp.out", for i:5 thru 10 do
               print (i, "! yields", i!))$
      (%i2) printfile ("tmp.out")$
      5 ! yields 120
      6 ! yields 720
      7 ! yields 5040
      8 ! yields 40320
      9 ! yields 362880
      10 ! yields 3628800

Funktion: writefile (filename)

  Startet eine Aufzeichnung aller Ein- und Ausgaben der Konsole. Die Ein- und Ausgaben werden in die Datei filename geschrieben.

  Die Ausgabedatei kann von Maxima nicht wieder zurückgelesen werden. Um ein Datei zu erzeugen, die von Maxima zurückgelesen werden kann, siehe die Funktionen `save` und `stringout`. `save` speichert Ausdrücke in einem Lisp-Format und `stringout` in einem Maxima-Format.

  Die Reaktion der Funktion `writefile` für den Fall, dass die Ausgabedatei bereits existiert, hängt von der Lisp-Implementation ab. Die Ausgabedatei kann zurückgesetzt werden oder die Daten werden angehängt. Die Funktion `appendfile` hängt die Daten immer an eine existierende Datei an.

  Um eine Aufzeichnung ohne Textausgaben von Funktionen zu erhalten, kann `writefile` nach der Ausführung von `playback` ausgeführt werden. `playback` gibt alle vorhergenden Eingabe- und Ausgabemarken aus, jedoch nicht sonstige Textausgaben von Maxima-Funktionen.

  Mit `closefile` wird die Aufzeichnung beendet.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 13.4 Funktionen und Variablen für die TeX-Ausgabe

Function: tex (expr)
Function: tex (expr, destination)
Function: tex (expr, false)
Function: tex (label)
Function: tex (label, destination)
Function: tex (label, false)

  Prints a representation of an expression suitable for the TeX document preparation system. The result is a fragment of a document, which can be copied into a larger document but not processed by itself.

  `tex (expr)` prints a TeX representation of expr on the console.

  `tex (label)` prints a TeX representation of the expression named by label and assigns it an equation label (to be displayed to the left of the expression). The TeX equation label is the same as the Maxima label.

  destination may be an output stream or file name. When destination is a file name, `tex` appends its output to the file. The functions `openw` and `opena` create output streams.

  `tex (expr, false)` and `tex (label, false)` return their TeX output as a string.

  `tex` evaluates its first argument after testing it to see if it is a label. Quote-quote `''` forces evaluation of the argument, thereby defeating the test and preventing the label.

  See also `texput`.

  Examples:

      (%i1) integrate (1/(1+x^3), x);
                                          2 x - 1
                        2            atan(-------)
                   log(x  - x + 1)        sqrt(3)    log(x + 1)
      (%o1)      - --------------- + ------------- + ----------
                          6             sqrt(3)          3
      (%i2) tex (%o1);
      $$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
       }\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
       }\over{3}}\leqno{\tt (\%o1)}$$
      (%o2)                          (\%o1)
      (%i3) tex (integrate (sin(x), x));
      $$-\cos x$$
      (%o3)                           false
      (%i4) tex (%o1, "foo.tex");
      (%o4)                          (\%o1)

  `tex (expr, false)` returns its TeX output as a string.

      (%i1) S : tex (x * y * z, false);
      (%o1) $$x\,y\,z$$
      (%i2) S;
      (%o2) $$x\,y\,z$$

Function: tex1 (e)

  Returns a string which represents the TeX output for the expressions e. The TeX output is not enclosed in delimiters for an equation or any other environment.

  Examples:

      (%i1) tex1 (sin(x) + cos(x));
      (%o1)                     \sin x+\cos x

Function: texput (a, s)
Function: texput (a, f)
Function: texput (a, s, operator_type)
Function: texput (a, [s_1, s_2], matchfix)
Function: texput (a, [s_1, s_2, s_3], matchfix)

  Assign the TeX output for the atom a, which can be a symbol or the name of an operator.

  `texput (a, s)` causes the `tex` function to interpolate the string s into the TeX output in place of a.

  `texput (a, f)` causes the `tex` function to call the function f to generate TeX output. f must accept one argument, which is an expression which has operator a, and must return a string (the TeX output). f may call `tex1` to generate TeX output for the arguments of the input expression.

  `texput (a, s, operator_type)`, where operator_type is `prefix`, `infix`, `postfix`, `nary`, or `nofix`, causes the `tex` function to interpolate s into the TeX output in place of a, and to place the interpolated text in the appropriate position.

  `texput (a, [s_1, s_2], matchfix)` causes the `tex` function to interpolate s_1 and s_2 into the TeX output on either side of the arguments of a. The arguments (if more than one) are separated by commas.

  `texput (a, [s_1, s_2, s_3], matchfix)` causes the `tex` function to interpolate s_1 and s_2 into the TeX output on either side of the arguments of a, with s_3 separating the arguments.

  Examples:

  Assign TeX output for a variable.

      (%i1) texput (me,"\\mu_e");
      (%o1)                         \mu_e
      (%i2) tex (me);
      $$\mu_e$$
      (%o2)                         false

  Assign TeX output for an ordinary function (not an operator).

      (%i1) texput (lcm, "\\mathrm{lcm}");
      (%o1)                     \mathrm{lcm}
      (%i2) tex (lcm (a, b));
      $$\mathrm{lcm}\left(a , b\right)$$
      (%o2)                         false

  Call a function to generate TeX output.

      (%i1) texfoo (e) := block ([a, b], [a, b] : args (e),
        concat ("\\left[\\stackrel{", tex1 (b),
                "}{", tex1 (a), "}\\right]"))$
      (%i2) texput (foo, texfoo);
      (%o2)                        texfoo
      (%i3) tex (foo (2^x, %pi));
      $$\left[\stackrel{\pi}{2^{x}}\right]$$
      (%o3)                         false

  Assign TeX output for a prefix operator.

      (%i1) prefix ("grad");
      (%o1)                         grad
      (%i2) texput ("grad", " \\nabla ", prefix);
      (%o2)                        \nabla
      (%i3) tex (grad f);
      $$ \nabla f$$
      (%o3)                         false

  Assign TeX output for an infix operator.

      (%i1) infix ("~");
      (%o1)                           ~
      (%i2) texput ("~", " \\times ", infix);
      (%o2)                        \times
      (%i3) tex (a ~ b);
      $$a \times b$$
      (%o3)                         false

  Assign TeX output for a postfix operator.

      (%i1) postfix ("##");
      (%o1)                          ##
      (%i2) texput ("##", "!!", postfix);
      (%o2)                          !!
      (%i3) tex (x ##);
      $$x!!$$
      (%o3)                         false

  Assign TeX output for a nary operator.

      (%i1) nary ("@@");
      (%o1)                          @@
      (%i2) texput ("@@", " \\circ ", nary);
      (%o2)                         \circ
      (%i3) tex (a @@ b @@ c @@ d);
      $$a \circ b \circ c \circ d$$
      (%o3)                         false

  Assign TeX output for a nofix operator.

      (%i1) nofix ("foo");
      (%o1)                          foo
      (%i2) texput ("foo", "\\mathsc{foo}", nofix);
      (%o2)                     \mathsc{foo}
      (%i3) tex (foo);
      $$\mathsc{foo}$$
      (%o3)                         false

  Assign TeX output for a matchfix operator.

      (%i1) matchfix ("<<", ">>");
      (%o1)                          <<
      (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
      (%o2)                [ \langle ,  \rangle ]
      (%i3) tex (<<a>>);
      $$ \langle a \rangle $$
      (%o3)                         false
      (%i4) tex (<<a, b>>);
      $$ \langle a , b \rangle $$
      (%o4)                         false
      (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
            matchfix);
      (%o5)           [ \langle ,  \rangle ,  \, | \,]
      (%i6) tex (<<a>>);
      $$ \langle a \rangle $$
      (%o6)                         false
      (%i7) tex (<<a, b>>);
      $$ \langle a \, | \,b \rangle $$
      (%o7)                         false

Function: get_tex_environment (op)
Function: set_tex_environment (op, before, after)

  Customize the TeX environment output by `tex`. As maintained by these functions, the TeX environment comprises two strings: one is printed before any other TeX output, and the other is printed after.

  Only the TeX environment of the top-level operator in an expression is output; TeX environments associated with other operators are ignored.

  `get_tex_environment` returns the TeX enviroment which is applied to the operator op; returns the default if no other environment has been assigned.

  `set_tex_environment` assigns the TeX environment for the operator op.

  Examples:

      (%i1) get_tex_environment (":=");
      (%o1) [
      \begin{verbatim}
      , ;
      \end{verbatim}
      ]
      (%i2) tex (f (x) := 1 - x);

      \begin{verbatim}
      f(x):=1-x;
      \end{verbatim}

      (%o2)                         false
      (%i3) set_tex_environment (":=", "$$", "$$");
      (%o3)                       [$$, $$]
      (%i4) tex (f (x) := 1 - x);
      $$f(x):=1-x$$
      (%o4)                         false

Function: get_tex_environment_default ()
Function: set_tex_environment_default (before, after)

  Customize the TeX environment output by `tex`. As maintained by these functions, the TeX environment comprises two strings: one is printed before any other TeX output, and the other is printed after.

  `get_tex_environment_default` returns the TeX environment which is applied to expressions for which the top-level operator has no specific TeX environment (as assigned by `set_tex_environment`).

  `set_tex_environment_default` assigns the default TeX environment.

  Examples:

      (%i1) get_tex_environment_default ();
      (%o1)                       [$$, $$]
      (%i2) tex (f(x) + g(x));
      $$g\left(x\right)+f\left(x\right)$$
      (%o2)                         false
      (%i3) set_tex_environment_default ("\\begin{equation}
      ", "
      \\end{equation}");
      (%o3) [\begin{equation}
      ,
      \end{equation}]
      (%i4) tex (f(x) + g(x));
      \begin{equation}
      g\left(x\right)+f\left(x\right)
      \end{equation}
      (%o4)                         false

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 13.5 Funktionen und Variablen für die Fortran-Ausgabe

Option variable: fortindent

  Default value: `0`

  `fortindent` controls the left margin indentation of expressions printed out by the `fortran` command. `0` gives normal printout (i.e., 6 spaces), and positive values will causes the expressions to be printed farther to the right.

Function: fortran (expr)

  Prints expr as a Fortran statement. The output line is indented with spaces. If the line is too long, `fortran` prints continuation lines. `fortran` prints the exponentiation operator `^` as `**`, and prints a complex number `a + b %i` in the form `(a,b)`.

  expr may be an equation. If so, `fortran` prints an assignment statement, assigning the right-hand side of the equation to the left-hand side. In particular, if the right-hand side of expr is the name of a matrix, then `fortran` prints an assignment statement for each element of the matrix.

  If expr is not something recognized by `fortran`, the expression is printed in `grind` format without complaint. `fortran` does not know about lists, arrays, or functions.

  `fortindent` controls the left margin of the printed lines. `0` is the normal margin (i.e., indented 6 spaces). Increasing `fortindent` causes expressions to be printed further to the right.

  When `fortspaces` is `true`, `fortran` fills out each printed line with spaces to 80 columns.

  `fortran` evaluates its arguments; quoting an argument defeats evaluation. `fortran` always returns `done`.

  See also the function `f90` for printing one or more expressions as a Fortran 90 program.

  Examples:

      (%i1) expr: (a + b)^12$
      (%i2) fortran (expr);
            (b+a)**12
      (%o2)                         done
      (%i3) fortran ('x=expr);
            x = (b+a)**12
      (%o3)                         done
      (%i4) fortran ('x=expand (expr));
            x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792
           1   *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b
           2   **3+66*a**10*b**2+12*a**11*b+a**12
      (%o4)                         done
      (%i5) fortran ('x=7+5*%i);
            x = (7,5)
      (%o5)                         done
      (%i6) fortran ('x=[1,2,3,4]);
            x = [1,2,3,4]
      (%o6)                         done
      (%i7) f(x) := x^2$
      (%i8) fortran (f);
            f
      (%o8)                         done

Option variable: fortspaces

  Default value: `false`

  When `fortspaces` is `true`, `fortran` fills out each printed line with spaces to 80 columns.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Viktor T. Toth on Dezember, 11 2016 using texi2html 1.76.