abs()
=====

       Format:
    abs(x)

       Argumente:
    x: Zahl, Vektor

       Ergebnis:
Zahl

   Falls x eine Zahl ist, wird der Betrag von x zurückgegeben.
Wenn x ein Vektor ist, wird die euklidische Norm (Länge) von x
zurückgegeben.

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

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

       Argumente:
    m: Matrix
    r1,r2: ganze Zahl zwischen 0 und rows(m)
    x: Zahl

       Ergebnis:
Matrix

   Gibt die Matrix m zurück, außer daß die Zeile r1 durch (row
r1) + x * (row r2) ersetzt wird.

arc()
=====

       Format:
    arc(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Wenn x eine komplexe Zahl ist, wird der Winkel zwischen x und
der x-Achse in der Gauss'schen Zahlenebene zurückgegeben, der
definiert ist als atan(im(x) / re(x))

       arc() einer positiven reellen Zahl ist definiert als 1 und
einer negativen als -1.

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

       Format:
    average(s)

       Argumente:
    s: Menge

       Ergebnis:
hängt vom Mengeninhalt ab

   Gibt das arithmetische Mittel des Mengeninhaltes zurück.

cols()
======

       Format:
    cols(m)

       Argumente:
    m: Matrix

       Ergebnis:
Zahl

   Gibt die Anzahl der Spalten von m zurück.

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

       Format:
    combine(a1, a2...)

       Argumente:
    a1, a2...: Vektor, Matrix

       Ergebnis:
Matrix

   Erzeugt eine Matrix aus den gegebenen Spaltenvektoren und Matrizen.

conj()
======

       Format:
    conj(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Liefert das komplex konjugierte von x zurück.

const()
=======

       Format:
    const(name1,name2...)

       Argumente:
    name1,name2...: Konstantenbezeichner

       Ergebnis:
keins

       const() erzeugt Konstanten mit dem gegebenen Namen.

   Eine optionale Typenspezifizierung läßt sich für jeden Namen im
Format name:type angeben, siehe Anleitung/Typen

count()
=======

       Format:
    count(s)

       Argumente:
    s: Menge

       Ergebnis:
Zahl

   Gibt die Anzahl der Elemente in der Menge s zurück.

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

       Format:
    cvector(m,c)

       Argumente:
    m: Matrix
    c: ganze Zahl zwischen 0 und cols(m)

       Ergebnis:
Vektor

   Gibt den Zeilenvektor der c-ten Zeile der Matrix m zurück.

debug()
=======

       Format:
    debug(string)

       Argumente:
    string: beliebige Zeichenkette

       Ergebnis:
keins

   Fügt die Zeichenkette string an die Debugliste an.

det()
=====

       Format:
    det(m)

       Argumente:
    m: Matrix

       Ergebnis:
Zahl

   Gibt die Determinante der Matrix m zurück.

diff()
======

       Format:
    diff(ex,var)

       Argumente:
    ex: beliebiger Ausdruck
    var: Variablenbezeichner

       Ergebnis:
hängt vom Ausdruck ab

   Liefert die erste Ableitung des gegebenen Ausdruckes zurück.

   Einige Beispiele:
     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)

Bemerkung
---------

   Wenn Du diff() als 'Stand alone' Ausdruck benutzt, also nicht als
rechte Seite einer Funktionsdefinition, und die benutzte Variable ist
in diesem Kontext nicht bekannt, so wird sie als Konstante erzeugt.
Dies kann jedoch zu Fehlern führen, wenn sie bereits vorher mit einem
anderen Typ benutzt wurde, z.B.:
     x=[1,2,3]
     ...
     f(x)=sin(x)
     diff(f, x)

       diff() sollte eigentlich immer mit einem Ausdruck wie f'(x) =
diff(f, x) benutzt werden und wenn nicht, sollten die Variablen vorher
als Konstanten deklariert werden.

dim()
=====

       Format:
    dim(v)

       Argumente:
    v: Vektor

       Ergebnis:
Zahl

   Liefert die Dimension des Vektors v zurück.

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

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

       Argumente:
    name1,name2,...: Objektbezeichner

       Ergebnis:
keins

   Dies gibt den Speicherplatz der vorher definierten Objekte wieder
frei.

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

       Format:
    disposeall()

       Argumente:
keine

       Ergebnis:
keins

   Dies gibt den Speicherplatz aller vorher definierten Objekte wieder
frei.

do()
====

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

       Argumente:
    ex1,ex2,...: beliebige Ausdrücke

       Ergebnis:
Ergebnis des letzten Ausdruckes

   Ein Synonym für eine Ausdrucksliste (siehe Anleitung/Ausdrücke).
z.B.
     {debug("Hallo Welt !"), sin(2)}
     do(debug("Hallo Welt !"), sin(2))

drop()
======

       Format:
    drop(ex)

       Argumente:
    ex: beliebig

       Ergebnis:
keins

   Der Ausdruck ex wird ausgewertet, es wird jedoch kein Ergebnis
zurückgegeben.

eq()
====

       Format:
    eq(left,right)

       Argumente:
    left,right: beliebige Ausdrücke

       Ergebnis:
Gleichung

   Erzeugt eine Gleichung mit der gegebenen linken und rechten Seite.

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

       Format:
    eqleft(e), eqright(e)

       Argumente:
    e: Gleichung

       Ergebnis:
hängt von der Gleichung ab

   Liefert die linke bzw. rechte Seite der Gleichung zurück.

error()
=======

       Format:
    error(s)

       Argumente:
    s: Menge von Zahlen

       Ergebnis:
Zahl

   Liefert den statistische Fehler des Durchschnittswertes zurück, der
definiert ist durch error(s) := sigma(s)/(sqrt(count(s)).

eval()
======

       Format:
    eval(ex)

       Argumente:
    ex: beliebiger Ausdruck

       Ergebnis:
hängt vom Ausdruck ab

   Der gegeben Ausdruck wird ausgewertet. Dabei werden auch
Parameterreferenzen ausgewertet (siehe Anleitung/Parameterreferenzen).

exp()
=====

       Format:
    exp(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Liefert e hoch x.

fak()
=====

       Format:
    fak(x)

       Argumente:
    x: ganze Zahl

       Ergebnis:
Zahl

   Liefert x! (Fakultät) zurück. Für x <= 0 wird 0
zurückgegeben.

for()
=====

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

       Argumente:
    init: beliebiger Ausdruck
    cond: Boolsch
    ex: beliebiger Ausdruck
    end: beliebiger Ausdruck

       Ergebnis:
hängt von end ab

   Zuerst wird der Ausdruck init ausgewertet, was gewöhnlich eine
Variablendefinition ist. Anschließend wird ex solange wiederholt
ausgewertet, wie cond als TRUE ausgewertet wird. Sobald die
Schleife dann beendet ist (cond also FALSE ist), wird end
ausgewertet und als Ergebnis zurückgegeben.
     f(x) = for({n=0, f(x)=0}, n<10, {f(x)=f(x)+x^n, n=n+1}, f(x))

if()
====

       Format:
    if(cond,ex1,ex2)

       Argumente:
    cond: Boolsch
    ex1,ex2: beliebiger Ausdruck

       Ergebnis:
hängt von den Ausdrücken ab

   Wenn cond als TRUE ausgewertet wird, wird ex1 ausgewertet und
als Ergebnis zurückgegeben, ansonsten ex2.

im()
====

       Format:
    im(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Liefert den Imaginärteil von x zurück.

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

       Format:
    include(path)

       Argumente:
    path: Pfad zur Bibliotheksdatei

       Ergebnis:
keins

   Die spezifizierte Datei im Verzeichnis Include wird geladen und
zeilenweise ausgewertet. Sie dazu auch Anleitung/Bibliotheken.

inv()
=====

       Format:
    inv(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Liefert das Inverse von x, also 1/x zurück.

invert()
========

       Format:
    invert(m)

       Argumente:
    m: Matrix

       Ergebnis:
Matrix

   Liefert die inverse Matrix zu m zurück.

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

       Format:
    isatomar(x)

       Argumente:
    x: beliebiger Ausdruck

       Ergebnis:
Boolsch

   Liefert TRUE, wenn x ein atomares Objekt ist.

Typenüberprüfung
================

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

       Argumente:
    x: beliebiger Ausdruck

       Ergebnis:
Boolsch

   Liefert TRUE, wenn x vom spezifizierten Typ ist.

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

       Format:
    ln(x), log(x)

       Argumente:
    x: positive Zahl

       Ergebnis:
Zahl

   Liefert den natürlichen Logarithmus ln x (Basis e), bzw.  den
dekadischen Logarithmus log x (Basis 10) zurück.

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

       Format:
    multrow(m,r,x)

       Argumente:
    m: Matrix
    r: ganze Zahl zwischen 0 und rows(m)
    x: Zahl

       Ergebnis:
Matrix

   Liefert die Matrix m zurück, außer daß die Zeile r mit x
multipliziert wurde.

nand()
======

       Format:
    nand(b1,b2)

       Argumente:
    b1,b2: Boolsch

       Ergebnis:
Boolsch

   Liefert FALSE, falls b1 und b2 TRUE sind, ansonsten
TRUE.

neg()
=====

       Format:
    neg(x)

       Argumente:
    x: Zahl, Vektor, Matrix

       Ergebnis:
Zahl, Vektor, Matrix

   Liefert das Negative der Zahl, des Vektors oder der Matrix. Bei
Vektoren und Matrizen werden alle Komponenten negiert.

nor()
=====

       Format:
    nor(b1,b2)

       Argumente:
    b1,b2: Boolsch

       Ergebnis:
Boolsch

   Liefert TRUE, falls b1 und b2 FALSE sind, ansonsten
FALSE.

norm()
======

       Format:
    norm(a)

       Argumente:
    a: Zahl, Vektor, Matrix

       Ergebnis:
Zahl, Vektor, Matrix

   Wenn a ein Vektor ist, wird dieser normiert, das heißt auf den
Betrag 1 gebracht. Bei einer Matrix werden alle Spaltenvektoren
normiert.

   Falls a eine komplexe Zahl ist, wird sie wie ein zweidimensionaler
Vektor behandelt. Eine reelle Zahl wird immer auf eins normiert.

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

       Format:
    orthogonal(m)

       Argumente:
    m: Matrix

       Ergebnis:
Matrix

   Mit Hilfe des Gram-Schmitt-Verfahrens, werden die Spaltenvektoren
der Matrix m orthogonalisiert.

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

       Format:
    quickhelp(Schlüsselwort)

       Argumente:
    Schlüsselword: Schlüsselwort nach dem gesucht werden soll

       Ergebnis:
eine kurze Beschreibung

   Zeigt eine kurze Beschreibung zu dem gegebenen Schlüsselwort an.
Dies ist ein Synonym zu ?keyword.  Siehe dazu auch
Anleitung/Online-Hilfe.

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

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

       Argumente:
    x: positive Zahl, optional, Voreinstellung 1
    n: ganze positive Zahl

       Ergebnis:
    random(), irandom(): Zahl
    randomseed(): keins

       random(x) liefert eine Zufallszahl zwischen 0 und x;
x kann auch weggelassen werden, wobei dann 1 benutzt wird.

       irandom(n) liefert eine ganze Zufallszahl zwischen 0 und
n.

       randomseed(n) setzt den Initialwert für den
Zufallszahlengenerator.

rank()
======

       Format:
    rank(m)

       Argumente:
    m: Matrix

       Ergebnis:
Zahl

   Liefert die Rang der Matrix m zurück.

re()
====

       Format:
    re(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Liefert den Realteil von x zurück.

rows()
======

       Format:
    rows(m)

       Argumente:
    m: Matrix

       Ergebnis:
Zahl

   Liefert die Anzahl der Zeilen der Matrix m.

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

       Format:
    rvector(m,r)

       Argumente:
    m: Matrix
    r: ganze Zahl zwischen 0 und rows(m)

       Ergebnis:
Vektor

   Liefert den Zeilenvektor der r-ten Zeile der Matrix m.

set()
=====

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

       Argumente:
    a1,a2,...: beliebige Ausdrücke

       result:
Menge

   Erzeugt eine Menge der gegebenen Elemente. Alle Elemente müssen vom
selben Typ sein.

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

       Format:
    showhelp(Schlüsselwort)

       Argumente:
    Schlüsselword: Schlüsselwort nach dem gesucht werden soll

       Ergebnis:
n/a

   Zeigt detailierte Hilfe zu dem gegebenen Schlüsselwort an. Dies ist
ein Synonym zu ??keyword.  Siehe dazu auch Anleitung/Online-Hilfe.

sigma()
=======

       Format:
    sigma(s)

       Argumente:
    s: Menge von Zahlen

       Ergebnis:
Zahl

   Liefert die Standardabweichung der Mengenelemente vom Mittelwert,
die definiert ist durch sqrt(sum((x - y)^2)/(count(s-1))) mit y =
average(s).

sign()
======

       Format:
    sign(x)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   Liefert -1, wenn x < 0; 0, wenn x = 0 und 1 wenn x >
0.

solve()
=======

       Format:
    solve(m)

       Argumente:
    m: Matrix

       Ergebnis:
Matrix

   Wendet den Gaußalgorithmus auf die Matrix m an.

spur()
======

       Format:
    spur(m)

       Argumente:
    m: Matrix

       Ergebnis:
Zahl

   Liefert die Spur der Matrix m. m muß quadratisch sein.
spur(m) := sum(x_ii), m = [x_ij, 1<=i<=n, 1<=j<=n]

sqrt()
======

       Format:
    sqrt(x)

       Argumente:
    x: positive Zahl

       Ergebnis:
Zahl

   Liefert die Quadratwurzel von x.

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

       Format:
    swaprows(m,r1,r2)

       Argumente:
    m: Matrix
    r1,r2: ganze Zahlen zwischen 0 und rows(m)

       Ergebnis:
Matrix

   Liefert die Matrix m, außer daß die Zeilen r1 und r2
vertauscht wurden.

taylor()
========

       Format:
    taylor(ex,x,x,n)

       Argumente:
    ex: Ausdruck des Typs Zahl oder Funktionsbezeichner
    x: Zahl
    a: Zahl
    n: ganze positive Zahl

       Ergebnis:
Ausdruck des Typs Zahl

   Dies berechnet die Taylorentwicklung n-ten Grades der Funktion
ex in der Variablen x an der Stelle a. Wird n weggelassen, wird
die Voreinstellung 2 benutzt, z.B.
     f(x) = taylor(sin(x), x, 0)
     g(x) = taylor(ln(x), x, 1)
     h(x) = taylor(exp(x), x, 0, 5)

   Siehe auch die Bemerkung zu diff(), die gleichen Einschränkungen
gelten auch für die taylor() Funktion.

trans()
=======

       Format:
    trans(m)

       Argumente:
    m: Matrix

       Ergebnis:
Matrix

   Liefert die transponierte Matrix zu m.

Trigonometrische Funktionen
===========================

       Format:
    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)

       Argumente:
    x: Zahl

       Ergebnis:
Zahl

   nun, eben die altbekannten trigonometrischen Funktionen...

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

       Format:
    umatrix(n)

       Argumente:
    n: ganze positive Zahl

       Ergebnis:
Matrix

   Erzeugt eine Einheitsmatrix der Größe n.

window()
========

       Format:
    window(name)

       Argumente:
    name: Objektbezeichner

       Ergebnis:
keins

   Dies öffnet ein Fenster, in welchem das Objekt angezeigt wird.