FullForm , Echo , PrettyForm , EvalFormula , Write , WriteString , Space , NewLine , FromFile , FromString , ToFile , ToString , Read , LispRead , ReadToken , Load , Use , DefLoad , FindFile , PatchLoad , Nl .

Ein- und Ausgabe

In diesem Kapitel werden die Befehle für die Ein- und Ausgabe erläutert. Alle Ausgabebefehle schreiben in den sogenannten "current output", die meisten Eingabebefehle lesen vom "current input". In beiden Fällen ist das normalerweise die Konsole. Die Ein- und Ausgabe kann aber durch spezielle Befehle auch umgeleitet werden.

FullForm Ausgabe eines Ausdrucks im LISP-Format
Echo Ausgaberoutine
PrettyForm formatierte Ausgabe
EvalFormula formatierte Darstellung einer Berechnung
Write elementare Ausgaberoutine
WriteString elementare Ausgaberoutine für Strings
Space Ausgabe von Leerzeichen
NewLine Ausgabe von Zeilenvorschüben
FromFile Eingabeumleitung zum Lesen aus einer Datei
FromString Eingabeumleitung zum Lesen aus einem String
ToFile Ausgabeumleitung zur Ausgabe in eine Datei
ToString Ausgabeumleitung zur Ausgabe in einen String
Read einen Ausdruck einlesen
LispRead einen Ausdruck in LISP-Syntax einlesen
ReadToken ein Token einlesen
Load alle in einer Datei enthaltenen Ausdrücke auswerten
Use eine Datei einmalig einlesen
DefLoad eine .def-Datei einlesen
FindFile eine Datei suchen
PatchLoad alle Befehle zwischen <? und ?> einer Datei ausführen
Nl Zeilenvorschubzeichen


FullForm -- Ausgabe eines Ausdrucks im LISP-Format

interne Funktion
Funktionsaufruf:
FullForm(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Der Ausdruck "expr" wird berechnet und gefolgt von einem Zeilenvorschub im LISP-Format ausgegeben. Der berechnete Ausdruck wird als Funktionswert zurückgegeben.
Beispiele:
In> FullForm(a+b+c);
(+ (+ a b )c )
Out> a+b+c;

In> FullForm(2*I*b^2);
(* (Complex 0 2 )(^ b 2 ))
Out> Complex(0,2)*b^2;

Das erste Beispiel zeigt die interne Darstellung des Ausdrucks a+b+c. Im zweiten Beispiel wird zunächst 2*I umgerechnet in Complex(0,2), bevor der Ausdruck ausgegeben wird.
siehe auch:
LispRead , Listify , Unlist .


Echo -- Ausgaberoutine

mathematische Standardbibliothek
Funktionsaufruf:
Echo(item)
Echo(list)
Parameter:
item - ein Ausdruck
list - eine Liste
Beschreibung:
Der Ausdruck "item" wird berechnet und gefolgt von einem Zeilenvorschub ausgegeben. Ist "item" ein String, wird dieser ohne die Anführungszeichen ausgegeben.

In der zweiten Form werden alle Listenelemente nacheinander ausgegeben.

Das Ergebnis von Echo ist immer True.
Beispiele:
In> Echo(5+3);
 8
Out> True;

In> Echo({"The square of two is ", 2*2});
The square of two is  4
Out> True;

Zum Ausdrucken einer Liste muss die zweite Form verwendet werden:

In> Echo({a,b,c});
a  b  c
Out> True;

In> Echo({{a,b,c}});
{a,b,c}
Out> True;
siehe auch:
PrettyForm , Write , WriteString .


PrettyForm -- formatierte Ausgabe

mathematische Standardbibliothek
Funktionsaufruf:
PrettyForm(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Der Ausdruck "expr" wird berechnet und das Ergebnis übersichtlich formatiert ausgegeben.
Beispiele:
In> Taylor(x,0,9)Sin(x)
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880;

In> PrettyForm(%)

     3    5      7       9
    x    x      x       x
x - -- + --- - ---- + ------
    6    120   5040   362880

Out> True;
siehe auch:
EvalFormula , PrettyPrinter .


EvalFormula -- formatierte Darstellung einer Berechnung

mathematische Standardbibliothek
Funktionsaufruf:
EvalFormula(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Stellt eine Berechnung in ansprechender Form dar.
Beispiele:
In> EvalFormula(Taylor(x,0,7)Sin(x))

                                      3    5      7
                                     x    x      x
Taylor( x , 0 , 7 , Sin( x ) ) = x - -- + --- - ----
                                     6    120   5040

Out> True
siehe auch:
PrettyForm .


Write -- elementare Ausgaberoutine

interne Funktion
Funktionsaufruf:
Write(expr, ...)
Parameter:
expr - ein Ausdruck
Beschreibung:
Der Ausdruck "expr" wird berechnet und auf dem "current output" ausgegeben. Sind mehrere Argumente vorhanden, werden diese nacheinander ausgegeben. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> Write(1);
1Out> True;
In> Write(1,2);
 1 2Out> True;

Write schließt die Ausgabe nicht mit einem Zeilenvorschub ab, so dass der Out> Prompt unmittelbar auf die Ausgabe folgt.
siehe auch:
Echo , WriteString .


WriteString -- elementare Ausgaberoutine für Strings

interne Funktion
Funktionsaufruf:
WriteString(string)
Parameter:
string - ein String
Beschreibung:
Der String "string" wird ohne die Anführungszeichen auf dem "current output" ausgegeben. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> Write("Hello, world!");
"Hello, world!"Out> True;
In> WriteString("Hello, world!");
Hello, world!Out> True;

siehe auch:
Echo , Write .


Space -- Ausgabe von Leerzeichen

mathematische Standardbibliothek
Funktionsaufruf:
Space()
Space(nr)
Parameter:
nr - Anzahl der Leerzeichen
Beschreibung:
Der Befehl Space() gibt "nr" Leerzeichen auf dem "current output" aus. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> Space(5);
     Out> True;
siehe auch:
Echo , Write , NewLine .


NewLine -- Ausgabe von Zeilenvorschüben

mathematische Standardbibliothek
Funktionsaufruf:
NewLine()
NewLine(nr)
Parameter:
nr - Anzahl der Zeilenvorschübe
Beschreibung:
Der Befehl NewLine() gibt "nr" Zeilenvorschübe auf dem "current output" aus. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> NewLine();

Out> True;
siehe auch:
Echo , Write , Space .


FromFile -- Eingabeumleitung zum Lesen aus einer Datei

interne Funktion
Funktionsaufruf:
FromFile(name) body
Parameter:
name - ein Dateiname
body - eine Anweisung
Beschreibung:
Der "current input" wird mit der Datei "name" verbunden. Danach wird die Anweisung "body" ausgeführt. Eingaben, die während der Ausführung von "body" erwartet werden, werden aus der Datei gelesen. Zum Schluss wird die Datei geschlossen und das Ergebnis der Anweisung zurückgegeben.
Beispiele:
Angenommen die Datei foo enthält

2 + 5;

Die Datei lässt sich z.B. folgendermaßen auslesen:
In> FromFile("foo") res := Read();
Out> 2+5;

In> FromFile("foo") res := ReadToken();
Out> 2;
siehe auch:
ToFile , FromString , Read , ReadToken .


FromString -- Eingabeumleitung zum Lesen aus einem String

interne Funktion
Funktionsaufruf:
FromString(str) body;
Parameter:
str - ein String
body - eine Anweisung
Beschreibung:
Die Anweisung "body" wird ausgeführt, wobei alle notwendigen Eingaben aus dem String "str" gelesen werden. Das Ergebnis der Anweisung wird zurückgegeben.
Beispiele:
In> FromString("2+5; this is never read") res := Read();
Out> 2+5;

In> FromString("2+5; this is never read") res := Eval(Read());
Out> 7;
siehe auch:
ToString , FromFile , Read , ReadToken .


ToFile -- Ausgabeumleitung zur Ausgabe in eine Datei

interne Funktion
Funktionsaufruf:
ToFile(name) body
Parameter:
name - ein Dateiname
body - eine Anweisung
Beschreibung:
Der "current output" wird mit der Datei "name" verbunden. Danach wird die Anweisung "body" ausgeführt. Alle während der Ausführung von "body" erfolgenden Ausgaben werden in die Datei "name" geschrieben. Zum Schluss wird die Datei geschlossen und das Ergebnis der Anweisung zurückgegeben.
Beispiele:
Betrachten wir zunächst folgende Anweisung:

In> [ Echo("Result:");  PrettyForm(Taylor(x,0,9) Sin(x)); ];
Result:

     3    5      7       9
    x    x      x       x
x - -- + --- - ---- + ------
    6    120   5040   362880

Out> True;

Die Ausgabe soll jetzt in eine Datei umgeleitet werden:

In> ToFile("out") [ Echo("Result:");  PrettyForm(Taylor(x,0,9) Sin(x)); ];
Out> True;

Der Dateiinhalt nach der Anweisung:

Result:

     3    5      7       9
    x    x      x       x
x - -- + --- - ---- + ------
    6    120   5040   362880

siehe auch:
FromFile , ToString , Echo , Write , WriteString , PrettyForm , Taylor .


ToString -- Ausgabeumleitung zur Ausgabe in einen String

interne Funktion
Funktionsaufruf:
ToString() body
Parameter:
body - eine Anweisung
Beschreibung:
Die Anweisung "body" wird ausgeführt. Die während der Ausführung erfolgenden Ausgaben werden als String zurückgegeben.
Beispiele:
In> str := ToString() \
In>        [ WriteString("The square of 8 is "); Write(8^2); ];
Out> "The square of 8 is  64";
siehe auch:
FromFile , ToString , Echo , Write , WriteString .


Read -- einen Ausdruck einlesen

interne Funktion
Funktionsaufruf:
Read()
Parameter:
keine
Beschreibung:
Ein Ausdruck wird vom "current input" eingelesen und unausgewertet zurückgegeben.
Beispiele:
In> FromString("2+5;") Read();
Out> 2+5;

In> FromString("") Read();
Out> EndOfFile;
siehe auch:
FromFile , FromString , LispRead , ReadToken , Write .


LispRead -- einen Ausdruck in LISP-Syntax einlesen

interne Funktion
Funktionsaufruf:
LispRead()
Parameter:
keine
Beschreibung:
Ein Ausdruck in LISP-Syntax wird vom "current input" eingelesen und unausgewertet zurückgegeben.

Der Ausdruck a+b lautet in LISP-Syntax (+ a b).
Beispiele:
In> FromString("(+ a b)") LispRead();
Out> a+b;

In> FromString("(List (Sin x) (- (Cos x)))") LispRead();
Out> {Sin(x),-Cos(x)};
siehe auch:
FromFile , FromString , Read , ReadToken , FullForm .


ReadToken -- ein Token einlesen

interne Funktion
Funktionsaufruf:
ReadToken()
Parameter:
keine
Beschreibung:
Ein Token wird vom "current input" eingelesen und unausgewertet zurückgegeben.

Ein Token ist die kleinste Einheit, in die ein Ausdruck zerlegt werden kann. Z.B. besteht a := foo aus den drei Token a, := und foo.
Beispiele:
In> FromString("a := Sin(x)") \
In>    While((tok := ReadToken()) != EndOfFile) Echo(tok);
a
:=
Sin
(
x
)
Out> True;
siehe auch:
FromFile , FromString , Read , LispRead .


Load -- alle in einer Datei enthaltenen Ausdrücke auswerten

interne Funktion
Funktionsaufruf:
Load(name)
Parameter:
name - ein Dateiname
Beschreibung:
Die Datei "name" wird geöffnet. Danach werden alle in der Datei stehenden Anweisungen eingelesen und ausgewertet. Das Ergebnis von Load ist immer true.
siehe auch:
Use , DefLoad , DefaultDirectory , FindFile .


Use -- eine Datei einmalig einlesen

interne Funktion
Funktionsaufruf:
Use(name)
Parameter:
name - ein Dateiname
Beschreibung:
Wurde die Datei bereits geladen, z.B. durch einen der Befehle Use oder DefLoad, dann passiert gar nichts. In allen anderen Fällen werden die in der Datei enthaltenen Anweisungen eingelesen und ausgewertet. Das Ergebnis von Use ist immer true.

Diese Funktion stellt sicher, dass eine Datei geladen ist, jedoch nicht ein zweites Mal eingelesen wird.
siehe auch:
Load , DefLoad , DefaultDirectory .


DefLoad -- eine .def-Datei einlesen

interne Funktion
Funktionsaufruf:
DefLoad(name)
Parameter:
name - ein Dateiname (ohne die Endung .def)
Beschreibung:
Die Dateiendung .def wird an den Dateinamen angehängt und die Datei mit dem daraus resultierenden Namen wird geladen. Die Datei sollte eine Liste von Anweisungen enthalten, die mit einer geschweiften Klammer } abgeschlossen wird. Die Datei wird erst dann vollständig geladen, wenn eine der aufgelisteten Funktionen aufgerufen wird. Die Startzeit kann so deutlich verkürzt werden, da zunächst nur die Liste geladen wird.
siehe auch:
Load , Use , DefaultDirectory .


FindFile -- eine Datei suchen

interne Funktion
Funktionsaufruf:
FindFile(name)
Parameter:
name - ein Dateiname
Beschreibung:
Das Ergebnis dieser Funktion ist der vollständige Pfad zur Datei "name". Wird die Datei nicht gefunden, wird ein leerer String zurückgegeben.
siehe auch:
Load , DefaultDirectory .


PatchLoad -- alle Befehle zwischen einer Datei ausführen

interne Funktion
Funktionsaufruf:
PatchLoad(name)
Parameter:
name - Dateiname
Beschreibung:
Diese Funktion lädt die Datei "name" und gibt den Inhalt auf dem "current output" aus. Enthält die Datei durch die Zeichen <? und ?> begrenzte Blöcke, dann wird der Text innerhalb dieser Blöcke als Folge von Yacas-Anweisungen interpretiert. Die Anweisungen werden ausgewertet, eventuelle Ausgaben erfolgen auf dem "current output".

In eine ansonsten statische Textdatei lassen sich somit dynamische Anteile einbetten.
siehe auch:
PatchString , Load .


Nl -- Zeilenvorschubzeichen

mathematische Standardbibliothek
Funktionsaufruf:
Nl()
Beschreibung:
Das Funktionsergebnis ist ein String, der einen Zeilenvorschub enthält.
Beispiele:
In> WriteString("First line" : Nl() : "Second line" : Nl());
First line
Second line
Out> True;
siehe auch:
NewLine .