MaxEvalDepth , Hold , Eval , While , Until , If , SystemCall , Function , Use , For , ForEach , Apply , MagArgs , Subst , WithValue , /:, /:: , SetHelpBrowser , TraceStack , TraceExp , TraceRule .

Kontrollfunktionen

MaxEvalDepth Setzen der max. Berechnungstiefe
Hold das Argument nicht berechnen
Eval das Argument berechnen
While eine Schleife durchlaufen, solange eine Bedingung erfüllt ist
Until eine Schleife durchlaufen, bis eine Bedingung erfüllt ist
If eine Verzweigung
SystemCall einen Befehl an die Shell weitergeben
Function eine Funktion definieren
Use eine Datei laden
For eine Schleife in C-Syntax
ForEach alle Elemente einer Liste in einer Schleife abarbeiten
Apply eine Funktion anwenden
MagArgs eine Funktion auf alle Argumente anwenden
Subst eine Substitution durchführen
WithValue eine nur für die aktuelle Berechnung gültige Wertzuweisung
/:, /:: lokale Vereinfachungsregeln
SetHelpBrowser setzt den für die Hilfefunktion zu verwendenden HTML-Browser
TraceStack gibt im Fehlerfall den Inhalt des Stacks aus
TraceExp schrittweise Berechnung von Termen
TraceRule schrittweise Berechnung einer best. Funktion


MaxEvalDepth -- Setzen der max. Berechnungstiefe

interne Funktion
Funktionsaufruf:
MaxEvalDepth(n)
Parameter:
n - eine pos. ganze Zahl
Beschreibung:
Diese Funktion setzt die maximale Berechnungstiefe auf den Wert "n". Die voreingestellte Berechnungstiefe ist n=1000.
Das Ergebnis der Funktion MaxEvalDepth ist True.

Das Festlegen einer max. Berechnungstiefe verhindert unendliche Rekursionen. Wird z.B. die Funktion f(x) := f(x) definiert, dann ruft sich die Funktion f(x) selber auf, was zu einer unendlichen Rekursion führt. Bei Erreichen der max. Berechnungstiefe wird die Rekursion abgebrochen. Indirekte Rekursionen wie z.B.
f(x) := g(x) und g(x) := f(x)
werden abgefangen.
Beispiele:
In> f(x) := f(x)
Out> True;

In> f(x)
Error on line 1 in file [CommandLine]
Max evaluation stack depth reached.
Please use MaxEvalDepth to increase the stack size as needed.

Bei komplexeren Berechnungen kann die max. Berechnungstiefe auch erreicht werden, ohne dass eine unendliche Rekursion vorliegt. In solchen Fällen kann die Berechnungstiefe mit MaxEvalDepth entsprechend angepasst werden.

In> 10 # g(0) <-- 1;
Out> True;

In> 20 # g(n_IsPositiveInteger) <-- 2 * g(n-1);
Out> True;

In> g(1001);
Error on line 1 in file [CommandLine]
Max evaluation stack depth reached.
Please use MaxEvalDepth to increase the stack size as needed.

In> MaxEvalDepth(10000);
Out> True;

In> g(1001);
Out> 214301721437253464189685009812000362112280962341106721488750077674070210224
98722449863967576313917162551893458351062936503742905713846280871969155149397149
60786913554964846197084214921012474228375590836430609294996716388253479753511833
1087892154125829142392955373084335320859663305248773674411336138752;


Hold -- das Argument nicht berechnen

interne Funktion
Funktionsaufruf:
Hold(expr)
Parameter:
expr - ein Term
Beschreibung:
Der Term "expr" wird ohne Berechnung zurückgegeben.
Beispiel:
In> Echo({ Hold(1+1), "=", 1+1 });
 1+1 = 2
Out> True;
siehe auch:
Eval , HoldArg .


Eval -- das Argument berechnen

interne Funktion
Funktionsaufruf:
Eval(expr)
Parameter:
expr - ein Term
Beschreibung:
Diese Funktion berechnet explizit den Term "expr" und gibt das Ergebnis als Funktionswert zurück.
Beispiele:
In> a := x;
Out> x;

In> x := 5;
Out> 5;

In> a;
Out> x;

In> Eval(a);
Out> 5;
Die Variable a hat den Wert x, und x hat den Wert 5. Die Berechnung von a ergibt somit x. Soll der Wert 5 zurückgegeben werden, so muss dies explizit gefordert werden.

Ein verändertes Verhalten ergibt sich, wenn x bei der Zuweisung a := x bereits den Wert 5 hat. a würde dann ebenfalls den Wert 5 erhalten, da der Zuweisungsoperator die rechte Seite zunächst berechnet.
siehe auch:
Hold , HoldArg , :=


While -- eine Schleife durchlaufen, solange eine Bedingung erfüllt ist

interne Funktion
Funktionsaufruf:
While(pred) body
Parameter:
pred - eine boolsche Funktion
body - ein Term
Beschreibung:
Der Term "body" wird berechnet, solange die Funktion "pred" den Wert True liefert. Die While-Schleife ist eine abweisende Schleife. Ist das Ergebnis von "pred" bereits beim ersten Mal False, dann wird der Term "body" gar nicht berechnet.
Beispiele:
In> x := 0;
Out> 0;
In> While (x! < 10^6) [ Echo({x, x!}); x++; ];
 0  1
 1  1
 2  2
 3  6
 4  24
 5  120
 6  720
 7  5040
 8  40320
 9  362880
Out> True;
siehe auch:
Until , For .


Until -- eine Schleife durchlaufen, bis eine Bedingung erfüllt ist

mathematische Standardbibliothek
Funktionsaufruf:
Until(pred) body
Parameter:
pred - eine boolsche Funktion
body - ein Term
Beschreibung:
Der Term "body" wird solange berechnet, bis die Funktion "pred" den Wert True liefert. Die Funktion "pred" wird nach der Berechnung von "body" ausgewertet. Im Unterschied zur While-Schleife wird der Term "body" in jedem Falle mindestens einmal berechnet.
Beispiele:
In> x := 0;
Out> 0;
In> Until (x! > 10^6) [ Echo({x, x!}); x++; ];
 0  1
 1  1
 2  2
 3  6
 4  24
 5  120
 6  720
 7  5040
 8  40320
 9  362880
Out> True;
siehe auch:
While , For .


If -- eine Verzweigung

interne Funktion
Funktionsaufruf:
If(pred, then)
If(pred, then, else)
Parameter:
pred - eine boolsche Funktion
then - ein Term
else - ein Term
Beschreibung:
Die boolsche Funktion "pred" wird ausgewertet. Ist das Ergebnis True, wird der Term "then" berechnet und als Ergebnis zurückgegeben. Liefert "pred" den Wert False, wird der Term "else" berechnet und als Ergebnis zurückgegeben. Ist kein "else"-Zweig vorhanden, wird als Ergebnis False zurückgegeben.
Beispiele:
Das Ergebnis der Funktion sign ist +1, falls das Argument positiv ist, ansonsten -1. Die Funktion lässt sich wie folgt realisieren:

In> mysign(x) := If (IsPositiveReal(x), 1, -1);
Out> True;

In> mysign(Pi);
Out> 1;

In> mysign(-2.5);
Out> -1;

Die so definierte Funktion liefert allerdings falsche Ergebnisse, wenn sich "x" nicht numerisch berechnen lässt:

In> mysign(a);
Out> -1;

Mit der folgenden Lösung tritt dieser Fehler nicht auf:

In> mysign(_x)_IsNumber(N(x)) <-- If (IsPositiveReal(x), 1, -1);
Out> True;


SystemCall -- einen Befehl an die Shell weitergeben

interne Funktion
Funktionsaufruf:
SystemCall(str)
Parameter:
str - ein String
Beschreibung:
Der mit dem String übergebene Befehl wird vom Betriebssystem ausgeführt.
Das Ergebnis ist True.

Dieser Befehl darf im Rahmen der Funktion Secure nicht verwendet werden.
Beispiele:
In einer UNIX-Umgebung liefert der Befehl SystemCall("ls") den Inhalt des aktuellen Verzeichnisses.
siehe auch:
Secure .


Function -- eine Funktion definieren

mathematische Standardbibliothek
Funktionsaufruf:
Function("op", {arg,...}) body
Parameter:
op - Name der Funktion
arg - Argument der Funktion
body - Funktionsterm
Beschreibung:
Mit diesem Befehl lassen sich einfache Funktionen definieren. Der Befehl ist äquivalent zu op(_arg, ...) <-- body.
Beispiele:
In> Function("FirstOf", {list})  list[1];
Out> True;
In> FirstOf({a,b,c});
Out> a;

Hiermit wird eine Funktion FirstOf definiert, die das erste Element einer Liste zurückgibt. Äquivalente Definitionen sind FirstOf(_list) <-- list[1] oder FirstOf(list) := list[1].
siehe auch:
TemplateFunction , Rule , RuleBase , := .


Use -- eine Datei laden

interne Funktion
Funktionsaufruf:
Use(name)
Parameter:
name - Dateiname
Beschreibung:
Die Datei "name" wird geladen, und alle enthaltenen Befehle werden ausgeführt.
Die Datei wird nicht geladen, wenn dies bereits mit einem früheren Aufruf von Use oder durch die Funktion DefLoad geschehen ist.
siehe auch:
Load , DefLoad , DefaultDirectory .


For -- eine Schleife in C-Syntax

mathematische Standardbibliothek
Funktionsaufruf:
For(init, pred, incr) body
Parameter:
init - ein Term
pred - eine boolsche Funktion
incr - ein Term
body - ein Term
Beschreibung:
Mit diesem Befehl wird eine Schleife ähnlich der for-Schleife in der Programmiersprache C realisiert. Zunächst wird einmalig der Term "init" ausgewertet. Danach wird die Funktion "pred" ausgeführt. Ist das Ergebnis True, wird der Term "body" berechnet. Ein Schleifendurchlauf wird mit Berechnung des Terms "incr" beendet. Die Schleife wird solange wiederholt, bis das Ergebnis von "pred" False ist.

Der Befehl wird meist in der Form
For(i=1, i<=10, i++) body
angewendet. Der Term "body" wird hier 10-mal für die Werte i=1 bis i=10 berechnet.
Beispiele:
In> For (i:=1, i<=10, i++) Echo({i, i!});
 1  1
 2  2
 3  6
 4  24
 5  120
 6  720
 7  5040
 8  40320
 9  362880
 10  3628800
Out> True;
siehe auch:
While , Until , ForEach .


ForEach -- alle Elemente einer Liste in einer Schleife abarbeiten

mathematische Standardbibliothek
Funktionsaufruf:
ForEach(var, list) body
Parameter:
var - eine Variable
list - eine Liste von Werten
body - ein Term
Beschreibung:
Der Term "body" mit der Variablen "var" wird nacheinander für alle Listenelemente berechnet.
Das Ergebnis von ForEach ist True.
Beispiele:
 In> ForEach(i,{2,3,5,7,11}) Echo({i, i!});
 2  2
 3  6
 5  120
 7  5040
 11  39916800
Out> True;
siehe auch:
For .


Apply -- eine Funktion anwenden

mathematische Standardbibliothek
Funktionsaufruf:
Apply(fn, arglist)
Parameter:
fn - eine Funktion
arglist - eine Liste von Argumenten
Beschreibung:
Die Funktion "fn" wird auf die Argumente in "arglist" angewendet. Der Funktionswert wird als Ergebnis zurückgegeben.
Der Befehl kann mit dem Operator @ abgekürzt werden.
Beispiele:
In> Apply("+", {5,9});
Out> 14;

In> Apply({{x,y}, x-y^2}, {Cos(a), Sin(a)});
Out> Cos(a)-Sin(a)^2;
siehe auch:
Map , MapSingle , @ .


MagArgs -- eine Funktion auf alle Argumente anwenden

mathematische Standardbibliothek
Funktionsaufruf:
MapArgs(expr, fn)
Parameter:
expr - ein Term
fn - eine Funktion
Beschreibung:
Die Funktion "fn" wird auf jedes im Term "expr" vorkommende Argument angewendet.
Beispiele:
In> MapArgs(f(x,y,z),"Sin");
Out> f(Sin(x),Sin(y),Sin(z));

In> MapArgs({3,4,5,6}, {{x},x^2});
Out> {9,16,25,36};
siehe auch:
MapSingle , Map , Apply .


Subst -- eine Substitution durchführen

mathematische Standardbibliothek
Funktionsaufruf:
Subst(from, to) expr
Parameter:
from - ein Term
to - ein Term
expr - ein Term
Beschreibung:
Jedes Vorkommen des Terms "from" in "expr" wird ersetzt durch "to".
Beispiele:
In> Subst(x, Sin(y)) x^2+x+1;
Out> Sin(y)^2+Sin(y)+1;

In> Subst(a+b, x) a+b+c;
Out> x+c;

In> Subst(b+c, x) a+b+c;
Out> a+b+c;

Das letzte Beispiel erklärt sich wie folgt:
Der Term a+b+c wird intern als (a+b)+c gespeichert. Somit ist a+b ein Teilausdruck, b+c jedoch nicht.
siehe auch:
WithValue , /: .


WithValue -- eine nur für die aktuelle Berechnung gültige Wertzuweisung

mathematische Standardbibliothek
Funktionsaufruf:
WithValue(var, val, expr)
WithValue({var,...}, {val,...}, expr)
Parameter:
var - eine Variable
val - ein Wert
expr - ein Term
Beschreibung:
Der Variablen "var" wird der Wert "val" zugewiesen. Der Term "expr" wird mit diesem Wert berechnet und der Funktionswert als Ergebnis zurückgegeben. Danach wird die Wertzuweisung wieder rückgängig gemacht, so dass "var" wieder den urprünglichen Wert hat.

Mit dem zweiten Funktionsaufruf wird dem ersten Element in der Liste von Variablen das erste Element der Werteliste zugewiesen, der zweiten Variablen der zweite Wert usw.
Beispiele:
In> WithValue(x, 3, x^2+y^2+1);
Out> y^2+10;

In> WithValue({x,y}, {3,2}, x^2+y^2+1);
Out> 14;
siehe auch:
Subst , /: .


/:, /:: -- lokale Vereinfachungsregeln

mathematische Standardbibliothek
Funktionsaufruf:
expression /: patterns
expressions /:: patterns
Parameter:
expression - ein Term
patterns - eine Liste von Mustern
Beschreibung:
Mit Hilfe der Operatoren /: und /:: lassen sich die internen Vereinfachungsregeln ergänzen. Soll z.B. in einem Term der Ausdruck Ln(a*b) durch Ln(a)+Ln(b) ersetzt werden, dann lässt sich das wie folgt mit dem /:- Operator realisieren:

In> Sin(x)*Ln(a*b)
Out> Sin(x)*Ln(a*b);
In> % /: { Ln(_x*_y) <- Ln(x)+Ln(y) }
Out> Sin(x)*(Ln(a)+Ln(b));

Die Liste kann mehrere Vereinfachungsregeln enthalten, die auf den Term auf der linken Seite von /: angewendet werden.

Die Muster können dabei in einer der folgenden Formen angegeben werden:

Muster <- Ersetzung

{Muster, Ersetzung}

Lokale Regeln werden mit<- definiert, globale Regeln mit >--.

Der /: Operator durchläuft den Term von oben nach unten und versucht nacheinander die in der Liste angegebenen Regeln anzuwenden. Können die Regeln nicht angewendet werden, dann werden die Teilterme untersucht.

Manchmal ist es erforderlich, den /: Operator mehrfach anzuwenden. Dazu dient der /:: Operator, der die Vereinfachungsregeln so oft anwendet, bis sich der Term nicht mehr verändert.
Wenn sich die Regeln gegenseitig aufheben, kann dies zu einer unendlichen Schleife führen. Dieser Fall kann erkannt werden, wenn zunächst der /: Operator mehrfach angewendet wird.

Beispiele:
In> Sin(u)*Ln(a*b) /: { Ln(_x*_y) <- Ln(x)+Ln(y) }
Out> Sin(u)*(Ln(a)+Ln(b));

In> Sin(u)*Ln(a*b) /:: { a <- 2, b <- 3 }
Out> Sin(u)*Ln(6);
siehe auch:
Subst .


SetHelpBrowser -- setzt den für die Hilfefunktion zu verwendenden HTML-Browser

mathematische Standardbibliothek
Funktionsaufruf:
SetHelpBrowser(helpbrowser)
Parameter:
helpbrowser - ein String
Beschreibung:
Mit dieser Funktion wird der für die Hilfefunktion zu verwendende HTML-Browser festgelegt. Das mit dem String "helpbrowser" bezeichnete Programm wird mit der html-Seite als Argument aufgerufen. Der auch für die Textkonsole geeignete Browser lynx ist voreingestellt. Ein anderer Browser kann dauerhaft als Standard vorgegeben werden, wenn der Befehl in die Datei ~/.yacasrc eingefügt wird.
Beispiele:
In> SetHelpBrowser("netscape")
Out> "netscape";

In> ??
siehe auch:
Help .


TraceStack -- gibt im Fehlerfall den Inhalt des Stacks aus

interne Funktion
Funktionsaufruf:
TraceStack(expression)
Parameter:
expression - ein Term
Beschreibung:
Die Funktion gibt im Fehlerfall den Inhalt des Stacks aus. Dies ist das wichtigste Hilfsmittel bei der Fehlersuche in Yacas. Angezeigt werden die letzten Stackeinträge bevor der Fehler auftrat.

Für jeden Eintrag wird angezeigt, ob es sich um eine interne oder eine benutzerdefinierte Funktion handelt. Für benutzerdefinierte Funktionen wird zusätzlich angegeben, welche Regel bearbeitet wurde.

Die Funktion ist standardmäßig abgeschaltet, da sie die Ausführungsgeschwindigkeit stark beeinträchtigt.
Beispiele:
Das folgende Beispiel zeigt den Stack nachdem die sich selbst aufrufende Funktion durch unendliche Rekursion einen Stacküberlauf verursacht hat:

In> f(x):=f(Sin(x))
Out> True;

In> TraceStack(f(2))
Debug> 982 :  f (Rule # 0 in body)
Debug> 983 :  f (Rule # 0 in body)
Debug> 984 :  f (Rule # 0 in body)
Debug> 985 :  f (Rule # 0 in body)
Debug> 986 :  f (Rule # 0 in body)
Debug> 987 :  f (Rule # 0 in body)
Debug> 988 :  f (Rule # 0 in body)
Debug> 989 :  f (Rule # 0 in body)
Debug> 990 :  f (Rule # 0 in body)
Debug> 991 :  f (Rule # 0 in body)
Debug> 992 :  f (Rule # 0 in body)
Debug> 993 :  f (Rule # 0 in body)
Debug> 994 :  f (Rule # 0 in body)
Debug> 995 :  f (User function)
Debug> 996 :  Sin (Rule # 0 in pattern)
Debug> 997 :  IsList (interne Funktion)
Error on line 1 in file [CommandLine]
Max evaluation stack depth reached.
Please use MaxEvalDepth to increase the stack size as needed.
siehe auch:
TraceExp , TraceRule .


TraceExp -- schrittweise Berechnung von Termen

interne Funktion
Funktionsaufruf:
TraceExp(expr)
Parameter:
expr - ein Term
Beschreibung:
Der Term "expr" wird schrittweise berechnet. Jeder Teilterm wird vor und nach der Berechnung angezeigt. Die Ausgabe vor der Berechnung hat die Form TrEnter(x), wobei mit x der aktuell zu berechnende Teilterm bezeichnet ist. Die Ausgabe nach der Berechnung des Teilterms lautet TrLeave(x,y), wobei y das Ergebnis der Berechnung ist. Die Einrückungstiefe zeigt die Schachtelungsebene an.

Dieser Befehl erzeugt eine große Ausgabeflut. Bei etwas komplexeren Termen sollte daher der Befehl TraceRule verwendet werden.
Beispiele:
In> TraceExp(2+3);
  TrEnter(2+3);
    TrEnter(2);
    TrLeave(2, 2);
    TrEnter(3);
    TrLeave(3, 3);
    TrEnter(IsNumber(x));
      TrEnter(x);
      TrLeave(x, 2);
    TrLeave(IsNumber(x),True);
    TrEnter(IsNumber(y));
      TrEnter(y);
      TrLeave(y, 3);
    TrLeave(IsNumber(y),True);
    TrEnter(True);
    TrLeave(True, True);
    TrEnter(MathAdd(x,y));
      TrEnter(x);
      TrLeave(x, 2);
      TrEnter(y);
      TrLeave(y, 3);
    TrLeave(MathAdd(x,y),5);
  TrLeave(2+3, 5);
Out> 5;
siehe auch:
TraceStack , TraceRule .


TraceRule -- schrittweise Berechnung einer best. Funktion

interne Funktion
Funktionsaufruf:
TraceRule(templ) expr
Parameter:
templ - eine Vorlage
expr - ein Term
Beschreibung:
Die schrittweise Berechnung erfolgt nur für Teilterme die der in der Vorlage "templ" angegeben Form entsprechen. Die Vorlage ist ein Beispiel einer Funktion, die schrittweise berechnet werden soll. Die Teilterme werden vor der Berechnung (angezeigt durch TrEnter) und danach (TrLeave) ausgegeben. Zwischenergebnisse werden vor und nach der Berechnung mit (TrArg) ausgegeben.
Die schrittweise Berechnung kann nur bei in Skripten definierten Funktionen durchgeführt werden.

Der Befehl eignet sich insbesondere zur Untersuchung von Funktionen, die von anderen Funktionen aufgerufen werden.
Beispiele:
In> TraceRule(x+y) 2+3*5+4;
    TrEnter(2+3*5+4);
      TrEnter(2+3*5);
          TrArg(2, 2);
          TrArg(3*5, 15);
      TrLeave(2+3*5, 17);
        TrArg(2+3*5, 17);
        TrArg(4, 4);
    TrLeave(2+3*5+4, 21);
Out> 21;
siehe auch:
TraceStack , TraceExp .