eigenmath summary
 
 
integer
real
complex
string
boolean
vector
array
predefined
 






greek letters
subindices mu and nu
string
vector[1] = 1    vector[2] = 5   vector[3] = 6
 
matrix[1,1] = 1  matrix[2,1] = 5  matrix[2,3] = 9
matrix[3,3] = 1 ...
 
f(3, 6) = 21
 


arithmetic operators
exponentiation
relational operators
logical operators  
 


block (=sequence) of expressions :
if block reduce to single expression, do(...) is not
necessary
return the last expression in the block : x + y
 

if predicate is True (=1), block1, else block2.
 
if predicate1 is True, block1 else
if predicate2 is True, block2 ...
 
test range
 







stop the program if predicate is False (=0).
 
1 if number else 0
1 if integer else 0
 
 loop control  
 






build-in loops
 


approximate pi
 
 
                                                                     
 
 
 return expressionk
                                                                                                                                                                                             
 


abs(x)=|x|
                                                                                                                                                         
pow(x,n)=x^n
 

fib(1)=1 fib(2)=2 fib(n)=fib(n-1)+fib(n-2)
 
                                                                                                                                                       
fac(1)=1   fac(n)=n*fac(n-1)                                                                    
 
                                                                                                                                                                                                           
test odd/even(n)
 
                                                                                                                                                       
cross recursivity
 














































































 
 
 
error message if False
 

 
 
predicates return 0/1
edata types
 
a = 45
b = 0.666
c = 3 + i * 5.3  
d = "bonjour"  
True = 1, False = 0  
v = (2, 6, 1)  
A = zero (5, 5)  
pi, e, i    
 
naming variables, expressions and functions
 
x = 124/3 + 17
y = sin (3.33) + sqrt (5) - exp ( pi/4 )
z = alpha+beta  
w = u^2 + v^2 + u/2 + v/2
epsilon = 10^(-20)
Amunu = y^2 + sqrt (x)  
msg = "this is a string"
vector = (1, 5, 6)
 
matrix = ((1, 4, 2),(5, 3, 9),(3, 8, 1))
 

f(x, y) = x + 3*y  
 
operators
 
+   -   *   /  
x ^ (y)    
<   <=    ==   >   >=
not    and    or  
 
control constructs              
                                                 
do(expression1, expression2,...,expressionk)
 

do (x = sqrt(6), y = exp(x/2),  x + y)    
 

test (predicate,block1,block2)
test (predicate1,block1,predicate2,block2, ...)
 

test (a>b, "a greater than b", "a not greater than b")
range (u,a,b) = test(and(u>=a,u<=b),0,and(u>b,u<a),1)
 
test (a>b,
               print (a),
       b>5,
              print (b),
              print (a + b) ))
 
check (predicate)
check (a>b)
 
number (x)
isinteger (x)
 
for (i, min, max, do (...))
for (i, 1, 100,  print (i^2) )
 
A=zero(10,5)
for (i, 1, 10,
  for (j, 1, 5,
      A[i,j] = i + 2j ))
 
product (i, imin ,imax, f)    
sum (i, imin, imax ,f)
S=sum (k, 1, 99, 1 + 1/k)
 
a(n) = test (n==0, 0, sqrt(2 + a(n-1)))
Pi = float (2*product(k, 1, 9, 2/a(k)))
 
defining functions
                                                                     
f (arg1, arg2, ..., argn) = expression
 
f (arg1, arg2, ..., argn) =
do (expression1, expression2,..., expressionk)    
                                                                                                                                                                                             
f (x, y) = sin (x)^2  + cos (y)^2
 
g (x, y) = do ( check (x > 2), check (y > 0), x^3 + 3/y)
                                                                                                                                                         
abs (x) = test (x < 0, -x, x)    
                                                                                                                                                         
pow (x, n) = do ( check (n > 0), p=1, for (i, 1, n, p = p * x), p)  
                                                                                                                                                         fib (n)=                                                                                                                                                                                    
do ( check (n > 0), test (n==1, 1, test (n==2, 2, fib (n-1) + fib (n-2) )))    
                                                                                                                                                                                     
fac (n) = do ( check (n > 0),
test (n == 1, 1, n * fac (n-1) ))        
                       
even (n) = test (n==0, 1, odd (n-1))  
odd (n) = test (n==0, 0, even (n-1))
                                                                                                                                                       
x(n) = test (n==0, 1, x(n-1) + y(n-1))    
y(n) = test (n==0, 2, y(n-1) * x(n-1))
 
build in functions :
usual
sin (x), cos (x), tan (x), asin (x), acos (x), atan (x),
sinh (x), cosh (x), tanh (x), asinh (x), acosh(x), atanh(x)
circexp (x), expcos (x), expsin (x)
exp (x), sqrt (x), log (x)
 
logical
and (a,b,c,...), or (a,b,c,...), not (a)
 
arithmetic
mod (a,b)
ceiling (x), floor (x),
gcd (a,b,...), lcm (a,b,...), choose (n,k),
factor (n), isprime (n), prime (n)
factorial (n), n!,
divisors (x)
 
complex number
mag(z), arg(z), conj(z)
imag(z), real(z)
polar(z), rect(z), clock(z)
 
polynomials
coeff(p,x,n), deg(p,x), leading(p,x),
expand(r,x),  factor(p,x,y,...), quotient(p,q,x), rationalize(x)
roots(p,x), nroots(p,x)
hermite(x,n), laguerre(x,n,a), legendre(x,n,m)
 
vector, matrix, tensor
rank(a), dim(a,n)
unit(n), zero(i,j,...)
det(m), inv(m), transpose(m), cofactor(m,i,j),
contract(a,i,j), transpose(a,i,j), dot(a,b,...), inner(a,b,...), outer(a,b,...)
abs(u), cross(u,v), dot(u,v), inner(u,v), outer(u,v)
hilbert(n)
 
calculus
d(f,x) :      
d(f,x,x), d(f,x,n),
d(f,x,y), d(f,x,m,y,n,...)
d(r,(x,y))    
div(u)    
curl(u)  
 
integral(f,x), integral(f,x,y,...)  
defint(f,x,a,b,...)
 
Taylor series
taylor(f,x,n,a)
 
misclaneous
 
print(a,b,...)
simplify(x), condense(x), numerator(x), denominator(x), rationalize(x)
draw(f,x), xrange, yrange
sgn(x)
erf(x), erfc(x)
subs(a,b,c), eval(f,x,n), filter(f,a,b,...)
float(x)
quote(x)
clear
stop
tty = 0 o full display on
tty = 1 o full display off  
trace = 0/1  trace off/on
autoexpand = 0/1  off/on
last        use last expression as argument
bake = 0/1
selftest
 
special functions
hermite(x,n), laguerre(x,n,a), legendre(x,n,m)
dirac(x)
 
specific EVA functions
isMvector(u)
isVector(u)
isScalar(u)
isInteger(u)
isNumber(u)
 
oddGrade(u)
evenGrade(u)
grade0(u)
grade1(u)
blade(u)
versor(u)