Math plus ultra is a graphing programable calculator with a large set of functions that features:

- The manipulation of numeric and symbolic expressions.
- The development of customized functions.
- The creation of 2D and 3D graphs, including plots, contours and surfaces.
- Matrix and complex calculus.
- Integration and differentiation of numeric and symbolic functions.

# Arithmetic

## abs

*abs(x)*

Calculates the absolute value of a number, returns the magnitude of a complex number or returns the length of a vector.

## ceiling

*ceiling(x)*

Returns the smallest integer value no less than x.

## eval

*eval(f,x,a)*

Returns the function f evaluated at x=a.

## exp

*exp(x)*

Calculates the exponential of x.

## factor

*factor(n)*

Returns the factors of integer n.

## float

*float(x)*

Takes rational numbers or integers and converts them to floating point values.

## floor

*floor(x)*

Rounds a value to the nearest integer less or equal to it.

## gcd

*gcd(a,b,…)*

Returns the greatest common divisor between two or more values.

## isprime

*isprime(n)*

Determines if a value is a prime number. Returns 1 if n is a prime number or returns zero if it is not.

## lcm

*lcm(a,b,…)*

Returns the least common multiple between two or more values.

## log

*log(x)*

Calculates the natural logarithm of x.

## mod

*mod(a,b)*

Returns the remainder after dividing a by b.

## prime

*prime(n)*

Calculates the nth prime number. The domain of n is 1 to 10000.

## product

*product(i,j,k,f)*

Evaluates f for i from j to k and returns the product of all f.

## simplify

*simplify(x)*

Simplifies x.

## sqrt

*sqrt(x)*

Calculates the square root of x

## subst

*subst(a,b,c)*

Substitutes a for b in c and calculates the result.

## sum

*sum(f,i,j,k)*

Evaluates f for i equals j through k and returns the sum of all f.

# Calculus

## circexp

*circexp(x)*

Converts circular and hyperbolic functions into exponential forms.

## d

*d(f,x)*

Calculates the partial derivative of f with respect to x

## defint

*defint(f,x,a,b)*

Calculates the definite integral of f with respect to x and evaluated from a to b. The arguments can be extended for multiple integrals or iterated integrals, for example, defint(f,x,a,b,y,c,d)

## integral

*integral(f,x)*

Calculates the integral of f with respect to x.

# Complex

## arg

*arg(z)*

Calculates the argument of a complex number.

## conj

*conj(z)*

Calculates the conjugate of a complex number.

## imag

*imag(z)*

Returns the imaginary part of a complex number.

## mag

*mag(z)*

Returns the magnitude of a complex number.

## polar

*polar(z)*

Returns a complex number in polar form.

## real

*real(z)*

Returns the real part of a complex number.

## rect

*rect(z)*

Returns a complex number in rectangular form

# Fractions

## denominator

*denominator(x)*

Calculates the denominator of the expression x.

## numerator

*numerator(x)*

Calculates the numerator of the expression x.

## rationalize

*rationalize(x)*

Rationalize x.

# Logical

## and

*and(a,b,…)*

Logical operator AND.

## check

*check(x)*

If x is true then continue, otherwise stop. Use A=B to verify if A equals B.

## not

*not(x)*

Logical negation of x.

## or

*or(a,b,…)*

Logical operator OR.

# Matrix

## adj

*adj(m)*

Calculates the adjunct of matrix m. The inverse of matrix m is equal to adj(m) divided by det(m).

## cofactor

*cofactor(m,i,j)*

Returns the cofactor ij of matrix m. Let c be the cofactor matrix of m, then transpose(c )= adj(m).

## contract

*contract(a,i,j)*

It is the equivalent to the trace of matrix m.

## cross

*cross(u,v)*

Calculates the cross product between vectors u and v.

## curl

*curl(u)*

Calculates the curl of vector u.

## det

*det(m)*

Calculates the determinant of matrix m.

## dot

*dot(a,b,…)*

Calculates the dot product of vectors.

## eigen

*eigen(m)*

Compute eigenvalues and eigen vectors numerically. Argument m must be a numerical and symmetric matrix. This function stores the eigenvalue matrix in D and the eigenvector matrix in Q, so it does not return anything.

## eigenval

*eigenval(m)*

Compute eigenvalues and eigen vectors numerically. Argument m must be a numerical and symmetric matrix. This function calculates a matrix with the eigenvalues along the diagonal.

## eigenvec

*eigenvec(m)*

Compute eigenvalues and eigen vectors numerically. Argument m must be a numerical and symmetric matrix. This function calculates the eigenvectors and arranges them as row vectors.

## hilbert

*hilbert(n)*

Calculates a n by n Hilbert matrix.

## inv

*inv(m)*

Calculates the inverse of matrix m.

## transpose

*transpose(a,i,j)*

Returns the transpose of matrix a with respect to indices i and j. When indices are omitted, 1 and 2 are assumed.

## unit

*unit(n)*

Returns an identity matrix with n by n dimensions.

## zero

*zero(i,j,…)*

Creates a matrix of all zeros with dimensions i,j, etc.

# Polynomial

## coeff

*coeff(p,x,n)*

Returns the nth coefficient of the polynomial p in the variable x. The argument x can be omitted for single variable polynomials in x.

## deg

*deg(p,x)*

Calculates the degree of polynomial p(x).

## expand

*expand(r,x)*

Expands the polynomial p with respect to x.

## factor

*factor(p,x)*

Factors polynomial p with respect to x. If the polynomial is in x then x can be omitted. The polynomial must be factorable over integers. The argument list can be extended for multivariable polynomials, e.g., factor(p,x,y) so it factors p over x and then over y.

## hermite

*hermite(x,n)*

Calculate the nth Hermite polynomial in x.

## laguerre

*laguerre(x,n,a)*

Calculates the nth Laguerre polynomial in x, but if a is omitted, a=0 is assumed.

## leading

*leading(p,x)*

Returns the leading coefficient of polynomial p in variable x.

## legendre

*legendre(x,n,m)*

Calculates the nth Legendre polynomial in x. If m is omitted, m=0 is assumed.

## nroots

*nroots(p,x)*

Calculates all the roots, real and complex of polynomial p in x. These roots are computed numerically. The coefficients of the polynomial can be real or complex.

## quotient

*quotient(p,q,x)*

Calculates the quotient of two polynomials, p(x) over q(x). If the polynomials are in x, then the last argument can be omitted. The remainder can be calculated as p-q*quotient(p,q)

## roots

*roots(p,x)*

Calculates the values of x such that polynomial p(x)=0. The polynomial must be factorable over integers. For multiple roots the result is a vector. Individual roots can be obtained by component rotation, e.g., r1=roots(p,x)[1].

# Probability

## choose

*choose(n,k)*

Returns the number of possible combinations of obtaining an unordered subset of k elements from a set of n objects.

## factorial

*factorial(x)*

Returns the factorial of x. It can be entered as x!

# Program

## do

*do(a,b,…)*

Evaluates all the arguments from left to right and returns the result of the last argument.

## for

*for(i,j,k,a,b,…)*

This function works as a loop to repeat a specified number of times according to a counter. The counter is i and repeats the cycle from the integer j through the integer k, evaluating arguments a, then b, etc.

## stop

*stop()*

Stops the execution of a script.

## test

*test(a,b,c,d,…)*

In this function if the argument ‘a’ is true then ‘b’ is returned else if argument ‘c’ is true then ‘d’ is returned and so on. But if the number of arguments is odd then the last argument will be returned after all else fails. Use A=B to check if A equals B.

# Special

## besselj

*besselj(x,n)*

Bessel function of the first kind.

## bessely

*bessely(x,n)*

Bessel function of the second kind.

## erf

*erf(x)*

Returns the error function of x.

## erfc

*erfc(x)*

Returns the complementary error function of x

## filter

*filter(f,a,b,…)*

Filters f by excluding any terms containing a,b,etc.

## taylor

*taylor(f,x,n,a)*

Returns the Taylor expansion of f(x) at x=a. If a is omitted, then a=0 is assumed. The argument n is the degree of the Taylor expansion.

# Tensor

## dim

*dim(a,n)*

Calculates the cardinality of the nth index of tensor a.

## dot

*dot(a,b,…)*

Returns the dot product of tensors.

## inner

*inner(a,b,…)*

Returns the inner product of tensors, is the same as the dot product.

## outer

*outer(a,b,…)*

Returns the tensor product or outer product of tensors.

## rank

*rank(a)*

Returns the number of indices of tensor a.

## shape

*shape(x)*

Returns a vector with the shape of the input tensor. If the tensor is a row vector it will return its length, but if the input is a matrix it will return a vector with its dimensions.

# Trigonometry

## arccos

*arccos(x)*

Returns the inverse cosine or arccosine of x.

## arccosh

*arccosh(x)*

Returns the hyperbolic arccosine or inverse hyperbolic cosine of x.

## arcsin

*arcsin(x)*

Returns the inverse sine or arcsine of x.

## arcsinh

*arcsinh(x)*

Returns the hyperbolic arcsine or inverse hyperbolic sine of x.

## arctan

*arctan(x)*

Returns the arctangent or inverse tangent of x.

## arctanh

*arctanh(x)*

Returns the hyperbolic arctangent or inverse hyperbolic tangent of x.

## cos

*cos(x)*

Calculates the cosine of x.

## cosh

*cosh(x)*

Calculates the hyperbolic cosine of x.

## expcos

*expcos(x)*

Calculates the exponential cosine of x.

## expsin

*expsin(x)*

Calculates the exponential sine of x.

## sin

*sin(x)*

Calculates the sine of x.

## sinh

*sinh(x)*

Calculates the hyperbolic sine of x.

## tan

*tan(x)*

Calculates the tangent of x.

## tanh

*tanh(x)*

Calculates the hyperbolic tangent of x.

## sec

*sec(x)*

Returns the secant of x, which is defined as sec(x) = 1/cos(x).

## cot

*cot(x)*

Returns the cotangent of x. It is defined as cot(x)=1/tan(x).

## csc

*csc(x)*

Returns the cosecant of x, which is defined as csc(x) = 1/sin(x).

## sech

*sech(x)*

Returns the hyperbolic secant of x, which is defined as sech(x) = 1 / cosh(x).

## coth

*coth(x)*

Returns the hyperbolic cotangent of x, which is defined as coth(x) = 1 / tanh(x).

## csch

*csch(x)*

Returns the hyperbolic cosecant of x, which is defined as csch(x) = 1 / sinh(x).

## acot

*acot(x)*

Returns the inverse cotangent or arctangent of x, which is defined as acot(x) = atan(1/x).

## acoth

*acoth(x)*

Returns the hyperbolic arc cotangent of x, which is defined as acoth(x) = atanh(1/x).

## asec

*asec(x)*

Returns the inverse secant or arc secant of x.

## asech

*asech(x)*

Returns the hyperbolic arc secant of x, which is defined as asech(x) = acosh(1/x).

## acsc

*acsc(x)*

Returns the inverse cosecant or arc cosecant of x, which is defined as acsc(x) = asin(1/x).

## acsch

*acsch(x)*

Returns the hyperbolic arc cosecant of x, which is defined as acsch(x) = asinh(1/x).

# Variable

## quote

*quote(x)*

Returns the expression without evaluating it first.