Sin, Cos, Tan , ArcSin, ArcCos, ArcTan , Exp , Ln , Sqrt , Abs , Sign , Complex , Re , Im , I , Conjugate , Arg , RootsOfUnity , !, !!, ***, Subfactorial , Bin , Eulerian , Add , Sum , Average , Factorize , Min , Max , IsZero , IsRational , Numer , Denom , Commutator , Taylor , InverseTaylor , ReversePoly , BigOh , Newton , D , Curl , Diverge , Integrate , Simplify , RadSimp , FactorialSimplify , LnExpand , LnCombine , Rationalize , Solve , OldSolve , SuchThat , Eliminate , PSolve , Pi , Random, RandomSeed , RngCreate, RngSeed, Rng , Limit , TrigSimpCombine , LagrangeInterpolant , Fibonacci .

# Calculus and elementary functions

In this chapter, some facilities 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
RootsOfUnity | find the n complex roots of unity
!, !!, ***, Subfactorial | factorial and related functions
Bin | binomial coefficients
Eulerian | Eulerian numbers
Add | find sum of a list of values
Sum | find sum of a sequence
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
FactorialSimplify | Simplify hypergeometric expressions containing factorials
LnExpand | expand a logarithmic expression using standard logarithm rules
LnCombine | combine logarithmic expressions using standard logarithm rules
Rationalize | convert floating point numbers to fractions
Solve | solve an equation
OldSolve | old version of `Solve`
SuchThat | special purpose solver
Eliminate | substitute and simplify
PSolve | solve a polynomial equation
Pi | numerical approximation of Pi
Random, RandomSeed | (pseudo-) random number generator
RngCreate, RngSeed, Rng | manipulate random number generators as objects
Limit | limit of an expression
TrigSimpCombine | combine products of trigonometric functions
LagrangeInterpolant | polynomial interpolation
Fibonacci | Fibonacci sequence

###

Sin, Cos, Tan -- trigonometric functions

##### Standard library

##### Calling format:

    Sin(x)
    Cos(x)
    Tan(x)

##### 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 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 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 using the `Ln` function.

These functions are threaded, meaning that if the argument `x` is a list, the function is applied to all 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> x:=N(ArcSin(0.75))
    Out> 0.848062;
    In> N(Sin(x))
    Out> 0.7499999477;

##### See also:

Sin , Cos , Tan , N , Pi , Ln .

###

Exp -- exponential function

##### Standard library

##### Calling format:

    Exp(x)

##### 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 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 library

##### Calling format:

    Ln(x)

##### 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`, i.e. 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 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 library

##### Calling format:

    Sqrt(x)

##### 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 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 library

##### Calling format:

    Abs(x)

##### 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 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 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 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 library

##### Calling format:

    Complex(r, c)

##### 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 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 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 library

##### Calling format:

    I

##### 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 library

##### Calling format:

    Conjugate(x)

##### 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 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 .

###

RootsOfUnity -- find the n complex roots of unity

##### Standard library

##### Calling format:

    RootsOfUnity(n)

##### Parameters:

`n` -- positive integer

##### Description:

This function returns the list of n roots of unity. The first element of this list is the primitive n-th root of unity, and the last element is simply `1`.

##### Examples:

    In> RootsOfUnity(3)
    Out> {Complex(-1/2,Sqrt(3/4)),Complex(-1/2,-Sqrt(3/4)),1};
    In> RootsOfUnity(1)
    Out> {1};
    In> RootsOfUnity(2)
    Out> {-1,1};

##### See also:

I , Complex .

###

!, !!, ***, Subfactorial -- factorial and related functions

##### Standard library

##### Calling format:

    n!
    n!!
    a *** b
    Subfactorial(m)

##### Parameters:

`m` -- integer `n` -- integer, half-integer, or list `a`, `b` -- numbers

##### Description:

The factorial function `n!` calculates the factorial of integer or half-integer numbers. For nonnegative integers, n! :=n*(n-1)*(n-2)*...*1. The factorial of half-integers is defined via Euler's Gamma function, z! :=Gamma(z+1). If n=0 the function returns 1.

The "double factorial" function `n!!` calculates n*(n-2)*(n-4)*.... This product terminates either with 1 or with 2 depending on whether n is odd or even. If n=0 the function returns 1.

The "partial factorial" function `a *** b` calculates the product a*(a+1)*... which is terminated at the least integer not greater than b. The arguments a and b do not have to be integers; for integer arguments, `a *** b` = b! /(a-1)!. This function is sometimes a lot faster than evaluating the two factorials, especially if a and b are close together. If a>b the function returns 1.

The `Subfactorial` function can be interpreted as the number of permutations of `m` objects in which no object appears in its natural place, also called "derangements."

The factorial functions are threaded, meaning that if the argument `n` is a list, the function will be applied to each element of the list.

Note: For reasons of Yacas syntax, the factorial sign `!` cannot precede other non-letter symbols such as `+` or `*`. Therefore, you should enter a space after `!` in expressions such as `x! +1`.

The factorial functions terminate and print an error message if the arguments are too large (currently the limit is n<65535) because exact factorials of such large numbers are computationally expensive and most probably not useful. One can call `LnGammaNum()` to evaluate logarithms of such factorials to desired precision.

##### Examples:

    In> 5!
    Out> 120;
    In> 1 * 2 * 3 * 4 * 5
    Out> 120;
    In> (1/2)!
    Out> Sqrt(Pi)/2;
    In> 7!!;
    Out> 105;
    In> 1/3 *** 10;
    Out> 17041024000/59049;
    In> Subfactorial(10)
    Out> 1334961;

##### See also:

Bin , Factorize , Gamma , !! , *** , Subfactorial .

###

Bin -- binomial coefficients

##### Standard library

##### Calling format:

    Bin(n, m)

##### Parameters:

`n`, `m` -- integers

##### Description:

This function calculates the binomial coefficient "n" above "m", which equals

n! /(m! *(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"; `Bin(0,0)`=1.

##### Examples:

    In> Bin(10, 4)
    Out> 210;
    In> 10! / (4! * 6!)
    Out> 210;

##### See also:

! , Eulerian .

###

Eulerian -- Eulerian numbers

##### Standard library

##### Calling format:

    Eulerian(n,m)

##### Parameters:

`n`, `m` --- integers

##### Description:

The Eulerian numbers can be viewed as a generalization of the binomial coefficients, and are given explicitly by

Sum(j,0,k+1,(-1)^j*Bin(n+1,j)*(k-j+1)^n)
.

##### Examples:

    In> Eulerian(6,2)
    Out> 302;
    In> Eulerian(10,9)
    Out> 1;

##### See also:

Bin .

###

Add -- find sum of a list of values

##### Standard library

##### Calling format:

    Add(val1, val2, ...)
    Add({list})

##### Parameters:

`val1`, `val2` -- expressions

`{list}` -- list of expressions to add

##### Description:

This function adds all its arguments and returns their sum. It accepts any number of arguments. The arguments can be also passed as a list.

##### Examples:

    In> Add(1,4,9);
    Out> 14;
    In> Add(1 .. 10);
    Out> 55;

##### See also:

Average .

###

Sum -- find sum of a sequence

##### Standard library

##### Calling format:

    Sum(var, from, to, body)

##### Parameters:

`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 command finds the sum of the sequence generated by an iterative formula. 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".

Warning: `Sum` does not evaluate its arguments `var` and `body` until the actual loop is run.

##### Examples:

    In> Sum(i, 1, 3, i^2);
    Out> 14;

##### See also:

Factorize .

###

Average -- average of a list of values

##### Standard 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:

Add .

###

Factorize -- product of a list of values

##### Standard 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 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 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 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 library

##### Calling format:

    IsRational(expr)

##### Parameters:

`expr` -- expression to test

##### Description:

This commands tests whether the expression "expr" is a rational number, i.e. an integer or a fraction of integers.

##### Examples:

    In> IsRational(5)
    Out> False;
    In> IsRational(2/7)
    Out> True;
    In> IsRational(0.5)
    Out> False;
    In> IsRational(a/b)
    Out> False;
    In> IsRational(x + 1/x)
    Out> False;

##### See also:

Numer , Denom .

###

Numer -- numerator of an expression

##### Standard 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 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 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", i.e. 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

    In> A := { {0,x}, {0,0} }

    /              \
    | ( 0 ) ( x )  |
    |              |
    | ( 0 ) ( 0 )  |
    \              /

    In> B := { {y,0}, {0,z} }

    /              \
    | ( y ) ( 0 )  |
    |              |
    | ( 0 ) ( z )  |
    \              /

    In> Commutator(A,B)

    /                          \
    | ( 0 ) ( x * z - y * x )  |
    |                          |
    | ( 0 ) ( 0 )              |
    \                          /

###

Taylor -- univariate Taylor series expansion

##### Standard 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 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

    In> exp1 := Taylor(x,0,7) Sin(x)

         3    5      7
        x    x      x
    x - -- + --- - ----
        6    120   5040

    In> exp2 := InverseTaylor(x,0,7) ArcSin(x)

     5      7     3
    x      x     x
    --- - ---- - -- + x
    120   5040   6

    In> Simplify(exp1-exp2)

    0

##### See also:

ReversePoly , Taylor , BigOh .

###

ReversePoly -- solve h(f(x))=g(x)+O(x^n) for h

##### Standard library

##### Calling format:

    ReversePoly(f, g, var, newvar, degree)

##### Parameters:

`f`, `g` -- functions of "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 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 library

##### Calling format:

    Newton(expr, var, initial, accuracy)
    Newton(expr, var, initial, accuracy,min,max)

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

`min` -- minimum value for "var" to use in the search

`max` -- maximum value for "var" to use in the search

##### 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.

When `min` and `max` are supplied, the Newton iteration takes them into account by returning `Fail` if it failed to find a root in the given range. Note this doesn't mean there isn't a root, just that this algorithm failed to find it due to the trial values going outside of the bounds.

##### Examples:

    In> Newton(Sin(x),x,3,0.0001)
    Out> 3.1415926535;
    In> Newton(x^2-1,x,2,0.0001,-5,5)
    Out> 1;
    In> Newton(x^2+1,x,2,0.0001,-5,5)
    Out> Fail;

##### See also:

Solve , NewtonNum .

###

D -- differentiation

##### Standard 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 derivatives 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 format is used, the `n`-th derivative is determined. Yacas knows how the differentiate standard functions such as `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.

The `D` operator returns the original function if n=0, a common mathematical idiom that simplifies many formulae.

##### 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 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 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 library

##### Calling format:

    Integrate(var, x1, x2) expr
    Integrate(var) expr

##### Parameters:

`var` -- atom, variable to integrate over

`x1` -- first point of definite integration

`x2` -- second point of definite integration

`expr` -- expression to integrate

##### Description:

This function integrates the expression `expr` with respect to the variable `var`. The first calling format is used to perform definite integration: the integration is carried out from var=x1 to var=x2". The second form is for indefinite integration.

Some simple integration rules have currently been implemented. Polynomials, some quotients of polynomials, trigonometric functions and their inverses, hyperbolic functions and their inverses, `Exp`, and `Ln`, and products of these functions with polynomials can be integrated.

##### Examples:

    In> Integrate(x,a,b) Cos(x)
    Out> Sin(b)-Sin(a);
    In> Integrate(x) Cos(x)
    Out> Sin(x);

##### See also:

D , UniqueConstant .

###

Simplify -- try to simplify an expression

##### Standard library

##### Calling format:

    Simplify(expr)

##### Parameters:

`expr` -- 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 similar 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 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 .

###

FactorialSimplify -- Simplify hypergeometric expressions containing factorials

##### Standard library

##### Calling format:

    FactorialSimplify(expression)

##### Parameters:

`expression` -- expression to simplify

##### Description:

`FactorialSimplify` takes an expression that may contain factorials, and tries to simplify it. An expression like (n+1)! /n! would simplify to n+1.

The following steps are taken to simplify:

- binomials are expanded into factorials
- the expression is flattened as much as possible, to reduce it to a sum of simple rational terms
- expressions like p^n/p^m are reduced to p^(n-m) if n-m is an integer
- expressions like n! /m! are simplified if n-m is an integer

The function `Simplify` is used to determine if the relevant expressions n-m are integers.

##### Example:

    In> FactorialSimplify( (n-k+1)! / (n-k)! )
    Out> n+1-k
    In> FactorialSimplify(n! / Bin(n,k))
    Out> k! *(n-k)!
    In> FactorialSimplify(2^(n+1)/2^n)
    Out> 2

##### See also:

Simplify , ! , Bin .

###

LnExpand -- expand a logarithmic expression using standard logarithm rules

##### Standard library

##### Calling format:

    LnExpand(expr)

##### Parameters:

`expr` -- the logarithm of an expression

##### Description:

`LnExpand` takes an expression of the form Ln(expr), and applies logarithm rules to expand this into multiple `Ln` expressions where possible. An expression like Ln(a*b^n) would be expanded to Ln(a)+n*Ln(b).

If the logarithm of an integer is discovered, it is factorised using `Factors` and expanded as though `LnExpand` had been given the factorised form. So Ln(18) goes to Ln(x)+2*Ln(3).

##### Example:

    In> LnExpand(Ln(a*b^n))
    Out> Ln(a)+Ln(b)*n
    In> LnExpand(Ln(a^m/b^n))
    Out> Ln(a)*m-Ln(b)*n
    In> LnExpand(Ln(60))
    Out> 2*Ln(2)+Ln(3)+Ln(5)
    In> LnExpand(Ln(60/25))
    Out> 2*Ln(2)+Ln(3)-Ln(5)

##### See also:

Ln , LnCombine , Factors .

###

LnCombine -- combine logarithmic expressions using standard logarithm rules

##### Standard library

##### Calling format:

    LnCombine(expr)

##### Parameters:

`expr` -- an expression possibly containing multiple `Ln` terms to be combined

##### Description:

`LnCombine` finds `Ln` terms in the expression it is given, and combines them using logarithm rules. It is intended to be the exact converse of `LnExpand`.

##### Example:

    In> LnCombine(Ln(a)+Ln(b)*n)
    Out> Ln(a*b^n)
    In> LnCombine(2*Ln(2)+Ln(3)-Ln(5))
    Out> Ln(12/5)

##### See also:

Ln , LnExpand .

###

Rationalize -- convert floating point numbers to fractions

##### Standard 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> x:={1.2, 3.123, 4.5}
    Out> {1.2,3.123,4.5};
    In> Rationalize(x)
    Out> {6/5,3123/1000,9/2};

##### See also:

IsRational .

###

Solve -- solve an equation

##### Standard library

##### Calling format:

    Solve(eq, var)

##### Parameters:

`eq` -- equation to solve

`var` -- variable to solve for

##### Description:

This command tries to solve an equation. If `eq` does not contain the `==` operator, it is assumed that the user wants to solve $eq == 0$. The result is a list of equations of the form `var == value`, each representing a solution of the given equation. The `Where` operator can be used to substitute this solution in another expression. If the given equation `eq` does not have any solutions, or if `Solve` is unable to find any, then an empty list is returned.

The current implementation is far from perfect. In particular, the user should keep the following points in mind:

- `Solve` cannot solve all equations. If it is given a equation it can not solve, it raises an error via `Check`. Unfortunately, this is not displayed by the inline pretty-printer; call `PrettyPrinter` to change this. If an equation cannot be solved analytically, you may want to call `Newton` to get a numerical solution.
- Systems of equations are not handled yet. For linear systems, `MatrixSolve` can be used. The old version of `Solve`, with the name `OldSolve` might be able to solve nonlinear systems of equations.
- The periodicity of the trigonometric functions `Sin`, `Cos`, and `Tan` is not taken into account. The same goes for the (imaginary) periodicity of `Exp`. This causes `Solve` to miss solutions.
- It is assumed that all denominators are nonzero. Hence, a solution reported by `Solve` may in fact fail to be a solution because a denominator vanishes.
- In general, it is wise not to have blind trust in the results returned by `Solve`. A good strategy is to substitute the solutions back in the equation.

##### Examples:

First a simple example, where everything works as it should. The quadratic equation x^2+x==0 is solved. Then the result is checked by substituting it back in the quadratic.

    In> quadratic := x^2+x;
    Out> x^2+x;
    In> Solve(quadratic, x);
    Out> {x==0,x==(-1)};
    In> quadratic Where %;
    Out> {0,0};

If one tries to solve the equation Exp(x)==Sin(x), one finds that `Solve` can not do this.

    In> PrettyPrinter("DefaultPrint");
    Out> True;
    In> Solve(Exp(x) == Sin(x), x);
    Error: Solve'Fails: cannot solve equation Exp(x)-Sin(x) for x
    Out> {};

The equation Cos(x)==1/2 has an infinite number of solutions, namely x==(2*k+1/3)*Pi and x==(2*k-1/3)*Pi for any integer k. However, `Solve` only reports the solutions with k==0.

    In> Solve(Cos(x) == 1/2, x);
    Out> {x==Pi/3,x== -Pi/3};

For the equation x/Sin(x)==0, a spurious solution at x==0 is returned. However, the fraction is undefined at that point.

    In> Solve(x / Sin(x) == 0, x);
    Out> {x==0};

At first sight, the equation Sqrt(x)==a seems to have the solution x==a^2. However, this is not true for eg. a== -1.

    In> PrettyPrinter("DefaultPrint");
    Out> True;
    In> Solve(Sqrt(x) == a, x);
    Error: Solve'Fails: cannot solve equation Sqrt(x)-a for  x
    Out> {};
    In> Solve(Sqrt(x) == 2, x);
    Out> {x==4};
    In> Solve(Sqrt(x) == -1, x);
    Out> {};

##### See also:

Check , MatrixSolve , Newton , OldSolve , PrettyPrinter , PSolve , Where , == .

###

OldSolve -- old version of `Solve`

##### Standard library

##### Calling format:

    OldSolve(eq, var)
    OldSolve(eqlist, varlist)

##### Parameters:

`eq` -- single identity equation

`var` -- single variable

`eqlist` -- list of identity equations

`varlist` -- list of variables

##### Description:

This is an older version of `Solve`. It is retained for two reasons. The first one is philosophical: it is good to have multiple algorithms available. The second reason is more practical: the newer version cannot handle systems of equations, but `OldSolve` can.

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> OldSolve(a+x*y==z,x)
    Out> (z-a)/y;
    In> OldSolve({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 `OldSolve` cannot solve:

    In> OldSolve({x^2-x == y^2-y,x^2-x == y^3+y},{x,y});
    Out> {};

##### See also:

Solve , SuchThat , Eliminate , PSolve , == .

###

SuchThat -- special purpose solver

##### Standard library

##### Calling format:

    SuchThat(expr, var)

##### 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> A:=Expand(a*x+b*x+c, x)
    Out> (a+b)*x+c;
    In> SuchThat(A, x)
    Out> (-c)/(a+b);

##### See also:

Solve , OldSolve , Subst , Simplify .

###

Eliminate -- substitute and simplify

##### Standard 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 library

##### Calling format:

    PSolve(poly, var)

##### 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:

    Pi()

##### 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, RandomSeed -- (pseudo-) random number generator

##### Standard library

##### Calling format:

    Random()
    RandomSeed(init)

*PARAMS `init` -- positive integer, initial random seed

##### Description:

The function `Random` 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.

The random number generator can be initialized by calling `RandomSeed` with an integer value. Each seed value will result in the same sequence of pseudo-random numbers.

##### See also:

RandomInteger , RandomPoly , Rng .

###

RngCreate, RngSeed, Rng -- manipulate random number generators as objects

##### Standard library

##### Calling format:

    RngCreate()
    RngCreate(init)
    RngCreate(option=value,...)
    RngSeed(r, init)
    Rng(r)

##### Parameters:

`init` -- integer, initial seed value

`option` -- atom, option name

`value` -- atom, option value

`r` -- a list, RNG object

##### Description:

These commands are an object-oriented interface to (pseudo-)random number generators (RNGs).

`RngCreate` returns a list which is a well-formed RNG object. Its value should be saved in a variable and used to call `Rng` and `RngSeed`.

`Rng(r)` returns a floating-point random number between 0 and 1 and updates the RNG object `r`. (Currently, the Gaussian option makes a RNG return a complex random number instead of a real random number.)

`RngSeed(r,init)` re-initializes the RNG object `r` with the seed value `init`. The seed value should be a positive integer.

The `RngCreate` function accepts several options as arguments. Currently the following options are available:

- `seed` -- specify initial seed value, must be a positive integer
- `dist` -- specify the distribution of the random number; currently `flat` and `gauss` are implemented, and the default is the flat (uniform) distribution
- `engine` -- specify the RNG engine; currently `default` and `advanced` are available ("advanced" is slower but has much longer period)

If the initial seed is not specified, the value of 76544321 will be used.

The `gauss` option will create a RNG object that generates pairs of Gaussian distributed random numbers as a complex random number. The real and the imaginary parts of this number are independent random numbers taken from a Gaussian (i.e. "normal") distribution with unit variance.

Note that unlike the global `Random` function, the RNG objects created with `RngCreate` are independent RNGs and do not affect each other. They generate independent streams of pseudo-random numbers. However, the `Random` function is slightly faster.

##### Examples:

    In> r1:=RngCreate(seed=1,dist=gauss)
    Out> {"GaussianRNGDist","RNGEngine'LCG'2",{1}}
    In> Rng(r1)
    Out> Complex(-1.6668466417,0.228904004);
    In> Rng(r1);
    Out> Complex(0.0279296109,-0.5382405341);

The second RNG gives a uniform distribution (default option) but uses a more complicated algorithm:

    In> [r2:=RngCreate(engine=advanced);Rng(r2);]
    Out> 0.3653615377;

The generator `r1` can be re-initialized with seed 1 again to obtain the same sequence:

    In> RngSeed(r1, 1)
    Out> True;
    In> Rng(r1)
    Out> Complex(-1.6668466417,0.228904004);

##### See also:

Random .

###

Limit -- limit of an expression

##### Standard 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 library

##### Calling format:

    TrigSimpCombine(expr)

##### Parameters:

`expr` -- expression to simplify

##### Description:

This function applies the product rules of trigonometry, e.g. 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 similar 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

    In> TrigSimpCombine(Cos(a)^2+Sin(a)^2)

    1

    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

##### See also:

Simplify , Integrate , Expand , Sin , Cos , Tan .

###

LagrangeInterpolant -- polynomial interpolation

##### Standard 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

    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 )

##### See also:

Subst .

###

Fibonacci -- Fibonacci sequence

##### Standard library

##### Calling format:

    Fibonacci(n)

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