Calculus

Sin(x)

Sin(x) : Calculate sinus of x.

Cos(x)

Cos(x) : Calculate cosinus of x.

Tan(x)

Tan(x) : Calculate tangent of x.

ArcSin(x)

ArcSin(x) : Calculate arc-sinus of x.

ArcCos(x)

ArcCos(x) : Calculate arc-cosinus of x.

ArcTan(x)

ArcTan(x) : Calculate acr-tangent of x.

Exp(x)

Exp(x) : Calculate e^x.

Ln(x)

Ln(x) : Calculate natural logarithm of x.

Sqrt(x)

Sqrt(x) : calculate the square root of x.

Complex(x,y)

This represents a complex number x+I*y.

Re(z)

Return real part of complex number z.

Im(z)

Return imaginary part of complex number z.

I

This is the pure imaginary number I (for which i*I=-1). You can type 2+I*3, which would evaluate to Complex(2,3). Re and Im return the real and imaginary parts of a number respectively.

n!

Factorial. n! evaluates to n*(n-1)*(n-2)*....*1.

Bin(n,m)

Bin(n,m) evaluates to n!/(n!*(n-m)!)

Sum(var,from,to,body)

Sum(var,from,to,body) : Sum does a summation over "body", setting variable "var" from "from" upto and including "to", incrementing it by 1 each time.

Sum({list})

Sum({list}) : calculate the sum of the elements in a list. Example : Sum({1,2,3}) evaluates to 6.

Average({list})

Average({list}) : calculate the average of the elements in a list. Example : Average({1,2,3}) evaluates to 2.

Factorize(var,from,to,body)

Factorize(var,from,to,body) : Factorize does a factorization over "body", setting variable "var" from "from" upto and including "to", incrementing it by 1 each time.

IsZero(x)

IsZero(x) : Returns wether x is zero or not.

IsRational(r)

IsRational(r) : Rational numbers are anything like a/b, or 2/5.

Numer(r)

Numer(r) : Return numerator of a rational number.

Denom(r)

Denom(r) : Return denominator of a rational number.

N(r)

N(r) : Rational numbers and other analytic functions (Sin, Cos, etc.) are not evaluated into floating point numbers, as it is usually the exact answer the user is after. By using N these functions will be evaluated into floating point numbers.

Commutator(a,b)

Commutator(a,b) : Return "a b - b a". For numbers and such this is zero, for matrices in general it isn't.

Taylor(var,var0,order)function

Taylor(var,var0,order)function : Return the Taylor series expansion of function "function", with respect to variable "var", around "var=var0", upto order "order".

InverseTaylor(var,degree) func

InverseTaylor(var,degree) func : build a taylor series expansion of the inverse of function func, with respect to variable var, upto degree.

Newton(function,variable,initial,accuracy)

Newton(function,variable,initial,accuracy) : Find a zero of "function", as a function of "variable", starting around value "initial", and continuing until the value for "variable" is maximally "accuracy" away from the correct value.

D(variable) expression

D(variable) expression : Calculate analytic derivative of an expression. "D(x) Sin(x);" "Cos(x);". The D operator is also threaded: "D({x,y,z}) Sin(x*y)" will return {Cos(x*y)*y,Cos(x*y)*x,0}

Diverge(vector, basis)

Diverge(vector, basis) : Calculate the divergence of a vector. Example: "Diverge(FillList(x*y,3),{x,y,z})" will return {y,x,0}

Curl(vector, basis)

Curl(vector, basis) : Calculate the curl of a vector. Example: "Curl(FillList(x*y,3),{x,y,z})" will return {x,-y,y-x}

Integrate(var,from,to) body

Integrate(var,from,to) body : integrate body over variable var=from to var=to. Currently, only polynomials can be integrated.

Simplify(expr)

Simplify(expr) : Simplify tries to simplify an expression as much as possible.

Rationalize(expr)

Rationalize(expr) : convert every real number in expr into a rational number.

Conjugate(expr)

Conjugate(expr) : return the conjugate of expr (given that all variables are real or integer).

Solve(expr1=expr2,variable)

Solve(expr1=expr2,variable) : A very simple solver. It can for now solve expressions where the variable to be solved for only occurs once. "Solve(a+x*y=z,x);" would evaluate to "(z-a)/y".

PSolve(expr,var)

PSolve(expr) : solve expr=0 with respect to variable var, treating it expr as a polynomial. It currently solves upto degree 2.

Pi()

Pi() : Returns pi to the current precision.

Fibonacci(n)

Fibonacci(n) : Calculate Fibonacci number "n".

Random()

Random() : Returns a random number between 0 and 1.

VarList(expression)

VarList(expression) : Returns a list with all the variables "expression" depends on. Example: "VarList(Sin(x));" should return "{x};".

Limit(variable,value) function

Limit(variable,value)function : determine the value "function" converges to when "variable" goes to "value" from positive infinity. Examples : "Limit(x,0) Sin(x)/x;" evaluates to "1", and "Limit(x,0) (Sin(x)-Tan(x))/(x^3);" evaluates to "-1/2".

TrigSimpCombine(expression)

TrigSimpCombine(expression) : This is the module that does the trigonometric simplification: Cos(...)*Sin(...) -> Cos(...)+Sin(...)

It also tries to simplify the resulting expression as much as possible, trying to combine all like terms.