Sin, Cos, Tan | Trigonometric functions |
ArcSin, ArcCos, ArcTan | Inverse trigonometric functions |
Exp | Exponential function |
Ln | Natural logarithm |
Sqrt | Square root |
Abs | Absolute value or modulus |
Sign | Sign of a number |
Complex | Construct a complex number |
Re | Real part of a complex number |
Im | Imaginary part of a complex number |
I | Imaginary unit |
Conjugate | Complex conjugate |
Arg | Argument of a complex number |
! | Factorial |
Bin | Binomial coefficient |
Sum | Sum of a list of values |
Average | Average of a list of values |
Factorize | Product of a list of values |
Min | Minimum of a number of values |
Max | Maximum of a number of values |
IsZero | Test whether argument is zero |
IsRational | Test whether argument is a rational |
Numer | Numerator of an expression |
Denom | Denominator of an expression |
Commutator | Commutator of two objects |
Taylor | Univariate Taylor series expansion |
InverseTaylor | Taylor expansion of inverse |
ReversePoly | Solve "h(f(x)) = g(x) + O(x^n)" for h |
BigOh | Drop all terms of a certain order in a polynomial |
Newton | Solve an equation numerically with Newton's method |
D | Differentiation |
Curl | Curl of a vector field |
Diverge | Divergence of a vector field |
Integrate | Integration |
Simplify | Try to simplify an expression |
RadSimp | Simplify expression with nested radicals |
Rationalize | Convert floating point numbers to fractions |
Solve | Solve one or more algebraic equations |
SuchThat | Find a value which makes some expression zero |
Eliminate | Substitute and simplify |
PSolve | Solve a polynomial equation |
Pi | Numerical approximation of pi |
Random | Random number between 0 and 1 |
VarList | List of variables appearing in some expression |
Limit | Limit of an expression |
TrigSimpCombine | Combine products of trigonometric functions |
LagrangeInterpolant | Polynomial interpolation |
Fibonacci | Fibonacci sequence |
Yacas knows some trigonometric identities, so it can simplify to exact results even if N is not used. This is the case when the arguments are multiples of Pi/6 or Pi/4.
These functions are threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
In> Sin(1) Out> Sin(1); In> N(Sin(1),20) Out> 0.84147098480789650665; In> Sin(Pi/4) Out> Sqrt(2)/2; |
Note that the number "y" is not unique. For instance, "Sin(0)" and "Sin(Pi)" both equal 0, so what should "ArcSin(0)" be? In Yacas, it is agreed that the value of "ArcSin(x)" should be in the interval [-Pi/2,Pi/2]. The same goes for "ArcTan(x)". However, "ArcCos(x)" is in the interval [0,Pi].
Usually, Yacas leaves these functions alone unless it is forced to do a numerical evaluation by the N function. If the argument is -1. 0, or 1 however, Yacas will simplify the expression. If the argument is complex, the expression will be rewritten as a Ln function.
These functions are threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
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; |
This function is threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
In> Exp(0) Out> 1; In> Exp(I*Pi) Out> -1; In> N(Exp(1)) Out> 2.7182818284; |
This function is threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
In> Ln(1) Out> 0; In> Ln(Exp(x)) Out> x; In> D(x) Ln(x) Out> 1/x; |
This function is threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
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); |
This function is connected to the Sign function by the identity "Abs(x) * Sign(x) = x" for real "x".
This function is threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
In> Abs(2); Out> 2; In> Abs(-1/2); Out> -1/2; In> Abs(3+4*I); Out> 5; |
This function is connected to the Abs function by the identity "Abs(x) * Sign(x) = x" for real "x".
This function is threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
In> Sign(2) Out> 1; In> Sign(-3) Out> -1; In> Sign(0) Out> 1; In> Sign(-3) * Abs(-3) Out> -3; |
Note that, at the moment, many functions in Yacas assume that all numbers are real unless it is obvious that it is a complex number. Hence Im(Sqrt(x)) evaluates to 0 which is only true for nonnegative "x".
In> I Out> Complex(0,1); In> 3+4*I Out> Complex(3,4); 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; |
This function is threaded, meaning that if the argument "x" is a list, the function is applied to all the entries in the list.
In> 5! Out> 120; In> 1 * 2 * 3 * 4 * 5 Out> 120; In> (1/2)! Out> Sqrt(Pi)/2; |
In> Bin(10, 4) Out> 210; In> 10! / (4! * 6!) Out> 210; |
If the second calling sequence is used, the expression "body" is evaluated while the variable "var" ranges over all integers from "from" upto "to", and the sum of all the results is returned. Obviously, "to" should be greater than or equal to "from".
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; |
If the second calling sequence is used, the expression "body" is evaluated while the variable "var" ranges over all integers from "from" upto "to", and the product of all the results is returned. Obviously, "to" should be greater than or equal to "from".
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> 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> PrettyForm(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,7) ArcSin(x) 5 7 3 x x x --- - ---- - -- + x 120 5040 6 Out> In> Simplify(exp1-exp2) 0 Out> |
This function is used to determine the Taylor series expansion of the inverse of a function "f": if we take "g(var)=var", then "h(f(var))=var" (upto order "degree"), so "h" will be the inverse of "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; |
The function will iterate using Newton's method until it estimates that it has come within a distance "accuracy" of the correct solution, and then it will return its best guess. In particular, it may loop forever if the algorithm does not converge.
In> Newton(Sin(x),x,3,0.0001) Out> 3.1415926535; |
The D operator is threaded in both "var" and "expr". This means that if either of them is a list, the function is applied to each entry in the list. The results are collected in another list which is returned. If both "var" and "expr" are a list, their lengths should be equal. In this case, the first entry in the list "expr" is differentiated with respect to the first entry in the list "var", the second entry in "expr" is differentiated with respect to the second entry in "var", and so on.
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)}; |
Curl(f,x) = { D(x[2]) f[3] - D(x[3]) f[2], D(x[3]) f[1] - D(x[1]) f[3], D(x[1]) f[2] - D(x[2]) f[1] }
Both "vector" and "basis" should be lists of length 3.
In> Curl({x*y,x*y,x*y},{x,y,z}) Out> {x,-y,y-x}; |
Diverge(f,x) = D(x[1]) f[1] + ... + D(x[n]) f[n],
where n is the length of the lists "vector" and "basis". These lists should have equal length.
In> Diverge({x*y,x*y,x*y},{x,y,z}) Out> y+x; |
Some simple integration rules have currently been implemented. Polynomials, quotients of polynomials, the transcendental functions Sin, Cos, Exp, and Ln, and products of these functions with polynomials can all be integrated.
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; |
It does this by trying all possible combinations for "e1", "e2", etcetera. Every possibility is numerically evaluated using N and compared with the numerical evaluation of "expr". If the approximations are equal (upto a certain margin), this possibility is returned. Otherwise, the expression is returned unevaluated.
Note that due to the use of numerical approximations, there is a small chance that the expression returned by RadSimp is close but not equal to "expr". The last example underneath illustrates this problem. Furthermore, if the numerical value of "expr" is large, the number of possibilities becomes exorbitantly big so the evaluation may take very long.
In> RadSimp(Sqrt(9+4*Sqrt(2))) Out> Sqrt(8)+1; 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> Sqrt(2)+3; |
But this command may yield incorrect results:
In> RadSimp(Sqrt(1+10^(-6))) Out> 1; |
It does this by finding the smallest integer n such that multiplying the number with 10^n is an integer. Then it divides by 10^n again, depending on the internal gcd calculation to reduce the resulting division of integers.
In> {1.2,3.123,4.5} Out> {1.2,3.123,4.5}; In> Rationalize(%) Out> {6/5,3123/1000,9/2}; |
The first calling sequence solves the equation "eq" for the variable "var". Use the == operator to form the equation. The value of "var" which satisfies the equation, is returned. Note that only one solution is found and returned.
To solve a system of equations, the second form should be used. It solves the system of equations contained in the list "eqlist" for the variables appearing in the list "varlist". A list of results is returned, and each result is a list containing the values of the variables in "varlist". Again, at most a single solution is returned.
The task of solving a single equation is simply delegated to SuchThat. Multiple equations are solved recursively: firstly, an equation is sought in which one of the variables occurs exactly once; then this equation is solved with SuchThat; and finally the solution is substituted in the other equations by Eliminate decreasing the number of equations by one. This suffices for all linear equations and a large group of simple nonlinear equations.
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}}; |
An example which Solve cannot solve:
In> Solve({x^2-x == y^2-y, x^2-x == y^3+y}, {x,y}); Out> {}; |
Basically, only expressions in which "var" occurs only once are handled; and in fact, SuchThat may even give wrong results if the variables occurs more than once. This is a consequence of the implementation, which repeatedly applies the inverse of the top function until the variable "var" is reached.
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> (a+b)*x+c; 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}; |
The second calling sequence is used for unidirectional limits. If one gives "dir" the value Left, the limit is taken as "var" approaches "val" from the positive infinity; and Right will take the limit from the negative infinity.
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; |
This function is used in for instance Integrate, to bring down the expression into a simpler form that hopefully can be integrated easily.
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> |
The lists "xlist" and "ylist" should be of equal length. Furthermore, the entries of "xlist" should be all distinct to ensure that there is one and only one solution.
This routine uses the Lagrange interpolant formula to build up the polynomial.
In> f := LagrangeInterpolant({0,1,2}, {0,1,1}, x); Out> (x*(x-1))/2-x*(x-2); In> Eval(Subst(x,0) f); Out> 0; In> Eval(Subst(x,1) f); Out> 1; In> Eval(Subst(x,2) f); Out> 1; In> PrettyPrinter("PrettyForm"); True 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> |
The Fibonacci sequence is 1, 1, 2, 3, 5, 8, 13, 21, ..., where every number is the sum of the two preceding numbers. Formally, it is defined by F(1) = 1, F(2) = 1, and F(n+1) = F(n) + F(n-1), where F(n) denotes the n-th Fibonacci number.
In> Fibonacci(4) Out> 3; In> Fibonacci(8) Out> 21; In> Table(Fibonacci(i), i, 1, 10, 1) Out> {1,1,2,3,5,8,13,21,34,55}; |