abs()
=====

       sypnosis:
    abs(x)

       arguments:
    x: number, vector

       result:
number

   If x is a number, the absolute of x is returned. If x is a
vector, the (euclidian) length of the vector is returned.

addrows()
=========

       sypnosis:
    addrows(m,r1,r2,x)

       arguments:
    m: matrix
    r1,r2: integer between 0 and rows(m)
    x: number

       result:
matrix

   Returns the matrix m, except that row r1 is replaced by (row
r1) + x * (row r2).

arc()
=====

       sypnosis:
    arc(x)

       arguments:
    x: number

       result:
number

   If x is a complex number, the angle between x and the x-axis in
the gaussian plane will be returned, which is defined as atan(im(x) /
re(x))

       arc() of an positive real number is defined as 1 and of a
negative as -1.

average()
=========

       sypnosis:
    average(s)

       arguments:
    s: set

       result:
depends on set contents

   Returns the arithmetic average of the set contents.

cols()
======

       sypnosis:
    cols(m)

       arguments:
    m: matrix

       result:
number

   Returns the number of columns of the matrix m.

combine()
=========

       sypnosis:
    combine(a1, a2...)

       arguments:
    a1, a2...: vector, matrix

       result:
matrix

   Returns a matrix constructed from the given column vectors and
matrices.

conj()
======

       sypnosis:
    conj(x)

       arguments:
    x: number

       result:
number

   Returns the complex conjunction of x.

const()
=======

       sypnosis:
    const(name1,name2...)

       arguments:
    name1,name2...: constant names

       result:
n/a

       const() will create constants with the given names.

   You can specify an optional type identifier for each name by entering
name:type, see Manual/Types.

count()
=======

       sypnosis:
    count(s)

       arguments:
    s: set

       result:
number

   Return the number of elementes in the set s.

cvector()
=========

       sypnosis:
    cvector(m,c)

       arguments:
    m: matrix
    c: integer between 0 and cols(m)

       result:
vector

   Returns a vector, consisting of the column c of the matrix m.

debug()
=======

       sypnosis:
    debug(string)

       arguments:
    string: any string

       result:
n/a

   This will add the string to the debug list.

det()
=====

       sypnosis:
    det(m)

       arguments:
    m: matrix

       result:
number

   Returns the determinant of the matrix m.

diff()
======

       sypnosis:
    diff(ex,var)

       arguments:
    ex: any expression
    var: variable name

       result:
depends on expression type

   This will calculate the first (partial) derivation of the given
expression.

   Some examples:
     f'(x) = diff(x^2, x)
     
     f(x) = x^2
     f'(x) = diff(f, x)
     
     f(x, y) = x^2 + y^3
     f_x'(x, y) = diff(f, x)
     f_y'(x, y) = diff(f, y)
     g(x) = diff(f(x,1), x)

Remark
------

   If you use diff() as a 'stand alone' expression that means not as
the right side of an function definition and the used variables are not
defined in this context and they are created as constant objects. This
can lead to errors if the same name was used earlier but with another
type, e.g.:
     x=[1,2,3]
     ...
     f(x)=sin(x)
     diff(f, x)

   You should then declare x as a constant before you use diff(), or
use something like f'(x) = diff(f, x).

dim()
=====

       sypnosis:
    dim(v)

       arguments:
    v: vector

       result:
number

   Return the dimension of the vector v.

dispose()
=========

       sypnosis:
    dispose(name1,name2,...)

       arguments:
    name1,name2,...: object names

       result:
n/a

   This will dispose the previously defined objects with the given name.

disposeall()
============

       sypnosis:
    disposeall()

       arguments:
n/a

       result:
n/a

   This will dispose all previously defined objects.

do()
====

       sypnosis:
    do(ex1,ex2,...)

       arguments:
    ex1,ex2,...: expression of any type

       result:
result of the last expression

   This is a synonym for an expression list (see Manual/Expressions).
E.g.
     {debug("Hello world !"), sin(2)}
     do(debug("Hello world !"), sin(2))

drop()
======

       sypnosis:
    drop(ex)

       arguments:
    ex: any

       result:
n/a

   Evaluates ex, without returning a result.

eq()
====

       sypnosis:
    eq(left,right)

       arguments:
    left,right: expressions of any type

       result:
equation

   Creates an equation with the given left and right side.

eqleft(), eqright()
===================

       sypnosis:
    eqleft(e), eqright(e)

       arguments:
    e: equation

       result:
depends on equation contents

   Return the left or right side of the equation e.

error()
=======

       sypnosis:
    error(s)

       arguments:
    s: set of number elements

       result:
number

   Returns the statistical error of the average value, which is
error(s) := sigma(s)/(sqrt(count(s)).

eval()
======

       sypnosis:
    eval(ex)

       arguments:
    ex: expression on any type

       result:
depends on the expression

   This will evaluate the given expression. Parameters are replaced, too
(see Manual/parameter).

exp()
=====

       sypnosis:
    exp(x)

       arguments:
    x: number

       result:
number

   Return e to the power of x.

fak()
=====

       sypnosis:
    fak(x)

       arguments:
    x: integer

       result:
number

   Returns x! (factorial). If x <= 0, 0 is returned.

for()
=====

       sypnosis:
    for(init,cond,ex,end)

       arguments:
    init: any
    cond: boolean
    ex: any
    end: any
    result:
depends on end

   First the init expression will be evaluated, which is usually an
variable definition. That ex will be repeatedly evaluated as long as
cond evaluates to TRUE. When the loop is finished (cond is
FALSE), end will be evaluated and it's result will be returned.
     f(x) = for({n=0, f(x)=0}, n<10, {f(x)=f(x)+x^n, n=n+1}, f(x))

if()
====

       sypnosis:
    if(cond,ex1,ex2)

       arguments:
    cond: boolean
    ex1,ex2: any

       result:
depends on expressions

   If cond evaluates to TRUE, ex1 will be evaluated, else
ex2.

im()
====

       sypnosis:
    im(x)

       arguments:
    x: number

       result:
number

   Returns the imaginary part of x.

include()
=========

       sypnosis:
    include(path)

       arguments:
    path: path of the include file

       result:
n/a

   This will load and process a file from the directory Include.  See
also Manual/Libraries.

inv()
=====

       sypnosis:
    inv(x)

       arguments:
    x: number

       result:
number

   Returns the invers 1/x.

invert()
========

       sypnosis:
    invert(m)

       arguments:
    m: matrix

       result:
matrix

   Returns the invers of the matrix m.

isatomar()
==========

       sypnosis:
    isatomar(x)

       arguments:
    x: any

       result:
boolean

   Return TRUE, if x is an atomar object.

Type checking
=============

       sypnosis:
    isnumber(x), iscomplex(x), isvector(x),
ismatrix(x), isboolean(x), isset(x),
isequation(x)

       arguments:
    x: any

       result:
boolean

   Return TRUE, if x is of the specified type.

ln(), log()
===========

       sypnosis:
    ln(x), log(x)

       arguments:
    x: positive number

       result:
number

   Returns ln x (base e), or log x (base 10).

multrow()
=========

       sypnosis:
    multrow(m,r,x)

       arguments:
    m: matrix
    r: integer between 0 and rows(m)
    x: number

       result:
matrix

   Returns the matrix m, except that rows r is multiplied with
x.

nand()
======

       sypnosis:
    nand(b1,b2)

       arguments:
    b1,b2: boolean

       result:
boolean

   Return FALSE, if b1 and b2 are TRUE, else TRUE.

neg()
=====

       sypnosis:
    neg(x)

       arguments:
    x: number, vector, matrix

       result:
number, vector, matrix

   Returns the negative of the given number, vector or matrix. For
Vectors and Matrices, all components are negated.

nor()
=====

       sypnosis:
    nor(b1,b2)

       arguments:
    b1,b2: boolean

       result:
boolean

   Return TRUE, if b1 and b2 are FALSE, else FALSE.

norm()
======

       sypnosis:
    norm(a)

       arguments:
    a: number, vector, matrix

       result:
number, vector, matrix

   If a is a vector, the normed vector will be returned (the vector
pointing into the same direction, but with abs(a) = 1). If a is a
matrix every column vector will be normed.

   If a is a complex number it will be treated as a two-dimensional
vector.  A real number will always be normed to one.

orthogonal()
============

       sypnosis:
    orthogonal(m)

       arguments:
    m: matrix

       result:
matrix

   Use the Gram-Schmitt-algorithm to create a orthogonalized base of the
column vectors of m.

quickhelp()
===========

       sypnosis:
    quickhelp(keyword)

       arguments:
    keyword: keyword to search for

       result:
a short description

   Shows a short description for the given keyword. Same as
?keyword.  See also Manual/Online Help.

random(), irandom(), randomseed()
=================================

       sypnosis:
    random(x), irandom(n), randomseed(x)

       arguments:
    x: positive number, optional, defaults to 1
    n: positiv integer

       result:
    random(), irandom(): number
    randomseed(): n/a

       random(x) returns a random number between 0 and x; you
may omit x, which defaults then to 1.

       irandom(n) returns a integer between 0 and n.

       randomseed(n) sets the initial value for the random
algorithm.

rank()
======

       sypnosis:
    rank(m)

       arguments:
    m: matrix

       result:
number

   Returns the rank of the matrix m.

re()
====

       sypnosis:
    re(x)

       arguments:
    x: number

       result:
number

   Returns the real part of x.

rows()
======

       sypnosis:
    rows(m)

       arguments:
    m: matrix

       result:
number

   Returns the number of rows of the matrix m.

rvector()
=========

       sypnosis:
    rvector(m,r)

       arguments:
    m: matrix
    r: integer between 0 and rows(m)

       result:
vector

   Returns a vector, consisting of the row r of the matrix m.

set()
=====

       sypnosis:
    set(a1,a2,...)

       arguments:
    a1,a2,...: any

       result:
set

   Creates a set of the given elements. All elements must be of the same
type.

showhelp()
==========

       sypnosis:
    showhelp(keyword)

       arguments:
    keyword: keyword to search for

       result:
n/a

   Shows detailed help for the given keyword. Same as ??keyword.  See
also Manual/Online Help.

sigma()
=======

       sypnosis:
    sigma(s)

       arguments:
    s: set of number elements

       result:
number

   Returns the standart error of the given set elements, which is
defined as sqrt(sum((x - y)^2)/(count(s-1) with y =
average(s).

sign()
======

       sypnosis:
    sign(x)

       arguments:
    x: number

       result:
number

   Returns -1, if x < 0; 0, if x = 0 and 1 if x > 0.

solve()
=======

       sypnosis:
    solve(m)

       arguments:
    m: matrix

       result:
matrix

   Apply the gaussian algorithm to the matrix m.

spur()
======

       sypnosis:
    spur(m)

       arguments:
    m: matrix

       result:
number

   Return the spur of the matrix m. m must be square.  spur(m)
:= sum(x_ii), m = [x_ij, 1<=i<=n, 1<=j<=n]

sqrt()
======

       sypnosis:
    sqrt(x)

       arguments:
    x: positive number

       result:
number

   Returns the square root of x.

swaprows()
==========

       sypnosis:
    swaprows(m,r1,r2)

       arguments:
    m: matrix
    r1,r2: integer between 0 and rows(m)

       result:
matrix

   Return the matrix m, except that rows r1 and r2 are swapped.

taylor()
========

       sypnosis:
    taylor(ex,x,a,n)

       arguments:
    ex: expression of number type
    x: number
    a: number
    n: positive integer

       result:
expression of number type

   This will calculate a taylor approximation for the given expression
of the variable x at the point a of the given grade n. If you
omit n, a default of 2 will be used, e.g.:
     f(x) = taylor(sin(x), x, 0)
     g(x) = taylor(ln(x), x, 1)
     h(x) = taylor(exp(x), x, 0, 5)

   See also the remark to the diff() function. The same restrictions
apply to the taylor() function.

trans()
=======

       sypnosis:
    trans(m)

       arguments:
    m: matrix

       result:
matrix

   Returns the transposed matrix of m.

Trigonometric functions
=======================

       sypnosis:
    sin(x), cos(x), tan(x), cot(x), asin(x),
acos(x), atan(x), acot(x), sinh(x), cosh(x),
tanh(x), asinh(x), acosh(x), atanh(x)

       arguments:
    x: number

       result:
number

   well, the well known trigonometric functions, should I say more...

umatrix()
=========

       sypnosis:
    umatrix(n)

       arguments:
    n: positive integer

       result:
matrix

   This will create a standart matrix of the given size.

window()
========

       sypnosis:
    window(name)

       arguments:
    name: object name

       result:
n/a

   This will open a window, displaying the named object.