Sin, Cos, Tan
,
ArcSin, ArcCos, ArcTan
,
Exp
,
Ln
,
Sqrt
,
Abs
,
Sign
,
Complex
,
Re
,
Im
,
I
,
Conjugate
,
Arg
,
!
,
Bin
,
Sum
,
Average
,
Factorize
,
Min
,
Max
,
IsZero
,
IsRational
,
Numer
,
Denom
,
Commutator
,
Taylor
,
InverseTaylor
,
ReversePoly
,
BigOh
,
Newton
,
D
,
Curl
,
Diverge
,
Integrate
,
Simplify
,
RadSimp
,
Rationalize
,
Solve
,
SuchThat
,
Eliminate
,
PSolve
,
Pi()
,
Random
,
VarList
,
Limit
,
TrigSimpCombine
,
LagrangeInterpolant
,
Fibonacci
.
Calculus
In this chapter, some functions for doing calculus are
described. These include functions implementing differentiation,
integration, standard mathematical functions, and solving of
equations.
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 coefficients |
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 |
Sin, Cos, Tan -- Trigonometric functions
Standard math library
Calling format:
Parameters:
x -- argument to the function, in radians
Description:
These functions represent the trigonometric functions sine, cosine,
and tangent respectively. Yacas leaves them alone even if x is a
number, trying to keep the result as exact as possible. The floating
point approximations of these functions can be forced by using the N function.
Yacas knows some trigonometric identities, so it can simplify to exact
results even if N is not used. This is the case, for instance,
when the argument is a multiple 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.
Examples:
In> Sin(1)
Out> Sin(1);
In> N(Sin(1),20)
Out> 0.84147098480789650665;
In> Sin(Pi/4)
Out> Sqrt(2)/2;
|
See also:
ArcSin
,
ArcCos
,
ArcTan
,
N
,
Pi
.
ArcSin, ArcCos, ArcTan -- Inverse trigonometric functions
Standard math library
Calling format:
ArcSin(x)
ArcCos(x)
ArcTan(x)
Parameters:
x - argument to the function
Description:
These functions represent the inverse trigonometric functions. For
instance, the value of "ArcSin(x)" is the number "y" such that
"Sin(y)" equals "x".
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.
Examples:
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;
|
See also:
Sin
,
Cos
,
Tan
,
N
,
Pi
,
Ln
.
Exp -- Exponential function
Standard math library
Calling format:
Parameters:
x - argument to the function
Description:
This function calculates e raised to the power "x", where e is the
mathematic constant 2.71828... One can use Exp(1)
to represent e.
This function is threaded, meaning that if the argument "x" is a
list, the function is applied to all the entries in the list.
Examples:
In> Exp(0)
Out> 1;
In> Exp(I*Pi)
Out> -1;
In> N(Exp(1))
Out> 2.7182818284;
|
See also:
Ln
,
Sin
,
Cos
,
Tan
,
N
.
Ln -- Natural logarithm
Standard math library
Calling format:
Parameters:
x - argument to the function
Description:
This function calculates the natural logarithm of "x". This is the
inverse function of the exponential function, Exp, ie. "Ln(x) = y" implies that "Exp(y) = x". For complex
arguments, the imaginary part of the logarithm is in the interval
(- Pi, Pi]. This is compatible with the branch cut of Arg.
This function is threaded, meaning that if the argument "x" is a
list, the function is applied to all the entries in the list.
Examples:
In> Ln(1)
Out> 0;
In> Ln(Exp(x))
Out> x;
In> D(x) Ln(x)
Out> 1/x;
|
See also:
Exp
,
Arg
.
Sqrt -- Square root
Standard math library
Calling format:
Parameters:
x - argument to the function
Description:
This function calculates the square root of "x". If the result is
not rational, the call is returned unevaluated unless a numerical
approximation is forced with the N function. This
function can also handle negative and complex arguments.
This function is threaded, meaning that if the argument "x" is a
list, the function is applied to all the entries in the list.
Examples:
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);
|
See also:
Exp
,
^
,
N
.
Abs -- Absolute value or modulus
Standard math library
Calling format:
Parameters:
x - argument to the function
Description:
This function returns the absolute value (also called the modulus) of
"x". If "x" is positive, the absolute value is "x" itself; if
"x" is negative, the absolute value is "-x". For complex "x",
the modulus is the "r" in the polar decomposition
x=r*Exp(I*phi).
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.
Examples:
In> Abs(2);
Out> 2;
In> Abs(-1/2);
Out> -1/2;
In> Abs(3+4*I);
Out> 5;
|
See also:
Sign
,
Arg
.
Sign -- Sign of a number
Standard math library
Calling format:
Sign(x)
Parameters:
x - argument to the function
Description:
This function returns the sign of the real number "x". It is "1"
for positive numbers and "-1" for negative numbers. Somewhat
arbitrarily, Sign(0) is defined to be 1.
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.
Examples:
In> Sign(2)
Out> 1;
In> Sign(-3)
Out> -1;
In> Sign(0)
Out> 1;
In> Sign(-3) * Abs(-3)
Out> -3;
|
See also:
Arg
,
Abs
.
Complex -- Construct a complex number
Standard math library
Calling format:
Parameters:
r - real part
c - imaginary part
Description:
This function represents the complex number "r + I*c", where "I"
is the imaginary unit. It is the standard representation used in Yacas
to represent complex numbers. Both "r" and "c" are supposed to be
real.
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".
Examples:
In> I
Out> Complex(0,1);
In> 3+4*I
Out> Complex(3,4);
In> Complex(-2,0)
Out> -2;
|
See also:
Re
,
Im
,
I
,
Abs
,
Arg
.
Re -- Real part of a complex number
Standard math library
Calling format:
Re(x)
Parameters:
x - argument to the function
Description:
This function returns the real part of the complex number "x".
Examples:
In> Re(5)
Out> 5;
In> Re(I)
Out> 0;
In> Re(Complex(3,4))
Out> 3;
|
See also:
Complex
,
Im
.
Im -- Imaginary part of a complex number
Standard math library
Calling format:
Im(x)
Parameters:
x - argument to the function
Description:
This function returns the imaginary part of the complex number "x".
Examples:
In> Im(5)
Out> 0;
In> Im(I)
Out> 1;
In> Im(Complex(3,4))
Out> 4;
|
See also:
Complex
,
Re
.
I -- Imaginary unit
Standard math library
Calling format:
Description:
This symbol represents the imaginary unit, which equals the square
root of -1. It evaluates to Complex(0,1).
Examples:
In> I
Out> Complex(0,1);
In> I = Sqrt(-1)
Out> True;
|
See also:
Complex
.
Conjugate -- Complex conjugate
Standard math library
Calling format:
Parameters:
x - argument to the function
Description:
This function returns the complex conjugate of "x". The complex
conjugate of a+I*b is a-I*b. This function assumes that all
unbound variables are real.
Examples:
In> Conjugate(2)
Out> 2;
In> Conjugate(Complex(a,b))
Out> Complex(a,-b);
|
See also:
Complex
,
Re
,
Im
.
Arg -- Argument of a complex number
Standard math library
Calling format:
Arg(x)
Parameters:
x - argument to the function
Description:
This function returns the argument of "x". The argument is the angle
with the positive real axis in the Argand diagram, or the angle
"phi" in the polar representation r*Exp(I*phi) of "x". The
result is in the range (-Pi, Pi], that is, excluding -Pi but including Pi. The
argument of 0 is Undefined.
Examples:
In> Arg(2)
Out> 0;
In> Arg(-1)
Out> Pi;
In> Arg(1+I)
Out> Pi/4;
|
See also:
Abs
,
Sign
.
! -- Factorial
Standard math library
Calling format:
n!
Parameters:
n - argument to the function
Description:
This function calculate "n" factorial. For nonnegative integers, n!
equals n*(n-1)*(n-2)*...*1. The factorial of half-integers,
defined via the gamma function, is also evaluated.
This function is threaded, meaning that if the argument "x" is a
list, the function is applied to all the entries in the list.
Examples:
In> 5!
Out> 120;
In> 1 * 2 * 3 * 4 * 5
Out> 120;
In> (1/2)!
Out> Sqrt(Pi)/2;
|
See also:
Bin
,
Factorize
.
Bin -- Binomial coefficients
Standard math library
Calling format:
Bin(n, m)
Parameters:
n, m - integers
Description:
This function calculates the binomial coefficient "n" above
"m", which equals
n! /(n! *(n-m)!)
This is equal to the number of ways
to choose "m" objects out of a total of "n" objects if order is
not taken into account. The binomial coefficient is defined to be zero
if "m" is negative or greater than "n".
Examples:
In> Bin(10, 4)
Out> 210;
In> 10! / (4! * 6!)
Out> 210;
|
See also:
!
.
Sum -- Sum of a list of values
Standard math library
Calling format:
Sum(list)
Sum(var, from, to, body)
Parameters:
list - list of values to sum
var - variable to iterate over
from - integer value to iterate from
to - integer value to iterate up to
body - expression to evaluate for each iteration
Description:
The first form of the Sum command simply adds all
the entries in "list" and returns their sum.
If the second calling sequence is used, the expression "body" is
evaluated while the variable "var" ranges over all integers from
"from" up to "to", and the sum of all the results is
returned. Obviously, "to" should be greater than or equal to
"from".
Examples:
In> Sum({1,4,9});
Out> 14;
In> Sum(i, 1, 3, i^2);
Out> 14;
|
See also:
Average
,
Factorize
,
Apply
.
Average -- Average of a list of values
Standard math library
Calling format:
Average(list)
Parameters:
list - list of values to average
Description:
This command calculates the (arithmetical) average of all the entries in
"list", which is the sum of all entries divided by the number of
entries.
Examples:
In> Average({1,2,3,4,5});
Out> 3;
In> Average({2,6,7});
Out> 5;
|
See also:
Sum
.
Factorize -- Product of a list of values
Standard math library
Calling format:
Factorize(list)
Factorize(var, from, to, body)
Parameters:
list - list of values to multiply
var - variable to iterate over
from - integer value to iterate from
to - integer value to iterate up to
body - expression to evaluate for each iteration
Description:
The first form of the Factorize command simply
multiplies all the entries in "list" and returns their product.
If the second calling sequence is used, the expression "body" is
evaluated while the variable "var" ranges over all integers from
"from" up to "to", and the product of all the results is
returned. Obviously, "to" should be greater than or equal to
"from".
Examples:
In> Factorize({1,2,3,4});
Out> 24;
In> Factorize(i, 1, 4, i);
Out> 24;
|
See also:
Sum
,
Apply
.
Min -- Minimum of a number of values
Standard math library
Calling format:
Min(x,y)
Min(list)
Parameters:
x, y - pair of values to determine the minimum of
list - list of values from which the minimum is sought
Description:
This function returns the minimum value of its argument(s). If the
first calling sequence is used, the smaller of "x" and "y" is
returned. If one uses the second form, the smallest of the entries in
"list" is returned. In both cases, this function can only be used
with numerical values and not with symbolic arguments.
Examples:
In> Min(2,3);
Out> 2;
In> Min({5,8,4});
Out> 4;
|
See also:
Max
,
Sum
,
Average
.
Max -- Maximum of a number of values
Standard math library
Calling format:
Max(x,y)
Max(list)
Parameters:
x, y - pair of values to determine the maximum of
list - list of values from which the maximum is sought
Description:
This function returns the maximum value of its argument(s). If the
first calling sequence is used, the larger of "x" and "y" is
returned. If one uses the second form, the largest of the entries in
"list" is returned. In both cases, this function can only be used
with numerical values and not with symbolic arguments.
Examples:
In> Max(2,3);
Out> 3;
In> Max({5,8,4});
Out> 8;
|
See also:
Min
,
Sum
,
Average
.
IsZero -- Test whether argument is zero
Standard math library
Calling format:
IsZero(n)
Parameters:
n - number to test
Description:
IsZero(n) evaluates to True if
"n" is zero. In case "n" is not a number, the function returns
False.
Examples:
In> IsZero(3.25)
Out> False;
In> IsZero(0)
Out> True;
In> IsZero(x)
Out> False;
|
See also:
IsNumber
,
IsNotZero
.
IsRational -- Test whether argument is a rational
Standard math library
Calling format:
IsRational(expr)
Parameters:
expr - expression to test
Description:
This commands tests whether the expression "expr" is a rational
number. This is the case if the top-level operator of "expr" is /.
Examples:
In> IsRational(5)
Out> False;
In> IsRational(2/7)
Out> True;
In> IsRational(a/b)
Out> True;
In> IsRational(x + 1/x)
Out> False;
|
See also:
Numer
,
Denom
.
Numer -- Numerator of an expression
Standard math library
Calling format:
Numer(expr)
Parameters:
expr - expression to determine numerator of
Description:
This function determines the numerator of the rational expression
"expr" and returns it. As a special case, if its argument is numeric
but not rational, it returns this number. If "expr" is neither
rational nor numeric, the function returns unevaluated.
Examples:
In> Numer(2/7)
Out> 2;
In> Numer(a / x^2)
Out> a;
In> Numer(5)
Out> 5;
|
See also:
Denom
,
IsRational
,
IsNumber
.
Denom -- Denominator of an expression
Standard math library
Calling format:
Denom(expr)
Parameters:
expr - expression to determine denominator of
Description:
This function determines the denominator of the rational expression
"expr" and returns it. As a special case, if its argument is numeric
but not rational, it returns 1. If "expr" is
neither rational nor numeric, the function returns unevaluated.
Examples:
In> Denom(2/7)
Out> 7;
In> Denom(a / x^2)
Out> x^2;
In> Denom(5)
Out> 1;
|
See also:
Numer
,
IsRational
,
IsNumber
.
Commutator -- Commutator of two objects
Standard math library
Calling format:
Commutator(a, b)
Parameters:
a, b - two objects whose commutator should be computed
Description:
This command computes the commutator of 'a" and "b", ie. the
expression "a b - b a". For numbers and other objects for which
multiplication is commutative, the commutator is zero. But this is not
necessarily the case for matrices.
Examples:
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>
|
Taylor -- Univariate Taylor series expansion
Standard math library
Calling format:
Taylor(var, at, order) expr
Parameters:
var - variable
at - point to get Taylor series around
order - order of approximation
expr - expression to get Taylor series for
Description:
This function returns the Taylor series expansion of the expression
"expr" with respect to the variable "var" around "at" up to order
"order". This is a polynomial which agrees with "expr" at the
point "var = at", and furthermore the first "order" derivatives of
the polynomial at this point agree with "expr". Taylor expansions
around removable singularities are correctly handled by taking the
limit as "var" approaches "at".
Examples:
In> PrettyForm(Taylor(x,0,9) Sin(x))
3 5 7 9
x x x x
x - -- + --- - ---- + ------
6 120 5040 362880
Out> True;
|
See also:
D
,
InverseTaylor
,
ReversePoly
,
BigOh
.
InverseTaylor -- Taylor expansion of inverse
Standard math library
Calling format:
InverseTaylor(var, at, order) expr
Parameters:
var - variable
at - point to get inverse Taylor series around
order - order of approximation
expr - expression to get inverse Taylor series for
Description:
This function builds the Taylor series expansion of the inverse of the
expression "expr" with respect to the variable "var" around "at"
up to order "order". It uses the function ReversePoly to perform the task.
Examples:
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>
|
See also:
ReversePoly
,
Taylor
,
BigOh
.
ReversePoly -- Solve h(f(x))=g(x)+O(x^n) for h
Standard math library
Calling format:
ReversePoly(f, g, var, newvar, degree)
Parameters:
f, g - expressions in "var"
var - a variable
newvar - a new variable to express the result in
degree - the degree of the required solution
Description:
This function returns a polynomial in "newvar", say "h(newvar)",
with the property that "h(f(var))" equals "g(var)" up to order
"degree". The degree of the result will be at most "degree-1". The
only requirement is that the first derivative of "f" should not be zero.
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" (up to order "degree"), so "h" will be the
inverse of "f".
Examples:
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;
|
See also:
InverseTaylor
,
Taylor
,
BigOh
.
BigOh -- Drop all terms of a certain order in a polynomial
Standard math library
Calling format:
BigOh(poly, var, degree)
Parameters:
poly - a univariate polynomial
var - a free variable
degree - positive integer
Description:
This function drops all terms of order "degree" or higher in
"poly", which is a polynomial in the variable "var".
Examples:
In> BigOh(1+x+x^2+x^3,x,2)
Out> x+1;
|
See also:
Taylor
,
InverseTaylor
.
Newton -- Solve an equation numerically with Newton's method
Standard math library
Calling format:
Newton(expr, var, initial, accuracy)
Parameters:
expr - an expression to find a zero for
var - free variable to adjust to find a zero
initial - initial value for "var" to use in the search
accuracy - minimum required accuracy of the result
Description:
This function tries to numerically find a zero of the expression
"expr", which should depend only on the variable "var". It uses
the value "initial" as an initial guess.
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.
Examples:
In> Newton(Sin(x),x,3,0.0001)
Out> 3.1415926535;
|
See also:
Solve
.
D -- Differentiation
Standard math library
Calling format:
D(var) expr
D(list) expr
D(var,n) expr
Parameters:
var - variable
list - a list of variables
expr - expression to take derivative of
n - order of derivative
Description:
This function calculates the derivative of the expression "expr" with
respect to the variable "var" and returns it. If the third calling
sequence is used, the "n"-th derivative is determined. Yacas knows
how the differentiate standard functions like Ln
and Sin.
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.
Examples:
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)};
|
See also:
Integrate
,
Taylor
,
Diverge
,
Curl
.
Curl -- Curl of a vector field
Standard math library
Calling format:
Curl(vector, basis)
Parameters:
vector - vector field to take the curl of
basis - list of variables forming the basis
Description:
This function takes the curl of the vector field "vector" with
respect to the variables "basis". The curl is defined in the usual way,
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.
Example:
In> Curl({x*y,x*y,x*y},{x,y,z})
Out> {x,-y,y-x};
|
See also:
D
,
Diverge
.
Diverge -- Divergence of a vector field
Standard math library
Calling format:
Diverge(vector, basis)
Parameters:
vector - vector field to calculate the divergence of
basis - list of variables forming the basis
Description:
This function calculates the divergence of the vector field "vector"
with respect to the variables "basis". The divergence is defined as
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.
Example:
In> Diverge({x*y,x*y,x*y},{x,y,z})
Out> y+x;
|
See also:
D
,
Curl
.
Integrate -- Integration
Standard math library
Calling format:
Integrate(var, from, to) expr
Integrate(var) expr
Parameters:
var - variable to integrate over
from - begin of interval to integrate over
to - end of interval to integrate over
expression - expression to integrate
Description:
This function integrates the expression "expr" with respect to the
variable "var". The first calling sequence is used to perform
definite integration: the integration is carried out from "var=form"
to "var=to". The second form signifies indefinite integration. In
this case, the function UniqueConstant is called
to get a variable of the form Cn (where "n" is
an integer) which represent the integration constant.
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.
Examples:
In> Integrate(x,a,b) Cos(x)
Out> Sin(b)-Sin(a);
In> Integrate(x) Cos(x)
Out> Sin(x)+C9;
|
See also:
D
,
UniqueConstant
.
Simplify -- Try to simplify an expression
Standard math library
Calling format:
Simplify(expr)
Parameters:
expression - expression to simplify
Description:
This function tries to simplify the expression "expr" as much
as possible. It does this by grouping powers within terms, and then
grouping like terms.
Examples:
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;
|
See also:
TrigSimpCombine
,
RadSimp
.
RadSimp -- Simplify expression with nested radicals
Standard math library
Calling format:
RadSimp(expr)
Parameters:
expr - an expression containing nested radicals
Description:
This function tries to write the expression "expr" as a sum of roots
of integers: Sqrt(e1)+Sqrt(e2)+..., where e1, e2 and
so on are natural numbers. The expression "expr" may not contain
free variables.
It does this by trying all possible combinations for e1, e2, ...
Every possibility is numerically evaluated using N and compared with the numerical evaluation of
"expr". If the approximations are equal (up to 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.
Examples:
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;
|
See also:
Simplify
,
N
.
Rationalize -- Convert floating point numbers to fractions
Standard math library
Calling format:
Rationalize(expr)
Parameters:
expr - an expression containing real numbers
Description:
This command converts every real number in the expression "expr"
into a rational number. This is useful when a calculation needs to be
done on floating point numbers and the algorithm is unstable.
Converting the floating point numbers to rational numbers will force
calculations to be done with infinite precision (by using rational
numbers as representations).
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.
Examples:
In> {1.2, 3.123, 4.5}
Out> {1.2,3.123,4.5};
In> Rationalize(%)
Out> {6/5,3123/1000,9/2};
|
See also:
IsRational
.
Solve -- Solve one or more algebraic equations
Standard math library
Calling format:
Solve(eq, var)
Solve(eqlist, varlist)
Parameters:
eq - single identity equation
var - single variable
eqlist - list of identity equations
varlist - list of variables
Description:
This command tries to solve one or more equations. Use the first form
to solve a single equation and the second one for systems of
equations.
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.
Examples:
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}};
|
This means that "x = (z-a)/y" is a solution of the first equation
and that "x = -z", "y = z*a" is a solution of the systems of
equations in the second command.
An example which Solve cannot solve:
In> Solve({x^2-x == y^2-y,x^2-x == y^3+y},{x,y});
Out> {};
|
See also:
SuchThat
,
Eliminate
,
PSolve
,
==
.
SuchThat -- Find a value which makes some expression zero
Standard math library
Calling format:
Parameters:
expr - expression to make zero
var - variable (or subexpression) to solve for
Description:
This functions tries to find a value of the variable "var" which
makes the expression "expr" zero. It is also possible to pass a
subexpression as "var", in which case SuchThat
will try to solve for that subexpression.
Basically, only expressions in which "var" occurs only once are
handled; 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.
Examples:
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);
|
See also:
Solve
,
Subst
,
Simplify
.
Eliminate -- Substitute and simplify
Standard math library
Calling format:
Eliminate(var, value, expr)
|
Parameters:
var - variable (or subexpression) to substitute
value - new value of "var"
expr - expression in which the substitution should take place
Description:
This function uses Subst to replace all instances
of the variable (or subexpression) "var" in the expression "expr"
with "value", calls Simplify to simplify the
resulting expression, and returns the result.
Examples:
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;
|
See also:
SuchThat
,
Subst
,
Simplify
.
PSolve -- Solve a polynomial equation
Standard math library
Calling format:
Parameters:
poly - a polynomial in "var"
var - a variable
Description:
This commands returns a list containing the roots of "poly",
considered as a polynomial in the variable "var". If there is only
one root, it is not returned as a one-entry list but just by
itself. A double root occurs twice in the result, and similarly for
roots of higher multiplicity. All polynomials of degree up to 4 are
handled.
Examples:
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)};
|
See also:
Solve
,
Factor
.
Pi() -- Numerical approximation of Pi
Internal function
Calling format:
Description:
This commands returns the value of the mathematical constant pi at the current
precision, as set by Precision. Usually this
function should not be called directly. The constant Pi can (and should) be used to represent the exact value of pi, as it is recognized by
the simplification rules. When the function N
is invoked on an expression, Pi will be replaced with the value
returned by Pi().
Examples:
In> Pi()
Out> 3.14159265358979323846;
In> Sin(3*Pi/2)
Out> -1;
In> Sin(3*Pi()/2)
Out> Sin(4.7123889804);
In> Precision(35)
Out> True;
In> Pi()
Out> 3.14159265358979323846264338327950288;
|
See also:
N
,
Pi
,
Precision
.
Random -- Random number between 0 and 1
Standard math library
Calling format:
Description:
This function returns a random number, uniformly distributed in the
interval between 0 and 1. The same sequence of random numbers is
generated in every Yacas session.
See also:
RandomInteger
,
RandomPoly
.
VarList -- List of variables appearing in some expression
Standard math library
Calling format:
Parameters:
expr - an expression
Description:
This command returns a list of all the variables that appear in the
expression "expr".
Examples:
In> VarList(Sin(x))
Out> {x};
In> VarList(x+a*y)
Out> {x,a,y};
|
See also:
IsFreeOf
,
IsVariable
.
Limit -- Limit of an expression
Standard math library
Calling format:
Limit(var, val) expr
Limit(var, val, dir) expr
|
Parameters:
var - a variable
val - a number
dir - a direction (Left or Right)
expr - an expression
Description:
This command tries to determine the value that the expression "expr"
converges to when the variable "var" approaches "val". One may use
Infinity or -Infinity for
"val". The result of Limit may be one of the
symbols Undefined (meaning that the limit does not
exist), Infinity, or -Infinity.
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.
Examples:
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;
|
TrigSimpCombine -- Combine products of trigonometric functions
Standard math library
Calling format:
TrigSimpCombine(expr)
Parameters:
expr - expression to simplify
Description:
This function applies the product rules of trigonometry, like
Cos(u)*Sin(v)=1/2*(Sin(v-u)+Sin(v+u)). As a
result, all products of the trigonometric functions Cos and Sin disappear. The function also tries to simplify the resulting expression as much as
possible by combining all like terms.
This function is used in for instance Integrate,
to bring down the expression into a simpler form that hopefully can be
integrated easily.
Examples:
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 )
-------- + -----------------
2 4
Sin( -2 * a - b )
- -----------------
4
Out>
|
See also:
Simplify
,
Integrate
,
Expand
,
Sin
,
Cos
,
Tan
.
LagrangeInterpolant -- Polynomial interpolation
Standard math library
Calling format:
LagrangeInterpolant(xlist, ylist, var)
Parameters:
xlist - list of argument values
ylist - list of function values
var - free variable for resulting polynomial
Description:
This function returns a polynomial in the variable "var" which
interpolates the points "(xlist, ylist)". Specifically, the value of
the resulting polynomial at "xlist[1]" is "ylist[1]", the value at
"xlist[2]" is "ylist[2]", etc. The degree of the polynomial is not
greater than the length of "xlist".
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.
Examples:
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 )
----------------------------
( x1 - x2 ) * ( x1 - x3 )
y2 * ( x - x1 ) * ( x - x3 )
+ ----------------------------
( x2 - x1 ) * ( x2 - x3 )
y3 * ( x - x1 ) * ( x - x2 )
+ ----------------------------
( x3 - x1 ) * ( x3 - x2 )
Out>
|
See also:
Subst
.
Fibonacci -- Fibonacci sequence
Standard math library
Calling format:
Parameters:
n - an integer
Description:
This command calculates and returns the "n"-th Fibonacci number.
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.
Examples:
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};
|