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; |