doc/info/de/Input.de.texi

   1 @c -----------------------------------------------------------------------------
   2 @c File        : Input.de.texi
   3 @c License     : GNU General Public License (GPL)
   4 @c Language    : German
   5 @c Original    : Input.texi revision 21.08.2011
   6 @c Translation : Dr. Dieter Kaiser
   7 @c Date        : 02.11.2010
   8 @c Revision    : 21.08.2011
   9 @c
  10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
  11 @c -----------------------------------------------------------------------------
  12
  13 @menu
  14 * Kommentare::
  15 * Dateien::
  16 * Funktionen und Variablen f@"ur die Eingabe und Ausgabe::
  17 * Funktionen und Variablen f@"ur die TeX-Ausgabe::
  18 * Funktionen und Variablen f@"ur die Fortran-Ausgabe::
  19 @end menu
  20
  21 @c -----------------------------------------------------------------------------
  22 @node Kommentare, Dateien, Eingabe und Ausgabe, Eingabe und Ausgabe
  23 @section Kommentare
  24 @c -----------------------------------------------------------------------------
  25
  26 Ein Kommentar in der Maxima-Eingabe ist ein Text der von den Zeichen @code{/*}
  27 und @code{*/} eingeschlossen ist.  Der Maxima-Parser behandelt einen Kommentar
  28 wie ein Zwischenraumzeichen, wenn ein Token eingelesen wird.  Ein Token endet
  29 immer an einem Zwischenraumzeichen.  Eine Eingabe wie @code{a/* foo */b}
  30 enth@"alt die beiden Token @code{a} und @code{b} und nicht das einzelne Token
  31 @code{ab}.  Ansonsten werden Kommentare von Maxima ignoriert.  Kommentare werden
  32 im eingelesenen Ausdruck nicht gespeichert.
  33
  34 Kommentare k@"onnen in beliebiger Tiefe verschachtelt werden.  Die
  35 Begrenzungszeichen @code{/*} und @code{*/} m@"ussen paarweise auftreten.
  36
  37 Beispiele:
  38
  39 @example
  40 (%i1) /* aa is a variable of interest */  aa : 1234;
  41 (%o1)                         1234
  42 (%i2) /* Value of bb depends on aa */  bb : aa^2;
  43 (%o2)                        1522756
  44 (%i3) /* User-defined infix operator */  infix ("b");
  45 (%o3)                           b
  46 (%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
  47 (%o4)                         a b c
  48 (%i5) /* Comments /* can be nested /* to any depth */ */ */  1 + xyz;
  49 (%o5)                        xyz + 1
  50 @end example
  51
  52 @c -----------------------------------------------------------------------------
  53 @node Dateien, Funktionen und Variablen f@"ur die Eingabe und Ausgabe, Kommentare, Eingabe und Ausgabe
  54 @section Dateien
  55 @c -----------------------------------------------------------------------------
  56
  57 @c TODO: HIER FEHLEN AUSFUEHRUNGEN DIE MAXIMA BETREFFEN.
  58 @c       DIE OBIGEN AUSFUEHRUNGEN SIND ZU ALLGEMEIN.
  59
  60 Folgende Funktionen und Variablen arbeiten mit Dateien:
  61
  62 @verbatim
  63    appendfile           batch                 batchload
  64    closefile            file_output_append    filename_merge
  65    file_search          file_search_maxima    file_search_lisp
  66    file_search_demo     file_search_usage     file_search_tests
  67    file_type            file_type_lisp        file_type_maxima
  68    load                 load_pathname         loadfile
  69    loadprint            pathname_directory    pathname_name
  70    pathname_type        printfile             save
  71    stringout            with_stdout           writefile
  72 @end verbatim
  73
  74 @c -----------------------------------------------------------------------------
  75 @node Funktionen und Variablen f@"ur die Eingabe und Ausgabe, Funktionen und Variablen f@"ur die TeX-Ausgabe, Dateien, Eingabe und Ausgabe
  76 @section Funktionen und Variablen f@"ur die Eingabe und Ausgabe
  77 @c -----------------------------------------------------------------------------
  78
  79 @c --- 09.11.2010 DK -----------------------------------------------------------
  80 @anchor{appendfile}
  81 @deffn {Funktion} appendfile (@var{filename})
  82
  83 Startet wie die Funktion @mref{writefile} eine Aufzeichnung aller Ein- und
  84 Ausgaben der Konsole.  Die Ein- und Ausgaben werden in die Datei @var{filename}
  85 geschrieben.  Im Unterschied zu @code{writefile} werden die Daten immer an eine
  86 existierende Datei angeh@"angt, wenn diese existiert.  Existiert die Datei
  87 nicht, wird diese angelegt.
  88
  89 Die Funktion @mref{closefile} beendet die Aufzeichnung.
  90 @end deffn
  91
  92 @c --- 09.11.2010 DK -----------------------------------------------------------
  93 @anchor{batch}
  94 @deffn  {Funktion} batch (@var{filename})
  95 @deffnx {Funktion} batch (@var{filename}, option)
  96
  97 Das Kommando @code{batch(@var{filename})} liest Maxima-Ausdr@"ucke aus der Datei
  98 @var{filename} ein, wertet diese aus und gibt die Ergebnisse auf der Konsole
  99 aus.  @code{batch} sucht die Datei @var{filename} in den Verzeichnissen, die in
 100 der Liste @mref{file_search_maxima} enthalten sind.  Siehe auch die Funktion
 101 @mrefdot{file_search}
 102
 103 @code{batch(@var{filename}, @code{demo})} entspricht dem Kommando
 104 @code{demo(@var{filename})}.  @code{batch} sucht f@"ur diesen Fall die Datei in
 105 der Liste der Verzeichnisse @mrefdot{file_search_demo}  Siehe auch die Funktion
 106 @mrefdot{demo}
 107
 108 @code{batch(@var{filename}, @code{test})} entspricht dem Kommando
 109 @mref{run_testsuite} mit der Option @code{display_all=true}.  Im Unterschied zur
 110 Funktion @code{run_testsuite} sucht die Funktion @code{batch} die Datei
 111 @var{filename} in den Verzeichnissen der Liste @code{file_search_maxima} und
 112 nicht in der Liste @mrefdot{file_search_tests}
 113
 114 Die Maxima-Ausdr@"ucke in der Datei werden wie auf der Konsole mit den
 115 Zeichen @code{;} oder @code{$} beendet.  Die Systemvariable @code{%} und die
 116 Funktion @code{%th} beziehen sich auf vorhergehende Zeilen in der Datei.  Die
 117 Datei kann @code{:lisp}-Unterbrechungskommandos enthalten.  Leerzeichen,
 118 Tabulatoren, Zeilenschaltungen und Kommentare werden ignoriert.  Eine geeignete
 119 Datei kann mit einem Texteditor oder der Funktion @mref{stringout} erstellt
 120 werden.
 121
 122 Den Ein- und Ausgaben werden jeweils Ein- und Ausgabemarken zugewiesen.  Tritt
 123 w@"ahrend der Auswertung eines Ausdrucks ein Fehler auf, wird das Einlesen der
 124 Datei abgebrochen.  Werden Eingaben vom Nutzer ben@"otigt, wie zum Beispiel bei
 125 Fragen der Funktionen @code{asksign} oder @code{askinteger}, dann wartet
 126 @code{batch} auf die Antworten, um dann die Verarbeitung der Datei fortzusetzen.
 127
 128 Die Verarbeitung von @code{batch} kann durch die Eingabe von @code{control-C}
 129 abgebrochen werden.  Die weitere Reaktion auf einen Abbruch mit @code{control-C}
 130 h@"angt von der Lisp-Implementation ab.
 131
 132 @code{batch} wertet die Argumente aus.  @code{batch} gibt den Namen der Datei
 133 @var{filename} als Zeichenkette zur@"uck, wenn die Funktion ohne zweites
 134 Argument oder mit der Option @code{demo} aufgerufen wird.  Wird die Funktion mit
 135 der Option @code{test} aufgerufen, ist die R@"uckgabe eine leere Liste @code{[]}
 136 oder eine Liste, die @var{filename} und die Nummern der fehlgeschlagenen Tests
 137 enth@"alt.
 138
 139 Siehe auch die Funktionen @mref{load} und @mrefcomma{batchload} um Dateien
 140 zu laden, sowie die Funktionen @mref{run_testsuite} und @mrefdot{demo}
 141 @end deffn
 142
 143 @c --- 09.11.2010 DK -----------------------------------------------------------
 144 @anchor{batchload}
 145 @deffn {Funktion} batchload (@var{filename})
 146
 147 Liest Ausdr@"ucke aus der Datei @var{filename} ein und wertet diese aus, ohne
 148 die eingelesenen und ausgewerteten Ausdr@"ucke anzuzeigen und ohne Zuweisung von
 149 Eingabe- und Ausgabemarken.  Die Ausgabe von Fehlermeldungen oder sonstigem
 150 Text, der von Funktionen ausgegeben wird, wird nicht unterdr@"uckt.
 151
 152 Die Systemvariable @code{%} und die Funktion @code{%th} beziehen sich auf die
 153 letzte Eingabe auf der Konsole und nicht auf Zeilen oder Ergebnisse der Datei.
 154 Im Gegensatz zur Funktion @code{batch} darf eine Datei, die von @code{batchload}
 155 geladen wird, keine @code{:lisp}-Unterbrechungskommandos enthalten.
 156
 157 @code{batchload} gibt eine Zeichenkette mit dem Pfad der Datei @var{filename}
 158 zur@"uck.  Siehe auch die Funktionen @mref{batch} und @mrefcomma{load} um
 159 Dateien zu laden.
 160 @end deffn
 161
 162 @c --- 09.11.2010 DK -----------------------------------------------------------
 163 @anchor{closefile}
 164 @deffn {Funktion} closefile ()
 165
 166 Beendet eine Aufzeichnung, die von den Funktionen @mref{writefile} oder
 167 @mref{appendfile} gestartet wurde, und schlie@ss{}t die Ausgabedatei.
 168 @end deffn
 169
 170 @c --- 09.11.2010 DK -----------------------------------------------------------
 171 @anchor{file_output_append}
 172 @defvr {Optionsvariable} file_output_append
 173 Standardwert: @code{false}
 174
 175 Die Optionsvariable @code{file_output_append} kontrolliert, ob die Funktionen
 176 @mrefcomma{save} @mref{stringout} oder @mrefcomma{with_stdout} die in eine Datei
 177 schreiben, diese l@"oschen und neu anlegen oder die Daten anh@"angen.  Wenn
 178 @code{file_output_append} den Wert @code{true} hat, werden die Daten an die
 179 existierende Datei angeh@"angt.  Ansonsten wird eine neue Datei erstellt.
 180
 181 Plot-Funktionen und der @"Ubersetzer erstellen grunds@"atzlich neue Dateien und
 182 die Funktionen @mref{tex} und @mref{appendfile} h@"angen die Ausgabe immer an
 183 eine bestehende Datei an.
 184 @end defvr
 185
 186 @c --- 28.08.2010 DK -----------------------------------------------------------
 187 @anchor{filename_merge}
 188 @deffn {Funktion} filename_merge (@var{path}, @var{filename})
 189
 190 Setzt einen Pfad aus @var{path} und @var{filename} zusammen.  Endet @var{path}
 191 mit einer Zeichenkette der Form @code{###.@var{something}}, wird diese
 192 Zeichenkette durch @code{@var{filename.something}} ersetzt.  Ansonsten
 193 wird der Endbestandteil durch @var{filename} ersetzt.
 194
 195 Die R@"uckgabe ist ein Lisp-Dateiname.
 196
 197 Beispiele:
 198
 199 @example
 200 (%i1) filename_merge("user/", "myfile");
 201 (%o1)                      user/myfile
 202
 203 (%i2) filename_merge("user/###.lisp", "myfile");
 204 (%o2)                   user/myfile.lisp
 205 @end example
 206 @end deffn
 207
 208 @c --- 09.11.2010 DK -----------------------------------------------------------
 209 @anchor{file_search}
 210 @deffn  {Funktion} file_search (@var{filename})
 211 @deffnx {Funktion} file_search (@var{filename}, @var{pathlist})
 212
 213 @code{file_search} sucht die Datei @var{filename} und gibt den Pfad als eine
 214 Zeichenkette zur@"uck, wenn die Datei gefunden wurde.  Ansonsten wird
 215 @code{false} zur@"uckgegeben.  @code{file_search(@var{filename})} sucht in den
 216 Standardsuchverzeichnissen, die mit den Optionsvariablen
 217 @mrefcomma{file_search_maxima} @mref{file_search_lisp} und
 218 @mref{file_search_demo} spezifiziert werden.
 219
 220 @code{file_search} pr@"uft zuerst, ob die Datei @code{filename} existiert.  Dann
 221 pr@"uft @code{file_search}, ob die Datei anhand von Mustern im Dateinamen
 222 gefunden werden kann.  Siehe @mref{file_search_maxima} f@"ur die Suche von
 223 Dateien.
 224
 225 Das Argument @var{filename} kann ein Name mit einer Pfadangabe oder allein der
 226 Dateiname sein.  Sind in den Suchverzeichnissen Dateinamen mit Mustern
 227 enthalten, kann die Datei auch ohne Endung angegeben werden.  Zum Beispiel
 228 finden die folgenden Kommandos dieselbe Datei, wenn
 229 @code{/home/wfs/special/###.mac} in der Liste @code{file_search_maxima}
 230 enthalten ist:
 231
 232 @example
 233 file_search ("/home/wfs/special/zeta.mac");
 234 file_search ("zeta.mac");
 235 file_search ("zeta");
 236 @end example
 237
 238 @code{file_search(@var{filename}, @var{pathlist})} sucht nur in den
 239 Verzeichnissen @var{pathlist}.  Das Argument @var{pathlist} @"uberschreibt die
 240 Standardsuchverzeichnisse.  Auch ein einzelnes Verzeichnis muss als eine Liste
 241 @"ubergeben werden.
 242
 243 Die Standardsuchverzeichnisse k@"onnen modifiziert werden.  Siehe dazu auch
 244 @mrefdot{file_search_maxima}
 245
 246 @code{file_search} wird von der Funktion @mref{load} mit den Verzeichnislisten
 247 @code{file_search_maxima} und @code{file_search_lisp} aufgerufen.
 248 @end deffn
 249
 250 @c --- 09.11.2010 DK -----------------------------------------------------------
 251 @anchor{file_search_maxima}
 252 @anchor{file_search_lisp}
 253 @anchor{file_search_demo}
 254 @anchor{file_search_usage}
 255 @anchor{file_search_tests}
 256 @defvr  {Optionsvariable} file_search_maxima
 257 @defvrx {Optionsvariable} file_search_lisp
 258 @defvrx {Optionsvariable} file_search_demo
 259 @defvrx {Optionsvariable} file_search_usage
 260 @defvrx {Optionsvariable} file_search_tests
 261
 262 Diese Optionsvariablen bezeichnen Listen mit Verzeichnissen, die von Funktionen
 263 wie @mref{load} und @mref{demo} durchsucht werden, um eine Datei zu finden.  Die
 264 Standardwerte bezeichnen verschiedene Verzeichnisse der Maxima-Installation.
 265
 266 Diese Variablen k@"onnen modifiziert werden, indem die Standardwerte ersetzt
 267 oder weitere Verzeichnisse angeh@"angt werden.  Zum Beispiel wird im Folgenden
 268 der Standardwert der Optionsvariablen @code{file_search_maxima} ersetzt:
 269
 270 @example
 271 file_search_maxima: ["/usr/local/foo/###.mac",
 272     "/usr/local/bar/###.mac"]$
 273 @end example
 274
 275 In diesem Beispiel werden zwei weitere Verzeichnisse zu der Optionsvariablen
 276 @code{file_search_maxima} hinzugef@"ugt:
 277
 278 @example
 279 file_search_maxima: append (file_search_maxima,
 280     ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$
 281 @end example
 282
 283 Soll eine erweiterte Liste der Suchverzeichnisse nach jedem Start von Maxima
 284 zur Verf@"ugung stehen, kann das obige Kommando in die Datei
 285 @code{maxima-init.mac} aufgenommen werden.
 286
 287 Mehrere Dateiendungen und Pfade k@"onnen mit Wildcard-Konstruktionen
 288 spezifiziert werden.  Eine Zeichenkette @code{###} wird durch einen Dateinamen
 289 ersetzt.  Werden mehrere Zeichenketten durch Kommata getrennt und mit
 290 geschweiften Klammern angegeben wie zum Beispiel @code{@{foo, bar, baz@}},
 291 expandiert die Liste in mehrere Zeichenketten.  Das folgende Beispiel expandiert
 292 f@"ur @code{neumann}
 293
 294 @example
 295 "/home/@{wfs,gcj@}/###.@{lisp,mac@}"
 296 @end example
 297
 298 in @code{/home/wfs/neumann.lisp}, @code{/home/gcj/neumann.lisp},
 299 @code{/home/wfs/neumann.mac} und @code{/home/gcj/neumann.mac}.
 300 @end defvr
 301
 302 @c --- 19.04.2011 DK -----------------------------------------------------------
 303 @anchor{file_type}
 304 @deffn {Funktion} file_type (@var{filename})
 305
 306 Gibt eine Vermutung @"uber den Typ der Datei @var{filename} zur@"uck.  Es
 307 wird nur die Dateiendung betrachtet.
 308
 309 Die R@"uckgabe ist das Symbol @code{maxima} oder @code{lisp}, wenn die
 310 Dateiendung einen der Werte der Optionsvariablen @mref{file_type_maxima} oder
 311 der Optionsvariablen @mref{file_type_lisp} entspricht.  Ansonsten ist die
 312 R@"uckgabe das Symbol @code{object}.
 313
 314 Siehe auch die Funktion @mrefdot{pathname_type}
 315 @end deffn
 316
 317 @c --- 19.04.2011 DK -----------------------------------------------------------
 318 @anchor{file_type_lisp}
 319 @defvr {Optionsvariable} file_type_lisp
 320 Standardwert:  @code{[l, lsp, lisp]}
 321
 322 Die Optionsvariable @code{file_type_lisp} enth@"alt die Dateiendungen, die
 323 Maxima als die Bezeichnung f@"ur eine Lisp-Datei annimmt.
 324
 325 Siehe auch die Funktion @mrefdot{file_type}
 326 @end defvr
 327
 328 @c --- 19.04.2011 DK -----------------------------------------------------------
 329 @anchor{file_type_maxima}
 330 @defvr {Optionsvariable} file_type_maxima
 331 Standardwert:  @code{[mac, mc, demo, dem, dm1, dm2, dm3, dmt]}
 332
 333 Die Optionsvariable @code{file_type_maxima} enth@"alt die Dateiendungen, die
 334 Maxima als die Bezeichnung f@"ur eine Maxima-Datei annimmt.
 335
 336 Siehe auch die Funktion @mrefdot{file_type}
 337 @end defvr
 338
 339 @c --- 28.08.2010 DK -----------------------------------------------------------
 340 @anchor{load}
 341 @deffn {Funktion} load (@var{filename})
 342
 343 Wertet die Ausdr@"ucke in der Datei @var{filename} aus, wodurch die Variablen,
 344 Funktionen und andere Objekte in Maxima geladen werden.  Alle bisher zugewiesen
 345 Variablen und Definitionen werden @"uberschrieben.  Um die Datei zu finden, wird
 346 von @code{load} die Funktion @mref{file_search} mit den Verzeichnislisten
 347 @mref{file_search_maxima} und @mref{file_search_lisp} aufgerufen.  Ist
 348 @code{load} erfolgreich, wird der Dateiname zur@"uckgegeben.  Ansonsten gibt
 349 @code{load} eine Fehlermeldung aus.
 350
 351 @code{load} verarbeitet Dateien mit Lisp-Code oder Maxima-Code.  Dateien, die
 352 mit den Funktionen @mrefcomma{save} @mref{translate_file} und
 353 @mref{compile_file} erstellt wurden, enthalten Lisp-Code.  Dateien, die mit
 354 @mref{stringout} erstellt wurden, enthalten Maxima-Code.  Die Ausgabedateien
 355 dieser Funktionen k@"onnen mit @code{load} geladen werden.  @code{load} ruft die
 356 Funktion @mref{loadfile} auf, um Lisp-Dateien und @mref{batchload} auf, um
 357 Maxima-Da@-tei@-en zu verarbeiten.
 358
 359 @code{load} erkennt keine @code{:lisp}-Unterbrechungskommandos in
 360 Maxima-Dateien.  Die Systemvariablen @mrefcomma{_} @mref{__} und @mref{%} und
 361 die Funktion @mref{%th} behalten jeweils ihren letzten Wert vor dem Aufruf von
 362 @code{load}.
 363
 364 Siehe auch die Funktionen @mrefcomma{loadfile} @mrefcomma{batch}
 365 @mref{batchload} und @mrefdot{demo}  @code{loadfile} verarbeitet
 366 Lisp-Da@-tei@-en.  @code{batch}, @code{batchload} und @code{demo} verarbeiten
 367 Maxima-Dateien.
 368
 369 Siehe @mref{file_search} f@"ur mehr Informationen, wie Maxima Dateien in
 370 Verzeichnissen findet.  @code{load} wertet die Argumente aus.
 371 @end deffn
 372
 373 @c --- 09.11.2010 DK -----------------------------------------------------------
 374 @anchor{load_pathname}
 375 @defvr {Systemvariable} load_pathname
 376 Standardwert: @code{false}
 377
 378 Wird eine Datei mit den Funktionen @mrefcomma{load} @mref{loadfile} oder
 379 @mref{batchload} geladen, enth@"alt die Systemvariable @code{load_pathname}
 380 den Namen der Datei.  Der Wert der Systemvariablen kann in der Datei, die
 381 geladen wird, ausgelesen werden.
 382
 383 Beispiele:
 384
 385 Ist eine Batch-Datei mit den Namen @code{test.mac} in dem Verzeichnis
 386 @example
 387 "/home/dieter/workspace/mymaxima/temp/"
 388 @end example
 389 abgelegt und enth@"alt die Datei die folgenden Befehle
 390
 391 @example
 392 print("The value of load_pathname is: ", load_pathname)$
 393 print("End of batchfile")$
 394 @end example
 395
 396 dann wird das Folgende ausgegeben:
 397
 398 @example
 399 (%i1) load("/home/dieter/workspace/mymaxima/temp/test.mac")$
 400 The value of load_pathname is:
 401               /home/dieter/workspace/mymaxima/temp/test.mac
 402 End of batchfile
 403 @end example
 404 @end defvr
 405
 406 @c --- 09.11.2010 DK -----------------------------------------------------------
 407 @anchor{loadfile}
 408 @deffn {Funktion} loadfile (@var{filename})
 409
 410 L@"adt die Datei @var{filename} und wertet die Lisp-Ausdr@"ucke in der Datei
 411 aus.  @code{filename} ruft nicht @mref{file_search} auf, um eine Datei zu
 412 finden.  Daher muss @code{filename} ein voll@-st@"an@-di@-ger Dateiname sein.
 413
 414 @code{loadfile} kann Dateien verarbeiten, die mit den Funktionen
 415 @mrefcomma{save} @mref{translate_file} und @mref{compile_file} erzeugt wurden.
 416 @end deffn
 417
 418 @c --- 09.11.2010 DK -----------------------------------------------------------
 419 @anchor{loadprint}
 420 @defvr {Optionsvariable} loadprint
 421 Standardwert: @code{true}
 422
 423 @code{loadprint} kontrolliert, ob Meldungen ausgegeben werden, wenn eine Datei
 424 geladen wird.
 425
 426 @itemize @bullet
 427 @item Hat @code{loadprint} den Wert @code{true}, wird immer eine Meldung
 428       ausgegeben.
 429 @item Hat @code{loadprint} den Wert @code{'loadfile}, wird eine Meldung
 430       ausgegeben, wenn die Datei mit der Funktion @mref{loadfile} geladen wird.
 431 @item Hat @code{loadprint} den Wert @code{'autoload}, wird eine Meldung
 432       ausgegeben, wenn eine Datei automatisch geladen wird.
 433 @item Hat @code{loadprint} den Wert @code{false}, werden keine Meldungen beim
 434       Laden von Dateien ausgegeben.
 435 @end itemize
 436 @end defvr
 437
 438 @c -----------------------------------------------------------------------------
 439 @anchor{pathname_directory}
 440 @anchor{pathname_name}
 441 @anchor{pathname_type}
 442 @deffn  {Funktion} pathname_directory (@var{pathname})
 443 @deffnx {Funktion} pathname_name (@var{pathname})
 444 @deffnx {Funktion} pathname_type (@var{pathname})
 445
 446 Diese Funktionen geben die Bestandteile eines Pfadnamens zur@"uck.
 447
 448 Beispiele:
 449
 450 @example
 451 (%i1) pathname_directory("/home/dieter/maxima/changelog.txt");
 452 (%o1)                 /home/dieter/maxima/
 453 (%i2) pathname_name("/home/dieter/maxima/changelog.txt");
 454 (%o2)                       changelog
 455 (%i3) pathname_type("/home/dieter/maxima/changelog.txt");
 456 (%o3)                          txt
 457 @end example
 458 @end deffn
 459
 460 @c --- 09.11.2010 DK -----------------------------------------------------------
 461 @anchor{printfile}
 462 @deffn {Funktion} printfile (@var{path})
 463
 464 Druckt eine Datei mit dem Namen @var{path} auf der Konsole aus.  @var{path} kann
 465 ein Symbol oder eine Zeichenkette sein.  @code{printfile} sucht die Datei in den
 466 Verzeichnissen, die in der Optionsvariablen @mref{file_search_usage} enthalten
 467 sind.
 468
 469 @code{printfile} gibt @var{path} zur@"uck, wenn die Datei existiert.
 470 @end deffn
 471
 472 @c --- 11.11.2010 DK -----------------------------------------------------------
 473 @anchor{save}
 474 @deffn  {Funktion} save (@var{filename}, @var{name_1}, @var{name_2}, @var{name_3}, @dots{})
 475 @deffnx {Funktion} save (@var{filename}, values, functions, labels, @dots{})
 476 @deffnx {Funktion} save (@var{filename}, [@var{m}, @var{n}])
 477 @deffnx {Funktion} save (@var{filename}, @var{name_1}=@var{expr_1}, @dots{})
 478 @deffnx {Funktion} save (@var{filename}, all)
 479 @deffnx {Funktion} save (@var{filename}, @var{name_1}=@var{expr_1}, @var{name_2}=@var{expr_2}, @dots{})
 480
 481 Speichert die aktuellen Werte von @var{name_1}, @var{name_2}, @var{name_3},
 482 @dots{}, in die Datei @var{filename}.  Die Argumente sind die Namen von
 483 Variablen, Funktionen oder anderen Objekten.  Argumente, die keinen Wert haben,
 484 werden ignoriert.  @code{save} gibt den Namen der Datei @code{filename}
 485 zur@"uck.
 486
 487 @code{save} speichert die Daten in einem Lisp-Format.  Die gespeicherten Daten
 488 k@"onnen mit dem Kommando @code{load(@var{filename})} zur@"uckgelesen werden.
 489 Siehe @mrefdot{load}
 490
 491 Die Optionsvariable @mref{file_output_append} kontrolliert, ob @code{save} die
 492 Daten an die Ausgabedatei anh@"angt, wenn diese bereits existiert, oder die
 493 Ausgabedatei zuvor l@"oscht.  Hat @code{file_output_append} den Wert
 494 @code{true}, werden die Daten angeh@"angt.  Ansonsten wird die Datei gel@"oscht
 495 und neu angelegt, wenn diese bereits existiert.  Existiert die Ausgabedatei
 496 noch nicht, wird diese angelegt.
 497
 498 @code{save(@var{filename}, values, functions, labels, ...)} speichert die
 499 Werte aller Ein@-tr@"a@-ge der Listen @code{values}, @code{functions},
 500 @code{labels}, u.s.w. in die Ausgabedatei.  Es kann jede der vorhandenen
 501 Informationslisten, die in der Systemvariablen @code{infolists} enthalten ist,
 502 als Argument @"ubergeben werden.  @code{values} enth@"alt zum Beispiel alle vom
 503 Nutzer definierten Variablen.
 504
 505 @code{save(@var{filename}, [@var{m}, @var{n}])} speichert die Werte der Eingabe-
 506 und Ausgabemarken von @var{m} bis @var{n}.  @var{m} und @var{n} m@"ussen ganze
 507 Zahlen sein.  Die Eingabe- und Ausgabemarken k@"onnen auch einzeln gespeichert
 508 werden, zum Beispiel mit dem Kommando @code{save("foo.1", %i42, %o42)}.
 509 @code{save(@var{filename}, labels)} speichert alle Eingabe- und Ausgabemarken.
 510 Beim Zur@"ucklesen der Marken werden vorhandene Werte @"uberschrieben.
 511
 512 @code{save(@var{filename}, @var{name_1} = @var{expr_1}, @var{name_2} =
 513 @var{expr_2}, ...)} speichert die Werte @var{expr_1}, @var{expr_2}, @dots{},
 514 unter den Namen @var{name_1}, @var{name_2}, @dots{} ab.  Dies kann  n@"utz@-lich
 515 sein, um zum Beispiel die Werte von Marken unter einem neuen Namen
 516 abzuspeichern.  Die rechte Seite der Gleichungen kann ein beliebiger
 517 ausgewerteter Ausdruck sein.  Die neuen Namen werden der aktuellen Sitzung nicht
 518 hinzugef@"ugt und nur in der Ausgabedatei gespeichert.
 519
 520 Die verschiedenen M@"oglichkeiten der Funktion @code{save}, k@"onnen
 521 miteinander kombiniert werden.  Das Kommando
 522 @code{save(@var{filename}, aa, bb, cc=42, functions, [11,17])} ist daf@"ur ein
 523 Beispiel.
 524
 525 @code{save(@var{filename}, all)} speichert den aktuellen Zustand von Maxima
 526 in eine Ausgabedatei.  Eingeschlossen sind alle nutzerdefinierten Variablen,
 527 Funktionen oder Arrays, einschlie@ss{}lich automatischer Definitionen.  Die
 528 gespeicherten Daten enthalten auch die Werte von ge@"anderten System- oder
 529 Optionsvariablen.  Siehe dazu auch @mrefdot{myoptions}
 530
 531 @code{save} wertet das Argument @var{filename} aus.  Alle anderen Argumente
 532 werden nicht ausgewertet.
 533 @end deffn
 534
 535 @c --- 11.11.2010 DK -----------------------------------------------------------
 536 @anchor{stringout}
 537 @deffn  {Funktion} stringout (@var{filename}, @var{expr_1}, @var{expr_2}, @var{expr_3}, @dots{})
 538 @deffnx {Funktion} stringout (@var{filename}, [@var{m}, @var{n}])
 539 @deffnx {Funktion} stringout (@var{filename}, input)
 540 @deffnx {Funktion} stringout (@var{filename}, functions)
 541 @deffnx {Funktion} stringout (@var{filename}, values)
 542
 543 @code{stringout} schreibt Ausdr@"ucke in einem Format in eine Datei, dass
 544 identisch mit dem Format der Eingabe ist.  Die Datei kann als Eingabedatei f@"ur
 545 die Funktionen @mref{batch} oder @mref{demo} genutzt werden.  Sie kann mit
 546 einem Texteditor f@"ur jeden Zweck editiert werden.  @code{stringout} kann
 547 ausgef@"uhrt werden, wenn das Kommando @mref{writefile} aktiv ist.
 548
 549 Die Optionsvariable @mref{file_output_append} kontrolliert, ob @code{stringout}
 550 die Daten an die Ausgabedatei anh@"angt, wenn diese bereits existiert oder die
 551 Ausgabedatei zuvor l@"oscht.  Hat @code{file_output_append} den Wert
 552 @code{true}, werden die Daten angeh@"angt, wenn die Datei bereits existiert.
 553 Ansonsten wird die Datei gel@"oscht und neu angelegt.  Existiert die
 554 Ausgabedatei noch nicht, wird diese angelegt.
 555
 556 Die allgemeine Form von @code{stringout} schreibt die Werte eines oder mehrerer
 557 Ausdr@"ucke in die Ausgabedatei.  Ist ein Ausdruck eine Variable, wird nur der
 558 Wert der Variablen, nicht jedoch der Name der Variablen in die Ausgabedatei
 559 geschrieben.  Ein n@"utzlicher Spezialfall ist, dass die Werte der Eingabe-
 560 und Ausgabemarken (@code{%i1}, @code{%i2}, @code{%i3}, @dots{} und @code{%o1},
 561 @code{%o2}, @code{%o3}, @dots{}) in die Datei geschrieben werden k@"onnen.
 562
 563 Hat die Optionsvariable @code{grind} den Wert @code{true}, wird die Ausgabe
 564 im Format der Funktion @mref{grind} in die Ausgabedatei geschrieben.  Ansonsten
 565 wird das Format der Funktion @mref{string} f@"ur die Ausgabe genutzt.
 566
 567 @code{stringout(@var{filename}, [@var{m}, @var{n}])} schreibt die Werte aller
 568 Eingabemarken von @var{m} bis @var{n} in die Ausgabedatei.
 569 @code{stringout(@var{filename}, input)} schreibt alle Eingabemarken in die
 570 Ausgabedatei.  @code{stringout(@var{filename}, functions)} schreibt alle vom
 571 Nutzer definierten Funktionen, die in der Informationsliste @code{functions}
 572 enthalten sind, in die Ausgabedatei.
 573
 574 @code{stringout(@var{filename}, values)} schreibt alle benuzterdefinierten
 575 Variablen, die in der Informationsliste @code{values} enthalten sind, in die
 576 Ausgabedatei.  Die Variablen werden als eine Zuweisung, mit dem Namen der
 577 Variablen, dem Zuweisungsoperator @code{:} und dem Wert in die Datei
 578 geschrieben.  Im Unterschied dazu, speichert die allgemeine Form der Funktion
 579 @code{stringout} die Variablen nicht als Zuweisung.
 580 @end deffn
 581
 582 @c --- 28.08.2010 DK -----------------------------------------------------------
 583 @anchor{with_stdout}
 584 @deffn  {Funktion} with_stdout (@var{f}, @var{expr_1}, @var{expr_2}, @var{expr_3}, @dots{})
 585 @deffnx {Funktion} with_stdout (@var{s}, @var{expr_1}, @var{expr_2}, @var{expr_3}, @dots{})
 586
 587 @code{with_stdout} wertet Argumente @var{expr_1}, @var{expr_2}, @var{expr_3},
 588 @dots{} aus und schreibt die Ergebnisse der Auswertung in die Ausgabedatei
 589 @code{f} oder in den Stream @code{s}.  Die Ergebnisse werden nicht auf der
 590 Konsole ausgegeben.
 591
 592 Die Optionsvariable @code{file_output_append} bestimmt, ob @code{with_stdout}
 593 die Daten an die Ausgabedatei anh@"angt oder die Ausgabedatei zuvor l@"oscht.
 594 Hat @code{file_output_append} den Wert @code{true}, werden die Daten
 595 angeh@"angt.  Ansonsten wird die Datei gel@"oscht und neu angelegt.  Existiert
 596 die Ausgabedatei noch nicht, wird diese angelegt.
 597
 598 @code{with_stout} gibt das Ergebnis des letzten Argumentes zur@"uck.
 599
 600 Siehe auch @mrefdot{writefile}
 601
 602 Beispiel:
 603
 604 @example
 605 (%i1) with_stdout ("tmp.out", for i:5 thru 10 do
 606          print (i, "! yields", i!))$
 607 (%i2) printfile ("tmp.out")$
 608 5 ! yields 120
 609 6 ! yields 720
 610 7 ! yields 5040
 611 8 ! yields 40320
 612 9 ! yields 362880
 613 10 ! yields 3628800
 614 @end example
 615 @end deffn
 616
 617 @c --- 03.09.2010 DK -----------------------------------------------------------
 618 @anchor{writefile}
 619 @deffn {Funktion} writefile (@var{filename})
 620
 621 Startet eine Aufzeichnung aller Ein- und Ausgaben der Konsole.  Die Ein- und
 622 Ausgaben werden in die Datei @var{filename} geschrieben.
 623
 624 Die Ausgabedatei kann von Maxima nicht wieder zur@"uckgelesen werden.  Um ein
 625 Datei zu erzeugen, die von Maxima zur@"uckgelesen werden kann, siehe die
 626 Funktionen @mref{save} und @mrefdot{stringout}  @code{save} speichert
 627 Ausdr@"ucke in einem Lisp-Format und @code{stringout} in einem Maxima-Format.
 628
 629 Die Reaktion der Funktion @code{writefile} f@"ur den Fall, dass die Ausgabedatei
 630 bereits existiert, h@"angt von der Lisp-Implementation ab.  Die Ausgabedatei
 631 kann zur@"uckgesetzt werden oder die Daten werden angeh@"angt.  Die Funktion
 632 @mref{appendfile} h@"angt die Daten immer an eine existierende Datei an.
 633
 634 Um eine Aufzeichnung ohne Textausgaben von Funktionen zu erhalten, kann
 635 @code{writefile} nach der Ausf@"uhrung von @code{playback} ausgef@"uhrt werden.
 636 @code{playback} gibt alle vorhergenden Eingabe- und Ausgabemarken aus, jedoch
 637 nicht sonstige Textausgaben von Maxima-Funktionen.
 638
 639 Mit @mref{closefile} wird die Aufzeichnung beendet.
 640 @end deffn
 641
 642 @c -----------------------------------------------------------------------------
 643 @node Funktionen und Variablen f@"ur die TeX-Ausgabe, Funktionen und Variablen f@"ur die Fortran-Ausgabe, Funktionen und Variablen f@"ur die Eingabe und Ausgabe, Eingabe und Ausgabe
 644 @section Funktionen und Variablen f@"ur die TeX-Ausgabe
 645 @c -----------------------------------------------------------------------------
 646
 647 @c -----------------------------------------------------------------------------
 648 @anchor{tex}
 649 @deffn  {Function} tex (@var{expr})
 650 @deffnx {Function} tex (@var{expr}, @var{destination})
 651 @deffnx {Function} tex (@var{expr}, false)
 652 @deffnx {Function} tex (@var{label})
 653 @deffnx {Function} tex (@var{label}, @var{destination})
 654 @deffnx {Function} tex (@var{label}, false)
 655
 656 Prints a representation of an expression suitable for the TeX document
 657 preparation system. The result is a fragment of a document, which can be copied
 658 into a larger document but not processed by itself.
 659
 660 @code{tex (@var{expr})} prints a TeX representation of @var{expr} on the
 661 console.
 662
 663 @code{tex (@var{label})} prints a TeX representation of the expression named by
 664 @var{label} and assigns it an equation label (to be displayed to the left of
 665 the expression). The TeX equation label is the same as the Maxima label.
 666
 667 @var{destination} may be an output stream or file name. When @var{destination}
 668 is a file name, @code{tex} appends its output to the file. The functions
 669 @code{openw} and @code{opena} create output streams.
 670
 671 @code{tex (@var{expr}, false)} and @code{tex (@var{label}, false)} return their
 672 TeX output as a string.
 673
 674 @code{tex} evaluates its first argument after testing it to see if it is a
 675 label. Quote-quote @code{''} forces evaluation of the argument, thereby
 676 defeating the test and preventing the label.
 677
 678 See also @code{texput}.
 679
 680 Examples:
 681
 682 @example
 683 (%i1) integrate (1/(1+x^3), x);
 684                                     2 x - 1
 685                   2            atan(-------)
 686              log(x  - x + 1)        sqrt(3)    log(x + 1)
 687 (%o1)      - --------------- + ------------- + ----------
 688                     6             sqrt(3)          3
 689 (%i2) tex (%o1);
 690 $$-@{@{\log \left(x^2-x+1\right)@}\over@{6@}@}+@{@{\arctan \left(@{@{2\,x-1
 691  @}\over@{\sqrt@{3@}@}@}\right)@}\over@{\sqrt@{3@}@}@}+@{@{\log \left(x+1\right)
 692  @}\over@{3@}@}\leqno@{\tt (\%o1)@}$$
 693 (%o2)                          (\%o1)
 694 (%i3) tex (integrate (sin(x), x));
 695 $$-\cos x$$
 696 (%o3)                           false
 697 (%i4) tex (%o1, "foo.tex");
 698 (%o4)                          (\%o1)
 699 @end example
 700
 701 @code{tex (@var{expr}, false)} returns its TeX output as a string.
 702
 703 @example
 704 (%i1) S : tex (x * y * z, false);
 705 (%o1) $$x\,y\,z$$
 706 (%i2) S;
 707 (%o2) $$x\,y\,z$$
 708 @end example
 709 @end deffn
 710
 711 @c -----------------------------------------------------------------------------
 712 @anchor{tex1}
 713 @deffn {Function} tex1 (@var{e})
 714
 715 Returns a string which represents the TeX output for the expressions @var{e}.
 716 The TeX output is not enclosed in delimiters for an equation or any other
 717 environment.
 718
 719 Examples:
 720
 721 @example
 722 (%i1) tex1 (sin(x) + cos(x));
 723 (%o1)                     \sin x+\cos x
 724 @end example
 725 @end deffn
 726
 727 @c -----------------------------------------------------------------------------
 728 @anchor{texput}
 729 @deffn  {Function} texput (@var{a}, @var{s})
 730 @deffnx {Function} texput (@var{a}, @var{f})
 731 @deffnx {Function} texput (@var{a}, @var{s}, @var{operator_type})
 732 @deffnx {Function} texput (@var{a}, [@var{s_1}, @var{s_2}], matchfix)
 733 @deffnx {Function} texput (@var{a}, [@var{s_1}, @var{s_2}, @var{s_3}], matchfix)
 734
 735 Assign the TeX output for the atom @var{a}, which can be a symbol or the name
 736 of an operator.
 737
 738 @code{texput (@var{a}, @var{s})} causes the @code{tex} function to interpolate
 739 the string @var{s} into the TeX output in place of @var{a}.
 740
 741 @code{texput (@var{a}, @var{f})} causes the @code{tex} function to call the
 742 function @var{f} to generate TeX output. @var{f} must accept one argument,
 743 which is an expression which has operator @var{a}, and must return a string
 744 (the TeX output). @var{f} may call @code{tex1} to generate TeX output for the
 745 arguments of the input expression.
 746
 747 @code{texput (@var{a}, @var{s}, @var{operator_type})}, where @var{operator_type}
 748 is @code{prefix}, @code{infix}, @code{postfix}, @code{nary}, or @code{nofix},
 749 causes the @code{tex} function to interpolate @var{s} into the TeX output in
 750 place of @var{a}, and to place the interpolated text in the appropriate
 751 position.
 752
 753 @code{texput (@var{a}, [@var{s_1}, @var{s_2}], matchfix)} causes the @code{tex}
 754 function to interpolate @var{s_1} and @var{s_2} into the TeX output on either
 755 side of the arguments of @var{a}. The arguments (if more than one) are separated
 756 by commas.
 757
 758 @code{texput (@var{a}, [@var{s_1}, @var{s_2}, @var{s_3}], matchfix)} causes the
 759 @code{tex} function to interpolate @var{s_1} and @var{s_2} into the TeX output
 760 on either side of the arguments of @var{a}, with @var{s_3} separating the
 761 arguments.
 762
 763 Examples:
 764
 765 Assign TeX output for a variable.
 766
 767 @example
 768 (%i1) texput (me,"\\mu_e");
 769 (%o1)                         \mu_e
 770 (%i2) tex (me);
 771 $$\mu_e$$
 772 (%o2)                         false
 773 @end example
 774
 775 Assign TeX output for an ordinary function (not an operator).
 776
 777 @example
 778 (%i1) texput (lcm, "\\mathrm@{lcm@}");
 779 (%o1)                     \mathrm@{lcm@}
 780 (%i2) tex (lcm (a, b));
 781 $$\mathrm@{lcm@}\left(a , b\right)$$
 782 (%o2)                         false
 783 @end example
 784
 785 Call a function to generate TeX output.
 786
 787 @example
 788 (%i1) texfoo (e) := block ([a, b], [a, b] : args (e),
 789   concat ("\\left[\\stackrel@{", tex1 (b),
 790           "@}@{", tex1 (a), "@}\\right]"))$
 791 (%i2) texput (foo, texfoo);
 792 (%o2)                        texfoo
 793 (%i3) tex (foo (2^x, %pi));
 794 $$\left[\stackrel@{\pi@}@{2^@{x@}@}\right]$$
 795 (%o3)                         false
 796 @end example
 797
 798 Assign TeX output for a prefix operator.
 799
 800 @example
 801 (%i1) prefix ("grad");
 802 (%o1)                         grad
 803 (%i2) texput ("grad", " \\nabla ", prefix);
 804 (%o2)                        \nabla
 805 (%i3) tex (grad f);
 806 $$ \nabla f$$
 807 (%o3)                         false
 808 @end example
 809
 810 Assign TeX output for an infix operator.
 811
 812 @example
 813 (%i1) infix ("~");
 814 (%o1)                           ~
 815 (%i2) texput ("~", " \\times ", infix);
 816 (%o2)                        \times
 817 (%i3) tex (a ~ b);
 818 $$a \times b$$
 819 (%o3)                         false
 820 @end example
 821
 822 Assign TeX output for a postfix operator.
 823
 824 @example
 825 (%i1) postfix ("##");
 826 (%o1)                          ##
 827 (%i2) texput ("##", "!!", postfix);
 828 (%o2)                          !!
 829 (%i3) tex (x ##);
 830 $$x!!$$
 831 (%o3)                         false
 832 @end example
 833
 834 Assign TeX output for a nary operator.
 835
 836 @example
 837 (%i1) nary ("@@@@");
 838 (%o1)                          @@@@
 839 (%i2) texput ("@@@@", " \\circ ", nary);
 840 (%o2)                         \circ
 841 (%i3) tex (a @@@@ b @@@@ c @@@@ d);
 842 $$a \circ b \circ c \circ d$$
 843 (%o3)                         false
 844 @end example
 845
 846 Assign TeX output for a nofix operator.
 847
 848 @example
 849 (%i1) nofix ("foo");
 850 (%o1)                          foo
 851 (%i2) texput ("foo", "\\mathsc@{foo@}", nofix);
 852 (%o2)                     \mathsc@{foo@}
 853 (%i3) tex (foo);
 854 $$\mathsc@{foo@}$$
 855 (%o3)                         false
 856 @end example
 857
 858 Assign TeX output for a matchfix operator.
 859
 860 @example
 861 (%i1) matchfix ("<<", ">>");
 862 (%o1)                          <<
 863 (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
 864 (%o2)                [ \langle ,  \rangle ]
 865 (%i3) tex (<<a>>);
 866 $$ \langle a \rangle $$
 867 (%o3)                         false
 868 (%i4) tex (<<a, b>>);
 869 $$ \langle a , b \rangle $$
 870 (%o4)                         false
 871 (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
 872       matchfix);
 873 (%o5)           [ \langle ,  \rangle ,  \, | \,]
 874 (%i6) tex (<<a>>);
 875 $$ \langle a \rangle $$
 876 (%o6)                         false
 877 (%i7) tex (<<a, b>>);
 878 $$ \langle a \, | \,b \rangle $$
 879 (%o7)                         false
 880 @end example
 881 @end deffn
 882
 883 @c -----------------------------------------------------------------------------
 884 @anchor{get_tex_enviroment}
 885 @anchor{set_tex_enviroment}
 886 @deffn  {Function} get_tex_environment (@var{op})
 887 @deffnx {Function} set_tex_environment (@var{op}, @var{before}, @var{after})
 888
 889 Customize the TeX environment output by @code{tex}.
 890 As maintained by these functions, the TeX environment comprises two strings:
 891 one is printed before any other TeX output, and the other is printed after.
 892
 893 Only the TeX environment of the top-level operator in an expression
 894 is output; TeX environments associated with other operators are ignored.
 895
 896 @code{get_tex_environment} returns the TeX enviroment which is applied
 897 to the operator @var{op}; returns the default if no other environment
 898 has been assigned.
 899
 900 @code{set_tex_environment} assigns the TeX environment for the operator
 901 @var{op}.
 902
 903 Examples:
 904
 905 @example
 906 (%i1) get_tex_environment (":=");
 907 (%o1) [
 908 \begin@{verbatim@}
 909 , ;
 910 \end@{verbatim@}
 911 ]
 912 (%i2) tex (f (x) := 1 - x);
 913
 914 \begin@{verbatim@}
 915 f(x):=1-x;
 916 \end@{verbatim@}
 917
 918 (%o2)                         false
 919 (%i3) set_tex_environment (":=", "$$", "$$");
 920 (%o3)                       [$$, $$]
 921 (%i4) tex (f (x) := 1 - x);
 922 $$f(x):=1-x$$
 923 (%o4)                         false
 924 @end example
 925 @end deffn
 926
 927 @c -----------------------------------------------------------------------------
 928 @anchor{get_tex_enviroment_default}
 929 @anchor{set_tex_enviroment_default}
 930 @deffn  {Function} get_tex_environment_default ()
 931 @deffnx {Function} set_tex_environment_default (@var{before}, @var{after})
 932
 933 Customize the TeX environment output by @code{tex}.
 934 As maintained by these functions, the TeX environment comprises two strings:
 935 one is printed before any other TeX output, and the other is printed after.
 936
 937 @code{get_tex_environment_default} returns the TeX environment which is
 938 applied to expressions for which the top-level operator has no
 939 specific TeX environment (as assigned by @code{set_tex_environment}).
 940
 941 @code{set_tex_environment_default} assigns the default TeX environment.
 942
 943 Examples:
 944
 945 @example
 946 (%i1) get_tex_environment_default ();
 947 (%o1)                       [$$, $$]
 948 (%i2) tex (f(x) + g(x));
 949 $$g\left(x\right)+f\left(x\right)$$
 950 (%o2)                         false
 951 (%i3) set_tex_environment_default ("\\begin@{equation@}
 952 ", "
 953 \\end@{equation@}");
 954 (%o3) [\begin@{equation@}
 955 ,
 956 \end@{equation@}]
 957 (%i4) tex (f(x) + g(x));
 958 \begin@{equation@}
 959 g\left(x\right)+f\left(x\right)
 960 \end@{equation@}
 961 (%o4)                         false
 962 @end example
 963 @end deffn
 964
 965 @c -----------------------------------------------------------------------------
 966 @node Funktionen und Variablen f@"ur die Fortran-Ausgabe, , Funktionen und Variablen f@"ur die TeX-Ausgabe, Eingabe und Ausgabe
 967 @section Funktionen und Variablen f@"ur die Fortran-Ausgabe
 968 @c -----------------------------------------------------------------------------
 969
 970 @c -----------------------------------------------------------------------------
 971 @defvr {Option variable} fortindent
 972 Default value: @code{0}
 973
 974 @code{fortindent} controls the left margin indentation of
 975 expressions printed out by the @mref{fortran} command.  @code{0} gives normal
 976 printout (i.e., 6 spaces), and positive values will causes the
 977 expressions to be printed farther to the right.
 978 @end defvr
 979
 980 @c -----------------------------------------------------------------------------
 981 @anchor{fortran}
 982 @deffn {Function} fortran (@var{expr})
 983
 984 Prints @var{expr} as a Fortran statement.
 985 The output line is indented with spaces.
 986 If the line is too long, @code{fortran} prints continuation lines.
 987 @code{fortran} prints the exponentiation operator @code{^} as @code{**},
 988 and prints a complex number @code{a + b %i} in the form @code{(a,b)}.
 989
 990 @var{expr} may be an equation. If so, @code{fortran} prints an assignment
 991 statement, assigning the right-hand side of the equation to the left-hand side.
 992 In particular, if the right-hand side of @var{expr} is the name of a matrix,
 993 then @code{fortran} prints an assignment statement for each element of the
 994 matrix.
 995
 996 If @var{expr} is not something recognized by @code{fortran},
 997 the expression is printed in @mref{grind} format without complaint.
 998 @code{fortran} does not know about lists, arrays, or functions.
 999
1000 @code{fortindent} controls the left margin of the printed lines.
1001 @code{0} is the normal margin (i.e., indented 6 spaces). Increasing
1002 @code{fortindent} causes expressions to be printed further to the right.
1003
1004 When @mref{fortspaces} is @code{true}, @code{fortran} fills out
1005 each printed line with spaces to 80 columns.
1006
1007 @code{fortran} evaluates its arguments;
1008 quoting an argument defeats evaluation.
1009 @code{fortran} always returns @code{done}.
1010
1011 See also the function @mxref{function_f90, f90} for printing one or more
1012 expressions as a Fortran 90 program.
1013
1014 Examples:
1015
1016 @verbatim
1017 (%i1) expr: (a + b)^12$
1018 (%i2) fortran (expr);
1019       (b+a)**12
1020 (%o2)                         done
1021 (%i3) fortran ('x=expr);
1022       x = (b+a)**12
1023 (%o3)                         done
1024 (%i4) fortran ('x=expand (expr));
1025       x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792
1026      1   *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b
1027      2   **3+66*a**10*b**2+12*a**11*b+a**12
1028 (%o4)                         done
1029 (%i5) fortran ('x=7+5*%i);
1030       x = (7,5)
1031 (%o5)                         done
1032 (%i6) fortran ('x=[1,2,3,4]);
1033       x = [1,2,3,4]
1034 (%o6)                         done
1035 (%i7) f(x) := x^2$
1036 (%i8) fortran (f);
1037       f
1038 (%o8)                         done
1039 @end verbatim
1040 @end deffn
1041
1042 @c -----------------------------------------------------------------------------
1043 @anchor{fortspaces}
1044 @defvr {Option variable} fortspaces
1045 Default value: @code{false}
1046
1047 When @code{fortspaces} is @code{true}, @code{fortran} fills out
1048 each printed line with spaces to 80 columns.
1049 @end defvr
1050
1051 @c --- End of Input.de.texi ----------------------------------------------------
1052