:= | 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 |
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.
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; |
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; |
Der Funktionsaufruf Set(var, exp) ist äquivalent zu var := exp.
In> Set(a, Sin(x)+3); Out> True; In> a; Out> Sin(x)+3; |
In> a := 5; Out> 5; In> a^2; Out> 25; In> Clear(a); Out> True; In> a^2; Out> a^2; |
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.
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; |
In> x := 5; Out> 5; In> x++; Out> True; In> x; Out> 6; |
In> x := 5; Out> 5; In> x--; Out> True; In> x; Out> 4; |
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; |
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) |
In> a:=Hold(2+3) Out> 2+3; In> a Out> 2+3; In> LazyGlobal(a) Out> True; In> a Out> 5; |
In> UniqueConstant() Out> C9 In> UniqueConstant() Out> C10 |