:= , Set , Clear , Local , ++ , -- , Object , LazyGlobal , UniqueConstant .

Variablen

:= Wertzuweisung
Set Wertzuweisung
Clear Wertzuweisung aufheben
Local eine Variable als lokal deklarieren
++ Variable inkrementieren
-- Variable dekrementieren
Object unvollständigen Objekttyp erzeugen
LazyGlobal erneute Berechnung einer globalen Variablen
UniqueConstant einzigartige Konstante erzeugen


:= -- Wertzuweisung

mathematische Standardbibliothek
Funktionsaufruf:
var := exp
{var, ...} := {exp, ...}
var[i] := exp
fn(param, ...) := exp
Parameter:
var - eine Variable
exp - ein Ausdruck
i - ein Index
fn - Funktionsname
param - Argument der Funktion "fn"
Beschreibung:
Der := Operator kann vielfältig eingesetzt werden. In allen Fällen erfolgt irgendeine Form der Zuweisung.

Am häufigsten wird der Operator in der ersten Form verwendet. Der Ausdruck auf der rechten Seite wird ausgewertet und das Ergebnis der Variablen auf der linken Seite zugewiesen. Daneben wird das Ergebnis zurückgegeben.

Die zweite Form erlaubt mehrfache Zuweisungen in einer Anweisung. Der erste Eintrag der Liste auf der rechten Seite wird der ersten Variablen in der Liste links zugewiesen, der zweite Eintrag rechts der zweiten Variablen links usw. Die rechte Liste muss mindestens so viele Elemente wie die linke haben. Überzählige Elemente werden ignoriert. Als Ergebnis wird die Liste der zugewiesenen Werte zurückgegeben.

Mit der dritten Form kann einem Listenelement ein neuer Wert zugewiesen werden. Ist "i" eine natürliche Zahl, dann wird dem i-ten Listenelement der Ausdruck auf der rechten Seite zugewiesen. Ist "i" ein String, dann wird "var" als Schlüsselliste interpretiert und der Schlüssel "i" wird dem Ausdruck "exp" zugeordnet. In beiden Fällen wird der Ausdruck auf der rechten Seite vor der Zuweisung berechnet. Das Ergebnis der Zuweisung ist immer True.

Mit der vierten Form wird eine Funktion definiert, z.B. f(x) := x^2. Der Funktionsterm auf der rechten Seite wird nicht sofort berechnet, sondern erst beim Aufruf von "f". Ist dies zu zeitaufwendig, kann eine sofortige Berechnung mit Eval erzwungen werden.
Beispiele:
Eine einfache Zuweisung:

In> a := Sin(x) + 3;
Out> Sin(x)+3;

In> a;
Out> Sin(x)+3;

Eine mehrfache Zuweisung:

In> {a,b,c} := {1,2,3};
Out> {1,2,3};

In> a;
Out> 1;

In> b+c;
Out> 5;

Zuweisung zu einer Liste:

In> xs := { 1,2,3,4,5 };
Out> {1,2,3,4,5};

In> xs[3] := 15;
Out> True;

In> xs;
Out> {1,2,15,4,5};

Erstellen einer Schlüsselliste:

In> alist := {};
Out> {};

In> alist["cherry"] := "red";
Out> True;

In> alist["banana"] := "yellow";
Out> True;

In> alist["cherry"];
Out> "red";

In> alist;
Out> {{"banana","yellow"},{"cherry","red"}};

Definition einer Funktion:

In> f(x) := x^2;
Out> True;

In> f(3);
Out> 9;

In> f(Sin(a));
Out> Sin(a)^2;

In> Infix("*&*",10);
Out> True;

In> x1 *&* x2 := x1/x2 + x2/x1;
Out> True;

In> Sin(a) *&* Cos(a);
Out> Tan(1)+Cos(1)/Sin(1);

In> Clear(a);
Out> True;

In> Sin(a) *&* Exp(a);
Out> Sin(a)/Exp(a)+Exp(a)/Sin(a);

Das folgende Beispiel zeigt eine Taylorentwicklung. Die zeitaufwendige Berechnung erfolgt bei jedem Aufruf der Funktion f erneut.

In> f(a) := Taylor(x,0,25) Sin(x);
Out> True;

In> f(1);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;

In> f(2);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;

Die wiederholte Taylorentwicklung kann durch den Einsatz von Eval vermieden werden. Die Taylorentwicklung wird dann nur einmal durchgeführt und nicht bei jedem Funktionsaufruf erneut.

In> f(a) := Eval(Taylor(x,0,25) Sin(x));
Out> True;

In> f(1);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;

In> f(2);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;
siehe auch:
Set , Clear , [] , Rule , Infix , Eval .


Set -- Wertzuweisung

interne Funktion
Funktionsaufruf:
Set(var, exp)
Parameter:
var - eine Variable
exp - ein Ausdruck
Beschreibung:
Der Ausdruck "exp" wird berechnet und der Variablen "var" zugewiesen. Als Ergbnis wird True zurückgegeben.

Der Funktionsaufruf Set(var, exp) ist äquivalent zu var := exp.
Beispiele:
In> Set(a, Sin(x)+3);
Out> True;

In> a;
Out> Sin(x)+3;
siehe auch:
Clear , := .


Clear -- Wertzuweisung aufheben

interne Funktion
Funktionsaufruf:
Clear(var, ...)
Parameter:
var - eine Variable
Beschreibung:
Alle Wertzuweisungen zu den aufgelisteten Variablen werden gelöscht. In nachfolgenden Berechnungen verbleiben die Variablen solange unverändert bis eine erneute Zuweisung erfolgt. Als Ergbnis wird True zurückgegeben.
Beispiele:
In> a := 5;
Out> 5;

In> a^2;
Out> 25;

In> Clear(a);
Out> True;

In> a^2;
Out> a^2;
siehe auch:
Set , := .


Local -- eine Variable als lokal deklarieren

interne Funktion
Funktionsaufruf:
Local(var, ...)
Parameter:
var - eine Variable
Beschreibung:
Alle als Argument aufgelisteten Variablen werden als lokale Variablen deklariert. Die Argumente werden nicht berechnet. Als Ergbnis wird True zurückgegeben.

Standardmäßig sind alle Variablen in Yacas global. Eine globale Variable hat an jeder Stelle den gleichen Wert. Manchmal ist es sinnvoll, den Gültigkeitsbereich einer Variablen einzuschränken. Wird eine Variable als lokal deklariert, kann nur innerhalb eines Prog Blocks (oder dem syntaktischen äquivalenten [ ] Block) auf diese Variable zugegriffen werden. Eine innerhalb eines Blocks aufgerufene Funktion hat auf die lokalen Variablen des Blocks keinen Zugriff, außer der Zugriff wird explizit mit UnFence erlaubt.
Beispiele:
In> a := 3;
Out> 3;

In> [ a := 4; a; ];
Out> 4;

In> a;
Out> 4;

In> [ Local(a); a := 5; a; ];
Out> 5;

In> a;
Out> 4;

Im ersten Block ist a eine globale Variable. Die Änderung innerhalb des Blocks wirkt sich auch ausserhalb aus.
Im zweiten Block wird a lokal definiert. Die Änderung innerhalb des Blocks hat keinen Einfluss auf die globale Variable a.
siehe auch:
LocalSymbols , Prog , [] , UnFence .


++ -- Variable inkrementieren

mathematische Standardbibliothek
Funktionsaufruf:
var++
Parameter:
var - eine Variable
Beschreibung:
Die Variable "var" wird inkrementiert, d.h. um Eins vergrößert. Der Ausdruck x++ ist äquivalent zu x := x + 1 mit dem Unterschied, dass die Zuweisung den neuen Wert zurückgibt, während x++ immer das Ergebnis True hat.
Beispiele:
In> x := 5;
Out> 5;

In> x++;
Out> True;

In> x;
Out> 6;
siehe auch:
-- , := .


-- -- Variable dekrementieren

mathematische Standardbibliothek
Funktionsaufruf:
var--
Parameter:
var - eine Variable
Beschreibung:
Die Variable "var" wird dekrementiert, d.h. um Eins verkleinert. Der Ausdruck x-- ist äquivalent zu x := x - 1 mit dem Unterschied, dass die Zuweisung den neuen Wert zurückgibt, während x-- immer das Ergebnis True hat.
Beispiele:
In> x := 5;
Out> 5;

In> x--;
Out> True;

In> x;
Out> 4;
siehe auch:
++ , := .


Object -- unvollständigen Objekttyp erzeugen

mathematische Standardbibliothek
Funktionsaufruf:
Object("pred", exp)
Parameter:
pred - Objekttyp
exp - ein Ausdruck
Beschreibung:
Das Ergebnis dieser Funktion ist "exp", falls das Ergebnis von "pred" angewendet auf "exp" True ist.
Beispiele:
In> a := Object("IsNumber", x);
Out> Object("IsNumber",x);

In> Eval(a);
Out> Object("IsNumber",x);

In> x := 5;
Out> 5;

In> Eval(a);
Out> 5;
siehe auch:
IsNonObject .


LazyGlobal -- erneute Berechnung einer globalen Variablen

interne Funktion
Funktionsaufruf:
LazyGlobal(var)
Parameter:
var - eine Variable
Beschreibung:
LazyGlobal erzwingt die Berechnung einer globalen Variablen, wenn diese verwendet wird.

Bei den globalen Variablen % und I wird diese Funktion eingesetzt.

Das an die globale Variable gebundene Objekt wird erst berechnet, wenn die Variable aufgerufen wird. Das Ergebnis dieser Berechnung wird in der globalen Variablen gespeichert. Eine erneute Berechnung findet danach nicht mehr statt:

In> a:=Hold(Taylor(x,0,30)Sin(x))
Out> Taylor(x,0,30)Sin(x);
In> LazyGlobal(a)

Beim ersten Aufruf von a wird der Ausdruck Taylor(...) berechnet und das Ergebnis a zugewiesen. Bei folgenden Aufrufen von a wird das Ergebnis ohne erneute Berechnung zurückgegeben.
Beispiele:
In> a:=Hold(2+3)
Out> 2+3;

In> a
Out> 2+3;

In> LazyGlobal(a)
Out> True;

In> a
Out> 5;
siehe auch:
Set , Clear , Local , % , I .


UniqueConstant -- einzigartige Konstante erzeugen

mathematische Standardbibliothek
Funktionsaufruf:
UniqueConstant()
Parameter:
keine
Beschreibung:
Diese Funktion erzeugt bei jedem Aufruf eine neue einzigartige Konstante C#. Die Konstanten unterscheiden sich in der angefügten Zahl #.
Beispiele:
In> UniqueConstant()
Out> C9

In>  UniqueConstant()
Out> C10
siehe auch:
LocalSymbols .