Yacas erlaubt das Speichern persönlicher Einstellungen in der Datei ~/.yacasrc. Mit den folgenden Funktionen lässt sich die Arbeitsweise von Yacas beeinflussen:
DefaultDirectory | Verzeichnis zum Suchpfad für Yacas Skripte hinzufügen |
PrettyPrinter | Funktion für die formatierte Ausgabe setzen |
Help | Hilfefunktion aufrufen |
HistorySize | Größe der history-Datei setzen |
In> DefaultDirectory("/home/user/myscripts/"); Out> True; |
In> Taylor(x,0,5)Sin(x) Out> x-x^3/6+x^5/120; In> PrettyPrinter("PrettyForm"); True Out> In> Taylor(x,0,5)Sin(x) 3 5 x x x - -- + --- 6 120 Out> In> PrettyPrinter(); Out> True; In> Taylor(x,0,5)Sin(x) Out> x-x^3/6+x^5/120; |
Help(_f) <-- SystemCall("netscape ":FindFile("documentation/ref.html"):"#":f); Help() := SystemCall("netscape ":FindFile("documentation/books.html")); |
In> HistorySize(200) Out> True; In> quit |
+, -, *, /, ^ | Rechenoperatoren |
In> 2+3 Out> 5; In> 2*3 Out> 6; |
Div, Mod | Division mit Rest |
Gcd | größter gemeinsamer Teiler |
Lcm | kleinstes gemeinsames Vielfaches |
<<, >> | Schiebeoperatoren |
FromBase, ToBase | Umrechnung zwischen unterschiedlichen Stellenwertsystemen |
Precision | Rechengenauigkeit einstellen |
GetPrecision | eingestellte Rechengenauigkeit ermitteln |
N | numerischen Näherungswert berechnen |
Rationalize | Umwandlung von Dezimalzahlen in Brüche |
IsPrime | testen, ob das Argument eine Primzahl ist |
IsPrimePower | testen, ob das Argument eine Primzahlpotenz ist |
Factors | Primfaktorzerlegung |
Factor | Primfaktorzerlegung mit formatierter Ausgabe |
PAdicExpand | p-adische Erweiterung |
ContFrac | Umwandlung in einen Kettenbruch |
Decimal | Umwandlung eines Bruches in die vollständige Dezimaldarstellung |
TruncRadian | Umwandlung ins Bogenmaß modulo 2*Pi |
Floor | eine Zahl abrunden |
Ceil | eine Zahl aufrunden |
Round | eine Zahl zur nächsten ganzen Zahl runden |
Pslq | ganzzahlige Relationen zwischen Zahlen suchen |
In> Div(5,3) Out> 1; In> Mod(5,3) Out> 2; |
Prozedur zur Berechnung von Gcd(n,m) 1) if n = m then return n 2) if both n and m are even then return 2*Gcd(n/2,m/2) 3) if exactly one of n or m (say n) is even then return Gcd(n/2,m) 4) if both n and m are odd and, say, n>m then return Gcd( (n-m)/2,m) |
Gcd({a,b,c}) = Gcd(Gcd(a,b),c) |
In> Gcd(55,10) Out> 5; In> Gcd({60,24,120}) Out> 12; |
Lcm(n,m) = Div(n*m,Gcd(n,m)) |
In> Lcm(60,24) Out> 120; |
Beispiele: 1<<10; ergibt 1024 -1024>>10; ergibt -1 |
In> FromBase(2,111111) Out> 63; In> ToBase(16,255) Out> ff; |
In> Precision(10) Out> True; In> N(Sin(1)) Out> 0.8414709848; In> Precision(20) Out> True; In> N(Sin(1)) Out> 0.84147098480789650665; In> GetPrecision() Out> 20; |
In> GetPrecision(); Out> 10; In> Precision(20); Out> True; In> GetPrecision(); Out> 20; |
In> 1/2 Out> 1/2; In> N(1/2) Out> 0.5; In> Sin(1) Out> Sin(1); In> N(Sin(1),10) Out> 0.8414709848; In> Pi Out> Pi; In> N(Pi,20) Out> 3.14159265358979323846; |
In> {1.2,3.123,4.5} Out> {1.2,3.123,4.5}; In> Rationalize(%) Out> {6/5,3123/1000,9/2}; In> Sin(1.234) Out> Sin(1.234); In> Rationalize(%) Out> Sin(617/500); |
In> IsPrime(1) Out> False; In> IsPrime(2) Out> True; In> IsPrime(10) Out> False; In> IsPrime(23) Out> True; In> Select("IsPrime", 1 .. 100) Out> {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97}; |
In> IsPrimePower(9) Out> True; In> IsPrimePower(10) Out> False; In> Select("IsPrimePower", 1 .. 50) Out> {2,3,4,5,7,8,9,11,13,16,17,19,23,25,27,29,31,32,37,41,43,47,49}; |
Das Ergebnis ist eine Liste der Form {p,n}, wobei jedes p^n ein Teiler von x ist.
Die Funktion Factor gibt das Ergebnis von Factors in einem übersichtlicheren Format aus.
In> Factors(24); Out> {{2,3},{3,1}}; In> Factors(2*x^3 + 3*x^2 - 1); Out> {{2,1},{x+1,2},{x-1/2,1}}; |
In> PrettyForm(Factor(24)); 3 2 * 3 Out> True; In> PrettyForm(Factor(2*x^3 + 3*x^2 - 1)); 2 / 1 \ 2 * ( x + 1 ) * | x - - | \ 2 / Out> True; |
n = a0 +a1*p +a2*p^2+...
Beispiel:
In> PrettyForm(PAdicExpand(1234,10)) 2 3 4 + 3 * 10 + 2 * 10 + 10 Out> True; In> PrettyForm(PAdicExpand(x^3, x-1)); 2 3 3 * ( x - 1 ) + 3 * ( x - 1 ) + ( x - 1 ) + 1 Out> True; |
In> PrettyForm(ContFrac(N(Pi))) 1 --------------------------- + 3 1 ----------------------- + 7 1 ------------------ + 15 1 -------------- + 1 1 -------- + 292 rest + 1 Out> True; In> PrettyForm(ContFrac(x^2+x+1, 3)) x ---------------- + 1 x 1 - ------------ x -------- + 1 rest + 1 Out> True; |
In> Decimal(1/22) Out> {0,0,{4,5}}; In> N(1/22,30) Out> 0.045454545454545454545454545454; |
Die Funktion arbeitet nach folgender Formel:
/ r \ r - MathFloor| ------ | * 2 * Pi \ 2 * Pi / |
In> 2*Pi() Out> 6.283185307; In> TruncRadian(6.28) Out> 6.28; In> TruncRadian(6.29) Out> 0.0068146929; |
In> Floor(1.1) Out> 1; In> Floor(-1.1) Out> -2; |
In> Ceil(1.1) Out> 2; In> Ceil(-1.1) Out> -1; |
In> Round(1.49) Out> 1; In> Round(1.51) Out> 2; In> Round(-1.49) Out> -1; In> Round(-1.51) Out> -2; |
In> Pslq({ 2*Pi+3*Exp(1) , Pi , Exp(1) },20) Out> {1,-2,-3}; |
Sin, Cos, Tan | trigonometrische Funktionen |
ArcSin, ArcCos, ArcTan | inverse trigonometrische Funktionen |
Exp | Exponentialfunktion |
Ln | natürlicher Logarithmus |
Sqrt | Quadratwurzel |
Abs | Absolutbetrag |
Sign | Signum |
Complex | Darstellung einer komplexen Zahl |
Re | Realteil einer komplexen Zahl |
Im | Imaginärteil einer komplexen Zahl |
I | imaginäre Einheit |
Conjugate | konjugiert komplexe Zahl |
Arg | Argument einer komplexen Zahl |
! | Fakultät |
Bin | Binomialkoeffizient |
Sum | Summe einer Liste von Zahlen |
Average | Mittelwert einer Liste von Zahlen |
Factorize | Produkt einer Liste von Zahlen |
Min | Minimum einer Liste von Zahlen |
Max | Maximum einer Liste von Zahlen |
IsZero | testen, ob das Argument Null ist |
IsRational | testen, ob das Argument ein Bruch ist |
Numer | Zähler eines Ausdrucks |
Denom | Nenner eines Ausdrucks |
Commutator | Kommutator zweier Objekte |
Taylor | univariate Taylorentwicklung |
InverseTaylor | inverse Taylorentwicklung |
ReversePoly | berechnet "h(f(x)) = g(x) + O(x^n)" für h |
BigOh | alle Terme ab einer best. Ordnung aus einem Polynom entfernen |
Newton | Nullstellenbestimmung mit dem Newtonverfahren |
D | Differentiation |
Curl | Rotation eines Vektorfeldes |
Diverge | Divergenz eines Vektorfeldes |
Integrate | Integration |
Simplify | einen Ausdruck vereinfachen |
RadSimp | einen Ausdruck mit verschachtelten Wurzelausdrücken vereinfachen |
Rationalize | Umwandlung einer Dezimalzahl in einen Bruch |
Solve | Lösung einer Gleichung bzw. eines Gleichungssystems |
SuchThat | einen Wert so bestimmen, dass ein Ausdruck Null wird |
Eliminate | substituieren und vereinfachen |
PSolve | Nullstellen eines Polynoms berechnen |
Pi | Näherungswert für pi |
Random | Zufallszahl zwischen 0 und 1 |
VarList | Liste aller in einem Term enthaltenen Variablen |
Limit | Grenzwert eines Ausdrucks |
TrigSimpCombine | Produkte trig. Funktionen in Summen umformen |
LagrangeInterpolant | Lagrange-Interpolation |
Fibonacci | Fibonacci Zahlen |
Yacas kennt grundlegende trigonometrische Zusammenhänge, so dass exakte Vereinfachungen ohne die N(...)-Funktionen möglich sind. Dies ist z.B. immer dann der Fall, wenn die Argumente Vielfache oder Bruchteile von Pi sind.
In> Sin(1) Out> Sin(1); In> N(Sin(1),20) Out> 0.84147098480789650665; In> Sin(Pi/4) Out> Sqrt(2)/2; |
Der Wertebereich der Funktionen "ArcSin(x)" und "ArcTan(x)" ist das Intervall [-Pi/2 | Pi/2], der der Funktion "ArcCos(x)" das Intervall [0 | Pi].
Yacas lässt diese Funktionen in Berechnungen unverändert, die Berechnung von Näherungswerten kann jedoch durch Anwendung der N-Funktion erzwungen werden. Bei besonderen Argumenten (z.B. -1, 0, 1 usw.) wird der Ausdruck vereinfacht. Ist das Argument eine komplexe Zahl, wird der Ausdruck in eine Ln-Funktion umgeformt.
Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
In> ArcSin(1) Out> Pi/2; In> ArcSin(1/3) Out> ArcSin(1/3); In> Sin(ArcSin(1/3)) Out> 1/3; In> N(ArcSin(0.75)) Out> 0.848062; In> N(Sin(%)) Out> 0.7499999477; |
Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
In> Exp(0) Out> 1; In> Exp(I*Pi) Out> -1; In> Exp(2) Out> Exp(2); In> Ln(%) Out> 2; In> N(Exp(1)) Out> 2.7182818284; |
Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
In> Ln(1) Out> 0; In> Ln(Exp(x)) Out> x; In> D(x) Ln(x) Out> 1/x; |
Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
In> Sqrt(16) Out> 4; In> Sqrt(15) Out> Sqrt(15); In> N(Sqrt(15)) Out> 3.8729833462; In> Sqrt(4/9) Out> 2/3; In> Sqrt(-1) Out> Complex(0,1); |
In> Abs(-2) Out> 2; In> Abs(-1/2); Out> -1/2; In> Abs(3+4*I); Out> 5; |
In> Sign(2) Out> 1; In> Sign(-3) Out> -1; In> Sign(0) Out> 1; In> Sign(-3) * Abs(-3) Out> -3; |
In> I Out> Complex(0,1); In> z := 2+3*I Out> Complex(2,3); In> Complex(-2,0) Out> -2; |
In> Re(5) Out> 5; In> Re(I) Out> 0; In> Re(Complex(3,4)) Out> 3; |
In> Im(5) Out> 0; In> Im(I) Out> 1; In> Im(Complex(3,4)) Out> 4; |
In> I Out> Complex(0,1); In> I = Sqrt(-1) Out> True; |
In> Conjugate(2) Out> 2; In> Conjugate(Complex(a,b)) Out> Complex(a,-b); |
In> Arg(2) Out> 0; In> Arg(-1) Out> Pi; In> Arg(1+I) Out> Pi/4; |
In> 10! Out> 3628800; In> 1 * 2 * 3 * 4 * 5 Out> 120; In> (10!)/((6!)*(4!)) Out> 210; In> (3/2)! Out> (3*Sqrt(Pi))/4; |
In> Bin(10, 4) Out> 210; In> 10! / (4! * 6!) Out> 210; |
In der zweiten Form wird der Ausdruck "body" für alle ganzen Zahlen "var" aus dem Bereich "from" bis "to" berechnet und die Summe der Ergebnisse zurückgegeben.
In> Sum({1,4,9}); Out> 14; In> Sum(i, 1, 3, i^2); Out> 14; |
In> Average({1,2,3,4,5}); Out> 3; In> Average({2,6,7}); Out> 5; |
In der zweiten Form wird der Ausdruck "body" für alle ganzen Zahlen "var" aus dem Bereich "from" bis "to" berechnet und das Produkt der Ergebnisse zurückgegeben.
In> Factorize({1,2,3,4}); Out> 24; In> Factorize(i, 1, 4, i); Out> 24; |
In> Min(2,3); Out> 2; In> Min({5,8,4}); Out> 4; |
In> Max(2,3); Out> 3; In> Max({5,8,4}); Out> 8; |
In> IsZero(3.25) Out> False; In> IsZero(0) Out> True; In> IsZero(x) Out> False; |
In> IsRational(5) Out> False; In> IsRational(2/7) Out> True; In> IsRational(a/b) Out> True; In> IsRational(x + 1/x) Out> False; |
In> Numer(2/7) Out> 2; In> Numer(a / x^2) Out> a; In> Numer(5) Out> 5; |
In> Denom(2/7) Out> 7; In> Denom(a / x^2) Out> x^2; In> Denom(5) Out> 1; |
In> Commutator(2,3) Out> 0; In> m1:=Identity(3) Out> {{1,0,0},{0,1,0},{0,0,1}}; In> m1[1][2] := a Out> True; In> m2:=Identity(3) Out> {{1,0,0},{0,1,0},{0,0,1}}; In> m2[2][2] := a Out> True; In> Commutator(m1,m2) Out> {{0,a^2-a,0},{0,0,0},{0,0,0}}; In> PrettyPrinter("PrettyForm"); True Out> In> A := { {0,x}, {0,0} } / \ | ( 0 ) ( x ) | | | | ( 0 ) ( 0 ) | \ / Out> In> B := { {y,0}, {0,z} } / \ | ( y ) ( 0 ) | | | | ( 0 ) ( z ) | \ / Out> In> Commutator(A,B) / \ | ( 0 ) ( x * z - y * x ) | | | | ( 0 ) ( 0 ) | \ / Out> |
In> Taylor(x,0,9)Sin(x) 3 5 7 9 x x x x x - -- + --- - ---- + ------ 6 120 5040 362880 Out> True; |
In> PrettyPrinter("PrettyForm") True Out> In> exp1 := Taylor(x,0,7)Sin(x) 3 5 7 x x x x - -- + --- - ---- 6 120 5040 Out> In> exp2 := InverseTaylor(x,0,8)ArcSin(x) 5 7 3 x x x --- - ---- - -- + x 120 5040 6 Out> In> Simplify(exp1-exp2) 0 Out> |
Diese Funktion wird zur Berechnung der Taylorreihe einer Funktion benötigt:
Ist g(var)=var, dann gilt h(f(var))=var und h ist somit die Umkehrfunktion von f.
In> f(x):=Eval(Expand((1+x)^4)) Out> True; In> g(x) := x^2 Out> True; In> h(y):=Eval(ReversePoly(f(x),g(x),x,y,8)) Out> True; In> BigOh(h(f(x)),x,8) Out> x^2; In> h(x) Out> (-2695*(x-1)^7)/131072+(791*(x-1)^6)/32768+(-119*(x-1)^5)/4096+(37*(x-1)^4)/1024+(-3*(x-1)^3)/64+(x-1)^2/16; |
In> BigOh(1+x+x^2+x^3,x,2) Out> x+1; |
In> Newton(Sin(x),x,3,0.0001) Out> 3.1415926535; |
In> D(x)Sin(x*y) Out> y*Cos(x*y); In> D({x,y,z})Sin(x*y) Out> {y*Cos(x*y),x*Cos(x*y),0}; In> D(x,2)Sin(x*y) Out> -Sin(x*y)*y^2; In> D(x){Sin(x),Cos(x)} Out> {Cos(x),-Sin(x)}; |
In> Diverge({x*y,x*y,x*y},{x,y,z}) Out> {y,x,0}; In> Curl({x*y,x*y,x*y},{x,y,z}) Out> {x,-y,y-x}; |
In> Diverge({x*y,x*y,x*y},{x,y,z}) Out> y+x; |
In> Integrate(x,a,b)Cos(x) Out> Sin(b)-Sin(a); In> Integrate(x)Cos(x) Out> Sin(x)+C9; |
In> a*b*a^2/b-a^3 Out> (b*a^3)/b-a^3; In> Simplify(a*b*a^2/b-a^3) Out> 0; |
In> RadSimp(Sqrt(9+4*Sqrt(2))) Out> 1+Sqrt(8); In> RadSimp(Sqrt(5+2*Sqrt(6))+Sqrt(5-2*Sqrt(6))) Out> Sqrt(12); In> RadSimp(Sqrt(14+3*Sqrt(3+2*Sqrt(5-12*Sqrt(3-2*Sqrt(2)))))) Out> 3+Sqrt(2); |
Im folgenden Beispiel wird aufgrund der numerischen Berechnung ein falsches Ergebnis geliefert:
In> RadSimp(Sqrt(1+10^(-6))) Out> 1; |
In> {1.2,3.123,4.5} Out> {1.2,3.123,4.5}; In> Rationalize(%) Out> {6/5,3123/1000,9/2}; |
In> Solve(a+x*y==z,x) Out> (z-a)/y; In> Solve({a*x+y==0,x+z==0},{x,y}) Out> {{-z,z*a}}; |
Ein mit Solve nicht lösbares Beispiel:
In> Solve({x^2-x == y^2-y, x^2-x == y^3+y}, {x,y}); Out> {}; |
In> SuchThat(a+b*x,x) Out> (-a)/b; In> SuchThat(Cos(a)+Cos(b)^2,Cos(b)) Out> (-Cos(a))^(1/2); In> Expand(a*x+b*x+c,x) Out> c+(a+b)*x; In> SuchThat(%,x) Out> (-c)/(a+b); |
In> Subst(Cos(b), c) (Sin(a)+Cos(b)^2/c) Out> Sin(a)+c^2/c; In> Eliminate(Cos(b), c, Sin(a)+Cos(b)^2/c) Out> Sin(a)+c; |
In> PSolve(b*x+a,x) Out> -a/b; In> PSolve(c*x^2+b*x+a,x) Out> {(Sqrt(b^2-4*c*a)-b)/(2*c),(-(b+Sqrt(b^2-4*c*a)))/(2*c)}; |
In> Pi() Out> 3.14159265358979323846; In> Precision(40) Out> True; In> Pi() Out> 3.1415926535897932384626433832795028841971; |
In> VarList(Sin(x)) Out> {x}; In> VarList(x+a*y) Out> {x,a,y}; |
Über den Parameter "dir" kann die Richtung der Annäherung vorgegeben werden. Erlaubt sind die Werte Left oder Right.
In> Limit(x,0) Sin(x)/x Out> 1; In> Limit(x,0) (Sin(x)-Tan(x))/(x^3) Out> -1/2; In> Limit(x,0) 1/x Out> Undefined; In> Limit(x,0,Left) 1/x Out> -Infinity; In> Limit(x,0,Right) 1/x Out> Infinity; |
Das Ergebnis der Umformung wird soweit wie möglich vereinfacht.
Diese Funktion wird z.B. bei Integrate verwendet, um den Integranden in eine leichter integrierbare Form zu bringen.
In> PrettyPrinter("PrettyForm"); True Out> In> TrigSimpCombine(Cos(a)^2+Sin(a)^2) 1 Out> In> TrigSimpCombine(Cos(a)^2-Sin(a)^2) Cos( 2 * a ) Out> In> TrigSimpCombine(Cos(a)^2*Sin(b)) Sin( b ) Sin( -2 * a + b ) Sin( -2 * a - b ) -------- + ----------------- - ----------------- 2 4 4 Out> |
In> LagrangeInterpolant({x1,x2,x3},{y1,y2,y3},x) y1 * ( x - x2 ) * ( x - x3 ) y2 * ( x - x1 ) * ( x - x3 ) ---------------------------- + ---------------------------- ( x1 - x2 ) * ( x1 - x3 ) ( x2 - x1 ) * ( x2 - x3 ) y3 * ( x - x1 ) * ( x - x2 ) + ---------------------------- ( x3 - x1 ) * ( x3 - x2 ) Out> |
In> Fibonacci(4) Out> 3; In> Fibonacci(8) Out> 21; |
LeviCivita | der vollständig antisymmetrische Levi-Civita-Tensor |
Permutations | Permutationen einer Liste |
InProduct | Skalarprodukt von Vektoren |
CrossProduct | Kreuzprodukt von Vektoren |
ZeroVector | Nullvektor |
BaseVector | Basisvektor |
Identity | Einheitsmatrix |
ZeroMatrix | Nullmatrix |
DiagonalMatrix | Diagonalmatrix |
IsMatrix | testet, ob das Argument eine Matrix ist |
Normalize | Einheitsvektor |
Transpose | transponierte Matrix |
Determinant | Determinante einer Matrix |
Trace | Spur einer Matrix |
Inverse | Inverses einer Matrix |
Minor | Streichungsdeterminante |
CoFactor | Unterdeterminante |
SolveMatrix | Lösung eines linearen Gleichungssystems |
CharacteristicEquation | charakteristisches Polynom einer Matrix |
EigenValues | Eigenwerte einer Matrix |
EigenVectors | Eigenvectors of a matrix |
IsHermitean | testet, ob das Argument eine hermitesche Matrix ist |
IsUnitary | testet, ob das Argument eine unitäre Matrix ist |
In> LeviCivita({1,2,3}) Out> 1; In> LeviCivita({2,1,3}) Out> -1; In> LeviCivita({2,2,3}) Out> 0; |
In> Permutations({a,b,c}) Out> {{a,b,c},{a,c,b},{c,a,b},{b,a,c},{b,c,a},{c,b,a}}; |
In> {a,b,c} . {d,e,f}; Out> a*d+b*e+c*f; |
In> {a,b,c} X {d,e,f}; Out> {b*f-c*e,c*d-a*f,a*e-b*d}; |
In> ZeroVector(4) Out> {0,0,0,0}; |
In> BaseVector(2,4) Out> {0,1,0,0}; |
In> Identity(3) Out> {{1,0,0},{0,1,0},{0,0,1}}; |
In> ZeroMatrix(3,4) Out> {{0,0,0,0},{0,0,0,0},{0,0,0,0}}; |
In> DiagonalMatrix(1 .. 4) Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}}; |
In> IsMatrix(ZeroMatrix(3,4)) Out> True; In> IsMatrix(ZeroVector(4)) Out> False; In> IsMatrix(3) Out> False; |
In> Normalize({3,4}) Out> {3/5,4/5}; In> % . % Out> 1; |
In> Transpose({{a,b}}) Out> {{a},{b}}; |
In> DiagonalMatrix(1 .. 4) Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}}; In> Determinant(%) Out> 24; |
In> DiagonalMatrix(1 .. 4) Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}}; In> Trace(%) Out> 10; |
In> DiagonalMatrix({a,b,c}) Out> {{a,0,0},{0,b,0},{0,0,c}}; In> Inverse(%) Out> {{(b*c)/(a*b*c),0,0},{0,(a*c)/(a*b*c),0},{0,0,(a*b)/(a*b*c)}}; In> Simplify(%) Out> {{1/a,0,0},{0,1/b,0},{0,0,1/c}}; |
In> A := {{1,2,3}, {4,5,6}, {7,8,9}}; Out> {{1,2,3},{4,5,6},{7,8,9}}; In> PrettyForm(A); / \ | ( 1 ) ( 2 ) ( 3 ) | | | | ( 4 ) ( 5 ) ( 6 ) | | | | ( 7 ) ( 8 ) ( 9 ) | \ / Out> True; In> Minor(A,1,2); Out> -6; In> Determinant({{2,3}, {8,9}}); Out> -6; |
In> A := {{1,2,3}, {4,5,6}, {7,8,9}}; Out> {{1,2,3},{4,5,6},{7,8,9}}; In> PrettyForm(A); / \ | ( 1 ) ( 2 ) ( 3 ) | | | | ( 4 ) ( 5 ) ( 6 ) | | | | ( 7 ) ( 8 ) ( 9 ) | \ / Out> True; In> CoFactor(A,1,2); Out> 6; In> Minor(A,1,2); Out> -6; In> Minor(A,1,2) * (-1)^(1+2); Out> 6; |
In> A := {{1,2}, {3,4}}; Out> {{1,2},{3,4}}; In> v := {5,6}; Out> {5,6}; In> x := SolveMatrix(A, v); Out> {-4,9/2}; In> A * x; Out> {5,6}; |
In> DiagonalMatrix({a,b,c}) Out> {{a,0,0},{0,b,0},{0,0,c}}; In> CharacteristicEquation(%,x) Out> (a-x)*(b-x)*(c-x); In> Expand(%,x) Out> (b+a+c)*x^2-x^3-((b+a)*c+a*b)*x+a*b*c; |
In> M:={{1,2},{2,1}} Out> {{1,2},{2,1}}; In> EigenValues(M) Out> {3,-1}; |
In> M:={{1,2},{2,1}} Out> {{1,2},{2,1}}; In> e:=EigenValues(M) Out> {3,-1}; In> EigenVectors(M,e) Out> {{-ki2/ -1,ki2},{-ki2,ki2}}; |
In> IsHermitean({{0,I},{-I,0}}) Out> True; In> IsHermitean({{0,I},{2,0}}) Out> False; |
In> IsUnitary({{0,I},{-I,0}}) Out> True; In> IsUnitary({{0,I},{2,0}}) Out> False; |
Expand | formt das Polynom um in die Summenschreibweise |
Degree | Grad eines Polynoms |
Coef | Koeffizient eines Polynoms |
Content | Inhalt eines univariaten Polynoms |
PrimitivePart | primitiver Teil eines univariaten Polynoms |
LeadingCoef | führender Koeffizient eines Polynoms |
Monic | normierter Teil eines Polynoms |
RandomPoly | Zufallspolynom |
Horner | Hornerform eines Polynoms |
ExpandBrackets | Auflösen aller im Polynom enthaltenen Klammerausdrücke |
OrthoP | orthogonale Legendre und Jacobi Polynome |
OrthoH | hermitesche orthogonale Polynome |
OrthoG | orthogonale Gegenbauer Polynome |
OrthoL | orthogonale Laguerre Polynome |
OrthoT | Tshebyscheff Polynome erster Art |
OrthoU | Tshebyscheff Polynome zweiter Art |
OrthoPSum | Summe einer Folge von Legendre und Jacobi Polynomen |
OrthoHSum | Summe einer Folge von hermiteschen Polynomen |
OrthoLSum | Summe einer Folge von Laguerre Polynomen |
OrthoGSum | Summe einer Folge von Gegenbauer Polynomen |
OrthoTSum | Summe einer Folge von Tschebyscheff Polynomen erster Art |
OrthoUSum | Summe einer Folge von Tschebyscheff Polynomen zweiter Art |
OrthoPoly | interne Funktion zum Erzeugen orthogonaler Polynome |
OrthoPolySum | interne Funktion zum Berechnen von Reihen orthogonaler Polynome |
Enthält der Term "expr" nur eine Variable, so kann der erste Funktionsaufruf verwendet werden, ansonsten muss die Funktionsvariable mit "var" explizit angegeben werden.
In> PrettyPrinter("PrettyForm"); True Out> In> Expand((1+x)^5); 5 4 3 2 x + 5 * x + 10 * x + 10 * x + 5 * x + 1 Out> In> Expand((1+x-y)^2, x); 2 2 x + 2 * ( 1 - y ) * x + ( 1 - y ) Out> In> Expand((1+x-y)^2, {x,y}); 2 2 x + ( -2 * y + 2 ) * x + y - 2 * y + 1 Out> |
In> Degree(x^5+x-1); Out> 5; In> Degree(a+b*x^3, a); Out> 1; In> Degree(a+b*x^3, x); Out> 3; |
In> e := Expand((a+x)^4,x) Out> x^4+4*a*x^3+(a^2+(2*a)^2+a^2)*x^2+(a^2*2*a+2*a^3)*x+a^4; In> Coef(e,a,2) Out> 6*x^2; In> Coef(e,a,0 .. 4) Out> {x^4,4*x^3,6*x^2,4*x,1}; |
In> poly := 2*x^2 + 4*x; Out> 2*x^2+4*x; In> c := Content(poly); Out> 2*x; In> pp := PrimitivePart(poly); Out> x+2; In> Expand(pp*c); Out> 2*x^2+4*x; |
In> poly := 2*x^2 + 4*x; Out> 2*x^2+4*x; In> c := Content(poly); Out> 2*x; In> pp := PrimitivePart(poly); Out> x+2; In> Expand(pp*c); Out> 2*x^2+4*x; |
In> poly := 2*x^2 + 4*x; Out> 2*x^2+4*x; In> lc := LeadingCoef(poly); Out> 2; In> m := Monic(poly); Out> x^2+2*x; In> Expand(lc*m); Out> 2*x^2+4*x; In> LeadingCoef(2*a^2 + 3*a*b^2 + 5, a); Out> 2; In> LeadingCoef(2*a^2 + 3*a*b^2 + 5, b); Out> 3*a; |
In> poly := 2*x^2 + 4*x; Out> 2*x^2+4*x; In> lc := LeadingCoef(poly); Out> 2; In> m := Monic(poly); Out> x^2+2*x; In> Expand(lc*m); Out> 2*x^2+4*x; In> Monic(2*a^2 + 3*a*b^2 + 5, a); Out> a^2+(a*3*b^2)/2+5/2; In> Monic(2*a^2 + 3*a*b^2 + 5, b); Out> b^2+(2*a^2+5)/(3*a); |
In> RandomPoly(x,3,-10,10) Out> 3*x^3+10*x^2-4*x-6; In> RandomPoly(x,3,-10,10) Out> -2*x^3-8*x^2+8; |
n-1 n c(0) + c(1) * x + ... + c(n-1) * x + c(n) * x |
(...( c(n) * x + c(n-1) ) * x + ... + c(1) ) * x + c(0) |
In> expr1:=Expand((1+x)^4) Out> x^4+4*x^3+6*x^2+4*x+1 In> Horner(expr1,x) Out> (((x+4)*x+6)*x+4)*x+1 |
In> Expand((a-x)*(b-x),x) Out> x^2-(b+a)*x+a*b; In> Expand((a-x)*(b-x),{x,a,b}) Out> x^2-(b+a)*x+b*a; In> ExpandBrackets((a-x)*(b-x)) Out> a*b-x*b+x^2-a*x; |
Die Jacobi Polynome sind orthogonal bzgl. der Gewichtsfunktion (1-x)^a (1+x)^b auf dem Intervall [-1 | 1]. Sie erfüllen die Gleichungen:
P(0,a,b,x) = 1 a - b / a + b \ P(1,a,b,x) = ----- + x | 1 + ----- | 2 \ 2 / 2 2 a - b + x (2n+a+b-2) (n+a+b) P(n,a,b,x) = (2n + a + b - 1) * ---------------------------- P(n-1,a,b,x) 2n (2n+a+b-2) (n+a+b) (n+a-1) (n+b-1) (2n+a+b) - ------------------------ P(n-2,a,b,x), for n > 1. n (n+a+b) (2n+a+b-2) |
Legendre Polynome sind spezielle Jacobi Polynome mit den Parametern a = b = 0. Sie erfüllen die Gleichungen:
P(0,x) = 1 P(1,x) = x (2n - 1) x n - 1 P(n,x) = ---------- P(n-1,x) - ----- P(n-2,x), for n > 1. 2n n |
Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
In> PrettyPrinter("PrettyForm"); True Out> In> OrthoP(3, x); / 2 \ | 5 * x 3 | x * | ------ - - | \ 2 2 / Out> In> OrthoP(3, 1, 2, x); 1 / / 21 * x 7 \ 7 \ - + x * | x * | ------ - - | - - | 2 \ \ 2 2 / 2 / Out> In> Expand(%) 3 2 21 * x - 7 * x - 7 * x + 1 ---------------------------- 2 Out> In> OrthoP(3, 1, 2, 0.5); -0.8124999999 Out> |
Die hermiteschen Polynome sind orthogonal bzgl. der Gewichtsfunktion e^(-x^2/2). Sie erfüllen die Gleichungen:
H(0,x) = 1 H(1,x) = 2x H(n,x) = 2x H(n-1,x) - 2(n-1) H(n-2,x), for n > 1. |
Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
In> OrthoH(3, x); Out> x*(8*x^2-12); In> OrthoH(6, 0.5); Out> 31; |
Die Gegenbauer Polynome sind orthogonal bzgl. der Gewichtsfunktion (1-x^2)^(a-1/2) auf dem Intervall [-1 | 1]. Zu den Jacobi Polynomen besteht demnach folgender Zusammenhang: G(n, a, x) = P(n, a-1/2, a-1/2, x). Sie erfüllen die Gleichungen:
G(0,a,x) = 1 G(1,a,x) = 2x / a - 1 \ / 2 (a-2) \ G(n,a,x) = 2 | 1 + ----- | x G(n-1,a,x) - | 1 + ------- | G(n-2,a,x), for n>1. \ n / \ n / |
Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
In> OrthoG(5, 1, x); Out> x*((32*x^2-32)*x^2+6); In> OrthoG(5, 2, -0.5); Out> 2; |
Die Laguerre Polynome sind orthogonal bzgl. der Gewichtsfunktion x^a * e^(-x). Sie erfüllen die Gleichungen:
L(0,a,x) = 1 L(1,a,x) = a + 1 - x / a - 1 - x \ / a - 1 \ L(n,a,x) = | 2 + --------- | L(n-1,a,x) - | 1 + ----- | L(n-2,a,x), for n>1. \ n / \ n / |
Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
In> OrthoL(3, 1, x); Out> x*(x*(2-x/6)-6)+4; In> OrthoL(3, 1/2, 0.25); Out> 1.2005208334; |
Die Tschebyscheff Polynome erster Art sind orthogonal bzgl. der Gewichtsfunktion (1-x^2)^(-1/2). Sie sind spezielle Gegenbauer Polynome mit dem Parameter a=0. Sie erfüllen die Gleichungen:
T(0,x) = 1 T(1,x) = x T(n,x) = 2x T(n-1,x) - T(n-2,x), for n > 1. |
Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
IIn> OrthoT(3, x); Out> x*(4*x^2-3); In> OrthoT(10, 0.9); Out> -0.2007474688; |
Die Tschebyscheff Polynome zweiter Art sind orthogonal bzgl. der Gewichtsfunktion (1-x^2)^(1/2). Sie sind spezielle Gegenbauer Polynome mit dem Parameter a=1. Sie erfüllen die Gleichungen:
U(0,x) = 1 U(1,x) = 2x U(n,x) = 2x U(n-1,x) - u(n-2,x), for n > 1. |
Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
In> OrthoU(3, x); Out> x*(8*x^2-4); In> OrthoU(10, 0.9); Out> -2.2234571776; |
Die Liste der Koeffizienten beginnt mit der kleinsten Ordnung, z.B.:
OrthoLSum(c, a, x) = c[1] L_0(a,x) + c[2] L_1(a,x) + ... + c[N] L_{N-1}(a,x). |
In> Expand(OrthoPSum({1,0,0,1/7,1/8}, 3/2, 2/3, x)); Out> (7068985*x^4)/3981312+(1648577*x^3)/995328+(-3502049*x^2)/4644864+(-4372969*x)/6967296+28292143/27869184; |
Alle bekannten Polynomfamilien sind in der Schlüsselliste KnownOrthoPoly abgespeichert. Der Name wird als Schlüssel verwendet. Zurzeit kennt Yacas folgende Polynomfamilien:
Ist der Wert "x" numerisch, wird die Funktion OrthoPolyNumeric aufgerufen, andernfalls wird mit OrthoPolyCoeffs eine Liste von Koeffizienten berechnet, die mit EvaluateHornerScheme in ein Polynom umgewandelt wird.
Ist der Wert "x" numerisch, wird die Funktion OrthoPolySumNumeric aufgerufen, andernfalls wird mit OrthoPolySumCoeffs eine Liste von Koeffizienten berechnet, die mit EvaluateHornerScheme in ein Polynom umgewandelt wird.
Head | erstes Element einer Liste |
Tail | Liste ohne das erste Element |
Length | Länge einer Liste oder einer Zeichenkette (String) |
Map | Anwenden einer Funktion auf alle Elemente der Liste |
MapSingle | Anwenden einer Funktion auf alle Elemente der Liste |
RandomIntegerVector | Zufallsvektor |
MakeVector | Vektor mit numerierten Variablen |
Select | Selektieren bestimmter Elemente einer Liste |
Nth | das n-te Element einer Liste |
DestructiveReverse | Vertauschen der Reihenfolge aller Elemente |
List | Erzeugen einer Liste |
UnList | Umwandlung einer Liste in einen Funktionsaufruf |
Listify | Umwandlung eines Funktionsaufrufs in eine Liste |
Concat | Aneinanderhängen von Listen |
Delete | Löschen eines Listenelements |
Insert | Einfügen eines Listenelements |
DestructiveDelete | Löschen eines Listenelements mit Änderung der ursprünglichen Liste |
DestructiveInsert | Einfügen eines Listenelements mit Änderung der ursprünglichen Liste |
Replace | Ersetzen eines Listenelements |
DestructiveReplace | Ersetzen eines Listenelements mit Änderung der ursprünglichen Liste |
FlatCopy | Kopieren einer Liste |
Contains | Testen, ob eine Liste ein best. Element enthält |
Find | Durchsuchen einer Liste |
Append | Hinzufügen eines Listenelements am Ende der Liste |
DestructiveAppend | Hinzufügen eines Listenelements am Ende der Liste mit Änderung der ursprünglichen Liste |
RemoveDuplicates | Entfernen von Duplikaten |
Push | Hinzufügen eines Elements zu einem Stack |
Pop | Entfernen eines Elements aus einem Stack |
PopFront | Entfernen des obersten Elements aus einem Stack |
PopBack | Entfernen des untersten Elements aus einem Stack |
Swap | Vertauschen zweier Listenelemente |
Count | Anzahl des Auftretens eines best. Ausdrucks in der Liste |
Intersection | Schnittmenge zweier Listen |
Union | Vereinigungsmenge zweier Listen |
Difference | Differenz zweier Listen |
FillList | Füllen einer Liste mit einem best. Ausdruck |
Drop | Entfernen eines Bereichs von Listenelementen |
Take | Abspalten eines Bereichs von Listenelementen |
Partition | Umformen einer Liste in Teillisten gleicher Länge |
Assoc | Suchen eines Listenelements anhand eines Schlüssels |
AssocIndices | Schlüssel einer Schlüsselliste |
Flatten | Zerlegen eines Terms in eine Liste |
UnFlatten | Erzeugen eines Terms aus den Elementen einer Liste |
Type | den Typ eines Ausdrucks bestimmen |
NrArgs | Anzahl der Argumente eines Ausdrucks bestimmen |
BubbleSort | Sortieren einer Liste |
Table | Erzeugen einer Liste über eine Schleife |
TableForm | gibt die Elemente einer Liste formatiert aus |
In> Head({a,b,c}) Out> a; In> Head(f(a,b,c)); Out> a; |
In> Tail({a,b,c}) Out> {b,c}; |
In> Length({a,b,c}) Out> 3; In> Length("abcdef"); Out> 6; |
In> MapSingle("Sin",{a,b,c}); Out> {Sin(a),Sin(b),Sin(c)}; In> Map("+",{{a,b},{c,d}}); Out> {a+c,b+d}; |
Der /@ Operator ist eine Abkürzung für MapSingle.
In> MapSingle("Sin",{a,b,c}); Out> {Sin(a),Sin(b),Sin(c)}; In> MapSingle({{x},x^2}, {a,2,c}); Out> {a^2,4,c^2}; |
In> RandomIntegerVector(4,-3,3) Out> {0,3,2,-2}; |
In> MakeVector(a,3) Out> {a1,a2,a3}; |
In> Select("IsInteger",{a,b,2,c,3,d,4,e,f}) Out> {2,3,4}; |
Auf einen Term angewendet ist das Ergebnis der n-te Operand.
Eine äquivalente Form von Nth(list, n) ist list[n].
In> lst := {a,b,c,13,19}; Out> {a,b,c,13,19}; In> Nth(lst, 3); Out> c; In> lst[3]; Out> c; In> Nth(lst, {3,4,1}); Out> {c,13,a}; In> Nth(b*(a+c), 2); Out> a+c; |
Es gibt keine Funktion, die eine Liste dreht ohne das Original zu zerstören. Soll das Original erhalten bleiben, muss die Liste zunächst mit FlatCopy kopiert werden.
In> lst := {a,b,c,13,19}; Out> {a,b,c,13,19}; In> revlst := DestructiveReverse(lst); Out> {19,13,c,b,a}; In> lst; Out> {a}; |
In> List(); Out> {}; In> List(a,b); Out> {a,b}; In> List(a,{1,2},d); Out> {a,{1,2},d}; |
Die Liste "list" wird vor dem Erstellen des Funktionsaufrufs berechnet, der resultierende Funktionsaufruf jedoch nicht.
In> UnList({Cos, x}); Out> Cos(x); In> UnList({f}); Out> f(); In> UnList({Taylor,x,0,5,Cos(x)}); Out> Taylor(x,0,5)Cos(x); In> Eval(%); Out> 1-x^2/2+x^4/24; |
In> Listify(Cos(x)); Out> {Cos,x}; In> Listify(3*a); Out> {*,3,a}; |
In> Concat({a,b}, {c,d}); Out> {a,b,c,d}; In> Concat({5}, {a,b,c}, {{f(x)}}); Out> {5,a,b,c,{f(x)}}; |
In> Delete({a,b,c,d,e,f}, 4); Out> {a,b,c,e,f}; |
In> Insert({a,b,c,d}, 4, x); Out> {a,b,c,x,d}; In> Insert({a,b,c,d}, 5, x); Out> {a,b,c,d,x}; In> Insert({a,b,c,d}, 1, x); Out> {x,a,b,c,d}; |
In> lst := {a,b,c,d,e,f}; Out> {a,b,c,d,e,f}; In> Delete(lst, 4); Out> {a,b,c,e,f}; In> lst; Out> {a,b,c,d,e,f}; In> DestructiveDelete(lst, 4); Out> {a,b,c,e,f}; In> lst; Out> {a,b,c,e,f}; |
In> lst := {a,b,c,d}; Out> {a,b,c,d}; In> Insert(lst, 2, x); Out> {a,x,b,c,d}; In> lst; Out> {a,b,c,d}; In> DestructiveInsert(lst, 2, x); Out> {a,x,b,c,d}; In> lst; Out> {a,x,b,c,d}; |
In> Replace({a,b,c,d,e,f}, 4, x); Out> {a,b,c,x,e,f}; |
In> lst := {a,b,c,d,e,f}; Out> {a,b,c,d,e,f}; In> Replace(lst, 4, x); Out> {a,b,c,x,e,f}; In> lst; Out> {a,b,c,d,e,f}; In> DestructiveReplace(lst, 4, x); Out> {a,b,c,x,e,f}; In> lst; Out> {a,b,c,x,e,f}; |
In> reverse(l_IsList) <-- DestructiveReverse(FlatCopy(l)); Out> True; In> lst := {a,b,c,d,e}; Out> {a,b,c,d,e}; In> reverse(lst); Out> {e,d,c,b,a}; In> lst; Out> {a,b,c,d,e}; |
In> Contains({a,b,c,d}, b); Out> True; In> Contains({a,b,c,d}, x); Out> False; In> Contains({a,{1,2,3},z}, 1); Out> False; In> Contains(a*b, b); Out> True; |
In> Find({a,b,c,d,e,f}, d); Out> 4; In> Find({1,2,3,2,1}, 2); Out> 2; In> Find({1,2,3,2,1}, 4); Out> -1; |
Hinweis: Die Zeit für das Anhängen am Listenende wächst proportional mit der Listenlänge; die Zeit für das Hinzufügen am Listenanfang ist konstant.
In> Append({a,b,c,d}, 1); Out> {a,b,c,d,1}; |
In> lst := {a,b,c,d}; Out> {a,b,c,d}; In> Append(lst, 1); Out> {a,b,c,d,1}; In> lst Out> {a,b,c,d}; In> DestructiveAppend(lst, 1); Out> {a,b,c,d,1}; In> lst; Out> {a,b,c,d,1}; |
In> RemoveDuplicates({1,2,3,2,1}); Out> {1,2,3}; In> RemoveDuplicates({a,1,b,1,c,1}); Out> {a,1,b,c}; |
In> stack := {}; Out> {}; In> Push(stack, x); Out> {x}; In> Push(stack, x2); Out> {x2,x}; In> PopFront(stack); Out> x2; |
In> stack := {}; Out> {}; In> Push(stack, x); Out> {x}; In> Push(stack, x2); Out> {x2,x}; In> Push(stack, x3); Out> {x3,x2,x}; In> Pop(stack, 2); Out> x2; In> stack; Out> {x3,x}; |
In> stack := {}; Out> {}; In> Push(stack, x); Out> {x}; In> Push(stack, x2); Out> {x2,x}; In> Push(stack, x3); Out> {x3,x2,x}; In> PopFront(stack); Out> x3; In> stack; Out> {x2,x}; |
In> stack := {}; Out> {}; In> Push(stack, x); Out> {x}; In> Push(stack, x2); Out> {x2,x}; In> Push(stack, x3); Out> {x3,x2,x}; In> PopBack(stack); Out> x; In> stack; Out> {x3,x2}; |
In> lst := {a,b,c,d,e,f}; Out> {a,b,c,d,e,f}; In> Swap(lst, 2, 4); Out> {a,d,c,b,e,f}; |
In> lst := {a,b,c,b,a}; Out> {a,b,c,b,a}; In> Count(lst, a); Out> 2; In> Count(lst, c); Out> 1; In> Count(lst, x); Out> 0; |
In> Intersection({a,b,c}, {b,c,d}); Out> {b,c}; In> Intersection({a,e,i,o,u}, {f,o,u,r,t,e,e,n}); Out> {e,o,u}; In> Intersection({1,2,2,3,3,3}, {1,1,2,2,3,3}); Out> {1,2,2,3,3}; |
In> Union({a,b,c}, {b,c,d}); Out> {a,b,c,d}; In> Union({a,e,i,o,u}, {f,o,u,r,t,e,e,n}); Out> {a,e,i,o,u,f,r,t,n}; In> Union({1,2,2,3,3,3}, {2,2,3,3,4,4}); Out> {1,2,3,4}; |
In> Difference({a,b,c}, {b,c,d}); Out> {a}; In> Difference({a,e,i,o,u}, {f,o,u,r,t,e,e,n}); Out> {a,i}; In> Difference({1,2,2,3,3,3}, {2,2,3,4,4}); Out> {1,3,3}; |
In> FillList(x, 5); Out> {x,x,x,x,x}; |
In> lst := {a,b,c,d,e,f,g}; Out> {a,b,c,d,e,f,g}; In> Drop(lst, 2); Out> {c,d,e,f,g}; In> Drop(lst, -3); Out> {a,b,c,d}; In> Drop(lst, {2,4}); Out> {a,e,f,g}; |
In> lst := {a,b,c,d,e,f,g}; Out> {a,b,c,d,e,f,g}; In> Take(lst, 2); Out> {a,b}; In> Take(lst, -3); Out> {e,f,g}; In> Take(lst, {2,4}); Out> {b,c,d}; |
In> Partition({a,b,c,d,e,f,}, 2); Out> {{a,b},{c,d},{e,f}}; In> Partition(1 .. 11, 3); Out> {{1,2,3},{4,5,6},{7,8,9}}; |
Schlüssellisten werden durch Listen von zweielementigen Listen repräsentiert. Das erste Element der zweielementigen Liste ist der Schlüssel, das zweite Element ist der dem Schlüssel zugeordnete Wert.
Ein zu Assoc(key, alist) äquivalenter Funktionsaufruf ist alist[key].
In> writer := {}; Out> {}; In> writer["Iliad"] := "Homer"; Out> True; In> writer["Henry IV"] := "Shakespeare"; Out> True; In> writer["Ulysses"] := "James Joyce"; Out> True; In> Assoc("Henry IV", writer); Out> {"Henry IV","Shakespeare"}; In> Assoc("War and Peace", writer); Out> Empty; |
In> writer := {}; Out> {}; In> writer["Iliad"] := "Homer"; Out> True; In> writer["Henry IV"] := "Shakespeare"; Out> True; In> writer["Ulysses"] := "James Joyce"; Out> True; In> AssocIndices(writer); Out> {"Iliad","Henry IV","Ulysses"}; |
In> Flatten(a+b*c+d,"+"); Out> {a,b*c,d}; In> Flatten({a,{b,c},d},"List"); Out> {a,b,c,d}; |
In> UnFlatten({a,b,c},"+",0) Out> a+b+c; In> UnFlatten({a,b,c},"*",1) Out> a*b*c; |
In> Type({a,b,c}); Out> "List"; In> Type(a*(b+c)); Out> "*"; In> Type(123); Out> ""; |
In> NrArgs(f(a,b,c)) Out> 3; In> NrArgs(Sin(x)); Out> 1; In> NrArgs(a*(b+c)); Out> 2; |
Die Funktion verwendet den BubbleSort-Algorithmus.
In> BubbleSort({4,7,23,53,-2,1}, "<"); Out> {-2,1,4,7,23,53}; In> BubbleSort({4,7,23,53,-2,1}, ">"); Out> {53,23,7,4,1,-2}; |
In> Table(i!, i, 1, 10, 1); Out> {1,2,6,24,120,720,5040,40320,362880,3628800}; In> Table(i, i, 3, 16, 4); Out> {3,7,11,15}; In> Table(i^2, i, 10, 1, -1); Out> {100,81,64,49,36,25,16,9,4,1}; |
In> TableForm(Table(i!, i, 1, 10, 1)); 1 2 6 24 120 720 5040 40320 362880 3628800 Out> True; |
: | Listenelement hinzufügen oder Strings aneinanderhängen |
@ | eine Funktion anwenden |
/@ | eine Funktion auf alle Elemente einer Liste anwenden |
.. | Erzeugen einer Liste aufeinanderfolgender ganzer Zahlen |
In> a:b:c:{} Out> {a,b,c}; In> "This":"Is":"A":"String" Out> "ThisIsAString"; |
In> "Sin" @ a Out> Sin(a); In> {{a},Sin(a)} @ a Out> Sin(a); In> "f" @ {a,b} Out> f(a,b); |
In> "Sin" /@ {a,b} Out> {Sin(a),Sin(b)}; In> {{a},Sin(a)*a} /@ {a,b} Out> {Sin(a)*a,Sin(b)*b}; |
In> 1 .. 4 Out> {1,2,3,4}; |
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 |
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.
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; |
In> Echo({ Hold(1+1), "=", 1+1 }); 1+1 = 2 Out> True; |
In> a := x; Out> x; In> x := 5; Out> 5; In> a; Out> x; In> Eval(a); Out> 5; |
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.
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; |
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; |
In> mysign(x) := If (IsPositiveReal(x), 1, -1); Out> True; In> mysign(Pi); Out> 1; In> mysign(-2.5); Out> -1; |
In> mysign(a); Out> -1; |
In> mysign(_x)_IsNumber(N(x)) <-- If (IsPositiveReal(x), 1, -1); Out> True; |
Dieser Befehl darf im Rahmen der Funktion Secure nicht verwendet werden.
In> Function("FirstOf", {list}) list[1]; Out> True; In> FirstOf({a,b,c}); Out> a; |
Der Befehl wird meist in der Form
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; |
In> ForEach(i,{2,3,5,7,11}) Echo({i, i!}); 2 2 3 6 5 120 7 5040 11 39916800 Out> True; |
In> Apply("+", {5,9}); Out> 14; In> Apply({{x,y}, x-y^2}, {Cos(a), Sin(a)}); Out> Cos(a)-Sin(a)^2; |
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}; |
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; |
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.
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; |
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 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.
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); |
In> SetHelpBrowser("netscape") Out> "netscape"; In> ?? |
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.
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. |
Dieser Befehl erzeugt eine große Ausgabeflut. Bei etwas komplexeren Termen sollte daher der Befehl TraceRule verwendet werden.
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; |
Der Befehl eignet sich insbesondere zur Untersuchung von Funktionen, die von anderen Funktionen aufgerufen werden.
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; |
< | testet, ob der linke Operand kleiner als der rechte ist |
> | testet, ob der linke Operand größer als der rechte ist |
<= | testet, ob der linke Operand kleiner oder gleich dem rechten ist |
>= | testet, ob der linke Operand größer oder gleich dem rechten ist |
!= | testet, ob die beiden Operanden ungleich sind |
= | testet, ob die beiden Operanden gleich sind |
Not | logische Negation |
And | logisches UND |
Or | logisches ODER |
IsFreeOf | testet, ob ein Term von einer Variablen abhängig ist |
IsZeroVector | testet, ob eine Liste nur Nullen enthält |
IsNonObject | testet, ob das Argument kein Objekt ist |
IsEven | testet, ob eine ganze Zahl gerade ist |
IsOdd | testet, ob eine ganze Zahl ungerade ist |
IsFunction | testet, ob das Argument ein zusammengesetztes Objekt ist |
IsAtom | testet, ob das Argument ein Atom ist |
IsString | testet, ob das Argument ein String ist |
IsNumber | testet, ob das Argument eine Zahl ist |
IsList | testet, ob das Argument eine Liste ist |
IsBound | testet, ob dem Argument ein Wert zugeordnet ist |
IsBoolean | testet, ob das Argument einen Wahrheitswert liefert |
IsNegativeNumber | testet, ob das Argument eine negative Zahl ist |
IsNegativeInteger | testet, ob das Argument eine negative ganze Zahl ist |
IsPositiveNumber | testet, ob das Argument eine positive Zahl ist |
IsPositiveInteger | testet, ob das Argument eine positive ganze Zahl ist |
IsNotZero | testet, ob das Argument eine von Null verschiedene Zahl ist |
IsNonZeroInteger | testet, ob das Argument eine von Null verschiedene ganze Zahl ist |
IsInfinity | testet, ob das Argument unendlich ist |
IsPositiveReal | testet, ob das Argument einen positiven Wert ergibt |
IsNegativeReal | testet, ob das Argument einen negativen Wert ergibt |
IsConstant | testet, ob das Argument eine Konstante ist |
Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
In> 2 < 5; Out> True; In> Cos(1) < 5; Out> Cos(1)<5; In> N(Cos(1)) < 5; Out> True |
Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
In> 2 > 5; Out> False; In> Cos(1) > 5; Out> Cos(1)>5; In> N(Cos(1)) > 5; Out> False |
Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
In> 2 <= 5; Out> True; In> Cos(1) <= 5; Out> Cos(1)<=5; In> N(Cos(1)) <= 5; Out> True |
Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
In> 2 >= 5; Out> False; In> Cos(1) >= 5; Out> Cos(1)>=5; In> N(Cos(1)) >= 5; Out> False |
Der Ausdruck e1 != e2 ist äquivalent zu Not(e1 = e2).
In> 1 != 2; Out> True; In> 1 != 1; Out> False; |
Hinweis: Getestet wird, ob die beiden Ausdrücke syntaktisch gleich sind. Das Ergebnis kann False sein, obwohl beide Ausdrücke mathematisch gleich sind (s. Beispiele).
In> e1 := (x+1) * (x-1); Out> (x+1)*(x-1); In> e2 := x^2 - 1; Out> x^2-1; In> e1 = e2; Out> False; In> Expand(e1) = e2; Out> True; |
In> Not True Out> False; In> Not False Out> True; In> Not(a) Out> Not a; |
In> True And False Out> False; In> And(True,True) Out> True; In> False And a Out> False; In> True And a Out> And(a); In> And(True,a,True,b) Out> b And a; |
In> True Or False Out> True; In> False Or a Out> Or(a); In> Or(False,a,b,True) Out> True; |
Mit dem zweiten Funktionsaufruf wird getestet, ob der Ausdruck von irgendeinem der Argumente abhängt. Das Ergebnis ist True, falls keines der Argumente in dem Ausdruck vorkommt, sonst False.
In> IsFreeOf(Sin(x), x); Out> False; In> IsFreeOf(Sin(x), y); Out> True; In> IsFreeOf(D(x) a*x+b, x); Out> True; In> IsFreeOf(Sin(x), {x,y}); Out> False; |
In> IsZeroVector({0, x, 0}); Out> False; In> IsZeroVector({x-x, 1 - D(x) x}); Out> True; |
In> IsEven(4); Out> True; In> IsEven(-1); Out> False; |
In> IsOdd(4); Out> False; In> IsOdd(-1); Out> True; |
In> IsFunction(x+5); Out> True; In> IsFunction(x); Out> False; |
In> IsAtom(x+5); Out> Falso; In> IsAtom(5); Out> True; |
In> IsString("duh"); Out> True; In> IsString(duh); Out> False; |
In> IsNumber(6); Out> True; In> IsNumber(3.25); Out> True; In> IsNumber(I); Out> False; In> IsNumber("duh"); Out> False; |
In> IsList({2,3,5}); Out> True; In> IsList(2+3+5); Out> False; |
In> IsBound(x); Out> False; In> x := 5; Out> 5; In> IsBound(x); Out> True; |
In> IsBoolean(a) Out> False; In> IsBoolean(True) Out> True; In> IsBoolean(a And b) Out> True; |
In> IsNegativeNumber(6); Out> False; In> IsNegativeNumber(-2.5); Out> True; |
In> IsNegativeInteger(31); Out> False; In> IsNegativeInteger(-2); Out> True; |
In> IsPositiveNumber(6); Out> True; In> IsPositiveNumber(-2.5); Out> False; |
In> IsPositiveInteger(31); Out> True; In> IsPositiveInteger(-2); Out> False; |
In> IsNotZero(3.25); Out> True; In> IsNotZero(0); Out> False; |
In> IsNonZeroInteger(0) Out> False; In> IsNonZeroInteger(-2) Out> True; |
In> IsInfinity(10^1000); Out> False; In> IsInfinity(-Infinity); Out> True; |
In> IsPositiveReal(Sin(1)-3/4); Out> True; In> IsPositiveReal(Sin(1)-6/7); Out> False; In> IsPositiveReal(Exp(x)); Out> False; |
In> IsNegativeReal(Sin(1)-3/4); Out> False; In> IsNegativeReal(Sin(1)-6/7); Out> True; In> IsNegativeReal(Exp(x)); Out> False; |
In> IsConstant(Cos(x)) Out> False; In> IsConstant(Cos(2)) Out> True; In> IsConstant(Cos(2+x)) Out> False; |
Not Negation
( (a=>b) And (b=>c) ) => (a=>c) |
In> CanProve(( (a=>b) And (b=>c) ) => (a=>c)) Out> True; |
Not ( Not x) --> x eliminate double negation x=>y --> Not x Or y eliminate implication Not (x And y) --> Not x Or Not y De Morgan's law Not (x Or y) --> Not x And Not y De Morgan's law (x And y) Or z --> (x Or z) And (y Or z) Distribution x Or (y And z) --> (x Or y) And (x Or z) Distribution |
(p1 Or p2 Or ...) And (q1 Or q2 Or ...) And ... |
In> CanProve(a Or Not a) Out> True; In> CanProve(True Or a) Out> True; In> CanProve(False Or a) Out> a; In> CanProve(a And Not a) Out> False; In> CanProve(a Or b Or (a And b)) Out> a Or b; |
% | letztes Ergebnis |
True, False | Wahrheitswerte |
EndOfFile | Dateiende |
Infinity | math. Konstante für den Wert unendlich |
Pi | Kreiszahl, 3.14159... |
Undefined | undefiniertes Ergebnis |
Typische Anwendungsbeispiele sind Simplify(%) und PrettyForm(%) zur Vereinfachung und formatierten Ausgabe von Ergebnissen.
In> Taylor(x,0,5)Sin(x) Out> x-x^3/6+x^5/120; In> PrettyForm(%) 3 5 x x x - -- + --- 6 120 |
In den meisten Fällen erlaubt Yacas das Rechnen mit Infinity.
In> 2*Infinity Out> Infinity; In> 2 |
In> Sin(3*Pi/2) Out> -1; In> Pi Out> Pi; In> N(Pi) Out> 3.1415926535; |
In> 2*Infinity Out> Infinity; In> 0*Infinity Out> Undefined; |
:= | 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 |
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 |
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; |
In der zweiten Form werden alle Listenelemente nacheinander ausgegeben.
Das Ergebnis von Echo ist immer True.
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; |
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; |
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 |
In> Write(1); 1Out> True; In> Write(1,2); 1 2Out> True; |
In> Write("Hello, world!"); "Hello, world!"Out> True; In> WriteString("Hello, world!"); Hello, world!Out> True; |
In> Space(5); Out> True; |
In> NewLine(); Out> True; |
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; |
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; |
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 |
In> str := ToString() \ In> [ WriteString("The square of 8 is "); Write(8^2); ]; Out> "The square of 8 is 64"; |
In> FromString("2+5;") Read(); Out> 2+5; In> FromString("") Read(); Out> EndOfFile; |
Der Ausdruck a+b lautet in LISP-Syntax (+ a b).
In> FromString("(+ a b)") LispRead(); Out> a+b; In> FromString("(List (Sin x) (- (Cos x)))") LispRead(); Out> {Sin(x),-Cos(x)}; |
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.
In> FromString("a := Sin(x)") \ In> While((tok := ReadToken()) != EndOfFile) Echo(tok); a := Sin ( x ) Out> True; |
Diese Funktion stellt sicher, dass eine Datei geladen ist, jedoch nicht ein zweites Mal eingelesen wird.
In eine ansonsten statische Textdatei lassen sich somit dynamische Anteile einbetten.
In> WriteString("First line" : Nl() : "Second line" : Nl()); First line Second line Out> True; |
SetStringMid | einen Teilstring verändern |
StringMid | einen Teilstring kopieren |
String, Atom | ein Atom in einen String umwandeln und umgekehrt |
ConcatStrings | Strings zusammenfügen |
LocalSymbols | einzigartige lokale Variablen erzeugen |
PatchString | in einem String enthaltene Anweisungen ausführen |
In> SetStringMid(3,"XY","abcdef") Out> "abXYef"; |
In> StringMid(3,2,"abcdef") Out> "cd"; In> "abcdefg"[2 .. 4] Out> "bcd"; |
In> String(a) Out> "a"; In> Atom("a") Out> a; |
In> ConcatStrings("a","b","c") Out> "abc"; |
Die Funktion erzeugt freie Variablen, die garantiert unbenutzt sind.
In> LocalSymbols(a,b)a+b Out> $a6+ $b6; |
In> PatchString("Two plus three is <? Write(2+3); ?> "); Out> "Two plus three is 5 "; |
Yacas unterstützt dynamisch ladbare Bibliotheken, mit denen die Funktionalität zur Laufzeit vergrößert werden kann. Mit einem entsprechenden Plugin wäre es z.B. möglich, spezielle Funktionen für numerische Berechnungen einzubinden.
Die Plugin-Schnittstelle ist zurzeit noch im experimentellen Stadium. Einige Beispiele für Plugins befinden sich im plugins/ Verzeichnis. Die Plugins müssen nach der Installation von Yacas gesondert compiliert werden. Das plugins/ Verzeichnis enthält eine README-Datei mit weiteren Hinweisen.
Neben dem Plugin-Mechanismus gibt es das ebenfalls noch in der Entwicklung befindliche Modul 'cstubgen', mit dem Plugins ohne größeren Aufwand erstellt werden können. Das 'cstubgen' Modul erzeugt eine c++ Datei, die sich compilieren und mit der Standardbibliothek linken lässt. Funktionen aus dem Plugin lassen sich dann so wie die eingebauten Yacas Funktionen aufrufen. Das plugins/ Verzeichnis enthält auch hierfür Beispiele (Dateien mit der Endung api.stub).
Zusätzlich zur c++ Datei generiert 'cstubgen' automatisch eine Dokumentationsdatei mit der Endung 'Beschreibung'.
Zurzeit arbeitet der Plugin-Mechanismus nur auf Betriebssystemen, die das ELF-Binärformat unterstützen, wie z.B. Linux.
Der folgende Abschnitt erfordert Kenntnisse in der C++ Programmierung.
In> DllLoad("./libopengl.so"); Out> True; |
Alle Argumente sind als Strings (eingeschlossen in Anführungszeichen) anzugeben.
Wird "fname2" nicht angegeben, dann wird hierfür "fname" angenommen.
Zurzeit werden die Funktionstypen "int", "double" und "void" unterstützt.
StubApiCFunction("void", "glVertex3d", {"double","double","double"}); |
Das Plugin muss eine Funktion der Form
static LispEnvironment* env = NULL; void GlutSetEnv(LispEnvironment& aEnv) { env = &aEnv; } |
StubApiCSetEnv("GlutSetEnv"); |
Fehlt das zweite Argument "freefunction", dann wird die Struktur mit einem Aufruf von free(...) aus dem Speicher entfernt, ansonsten wird die Funktion "freefunction" aufgerufen. Damit lassen sich evtl. erforderlich Operationen vor dem Entfernen der Struktur aus dem Speicher ausführen.
typedef struct SomeStruct { int a; int b; } SomeStruct; |
StubApiCStruct("SomeStruct*") |
Generische Objekte sind in c++ implementierte Objekte, auf die der Yacas-Interpreter zugreifen kann.