Sin, Cos, Tan , ArcSin, ArcCos, ArcTan , Exp , Ln , Sqrt , Abs , Sign , Complex , Re , Im , I , Conjugate , Arg , ! , Bin , Sum , Average , Factorize , Min , Max , IsZero , IsRational , Numer , Denom , Commutator , Taylor , InverseTaylor , ReversePoly , BigOh , Newton , D , Curl , Diverge , Integrate , Simplify , RadSimp , Rationalize , Solve , SuchThat , Eliminate , PSolve , Pi , Random , VarList , Limit , TrigSimpCombine , LagrangeInterpolant , Fibonacci .

Analysis

In diesem Abschnitt werden Funktionen aus der Analysis beschrieben. Enthalten sind die elementaren mathematischen Funktionen sowie Funktionen für die Differential- und Integralrechnung.

Sin, Cos, Tan trigonometrische Funktionen
ArcSin, ArcCos, ArcTan inverse trigonometrische Funktionen
Exp Exponentialfunktion
Ln natürlicher Logarithmus
Sqrt Quadratwurzel
Abs Absolutbetrag
Sign Signum
Complex Darstellung einer komplexen Zahl
Re Realteil einer komplexen Zahl
Im Imaginärteil einer komplexen Zahl
I imaginäre Einheit
Conjugate konjugiert komplexe Zahl
Arg Argument einer komplexen Zahl
! Fakultät
Bin Binomialkoeffizient
Sum Summe einer Liste von Zahlen
Average Mittelwert einer Liste von Zahlen
Factorize Produkt einer Liste von Zahlen
Min Minimum einer Liste von Zahlen
Max Maximum einer Liste von Zahlen
IsZero testen, ob das Argument Null ist
IsRational testen, ob das Argument ein Bruch ist
Numer Zähler eines Ausdrucks
Denom Nenner eines Ausdrucks
Commutator Kommutator zweier Objekte
Taylor univariate Taylorentwicklung
InverseTaylor inverse Taylorentwicklung
ReversePoly berechnet "h(f(x)) = g(x) + O(x^n)" für h
BigOh alle Terme ab einer best. Ordnung aus einem Polynom entfernen
Newton Nullstellenbestimmung mit dem Newtonverfahren
D Differentiation
Curl Rotation eines Vektorfeldes
Diverge Divergenz eines Vektorfeldes
Integrate Integration
Simplify einen Ausdruck vereinfachen
RadSimp einen Ausdruck mit verschachtelten Wurzelausdrücken vereinfachen
Rationalize Umwandlung einer Dezimalzahl in einen Bruch
Solve Lösung einer Gleichung bzw. eines Gleichungssystems
SuchThat einen Wert so bestimmen, dass ein Ausdruck Null wird
Eliminate substituieren und vereinfachen
PSolve Nullstellen eines Polynoms berechnen
Pi Näherungswert für pi
Random Zufallszahl zwischen 0 und 1
VarList Liste aller in einem Term enthaltenen Variablen
Limit Grenzwert eines Ausdrucks
TrigSimpCombine Produkte trig. Funktionen in Summen umformen
LagrangeInterpolant Lagrange-Interpolation
Fibonacci Fibonacci Zahlen


Sin, Cos, Tan -- trigonometrische Funktionen

mathematische Standardbibliothek
Funktionsaufruf:
Sin(x)
Cos(x)
Tan(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Diese Funktionen repräsentieren die trigonometrischen Funktionen Sinus, Cosinus und Tangens. Wenn x eine Zahl ist, werden die Funktionswerte nicht ausgerechnet, um die Genauigkeit zu erhöhen. Mit den N(...)-Funktionen können die Ergebnisse als Fließkommazahlen ausgegeben werden.

Yacas kennt grundlegende trigonometrische Zusammenhänge, so dass exakte Vereinfachungen ohne die N(...)-Funktionen möglich sind. Dies ist z.B. immer dann der Fall, wenn die Argumente Vielfache oder Bruchteile von Pi sind.
Beispiele:
In> Sin(1)
Out> Sin(1);
In> N(Sin(1),20)
Out> 0.84147098480789650665;
In> Sin(Pi/4)
Out> Sqrt(2)/2;
Siehe auch:
ArcSin, ArcCos, ArcTan , N , Pi .


ArcSin, ArcCos, ArcTan -- inverse trigonometrische Funktionen

mathematische Standardbibliothek
Funktionsaufruf:
ArcSin(x)
ArcCos(x)
ArcTan(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Diese Funktionen repräsentieren die inversen trigonometrischen Funktionen Arcussinus, Arcuscosinus und Arcustangens.

Der Wertebereich der Funktionen "ArcSin(x)" und "ArcTan(x)" ist das Intervall [-Pi/2 | Pi/2], der der Funktion "ArcCos(x)" das Intervall [0 | Pi].

Yacas lässt diese Funktionen in Berechnungen unverändert, die Berechnung von Näherungswerten kann jedoch durch Anwendung der N-Funktion erzwungen werden. Bei besonderen Argumenten (z.B. -1, 0, 1 usw.) wird der Ausdruck vereinfacht. Ist das Argument eine komplexe Zahl, wird der Ausdruck in eine Ln-Funktion umgeformt.

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> ArcSin(1)
Out> Pi/2;

In> ArcSin(1/3)
Out> ArcSin(1/3);
In> Sin(ArcSin(1/3))
Out> 1/3;

In> N(ArcSin(0.75))
Out> 0.848062;
In> N(Sin(%))
Out> 0.7499999477;
siehe auch:
Sin, Cos, Tan , N , Pi , Ln .


Exp(x) -- Exponentialfunktion

mathematische Standardbibliothek
Funktionsaufruf:
Exp(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Diese Funktion berechnet e^x wobei e die Eulersche Zahl 2.71828... ist. Der Ausdruck Exp(1) kann als Darstellung von e verwendet werden.

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> Exp(0)
Out> 1;

In> Exp(I*Pi)
Out> -1;

In> Exp(2)
Out> Exp(2);

In> Ln(%)
Out> 2;

In> N(Exp(1))
Out> 2.7182818284;
siehe auch:
Ln , Sin, Cos, Tan , N .


Ln -- natürlicher Logarithmus

mathematische Standardbibliothek
Funktionsaufruf:
Ln(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Diese Funktion berechnet den natürlichen Logarithmus von "x". Ist das Argument eine komplexe Zahl, liegt der Imaginärteil im Intervall [-Pi,Pi].

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> Ln(1)
Out> 0;
In> Ln(Exp(x))
Out> x;
In> D(x) Ln(x)
Out> 1/x;
siehe auch:
Exp , Arg .


Sqrt -- Quadratwurzel

mathematische Standardbibliothek
Funktionsaufruf:
Sqrt(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Diese Funktion berechnet die Quadratwurzel von x. Ist das Ergebnis irrational, wird der Ausdruck nicht berechnet, die Berechnung von Näherungswerten kann jedoch durch Anwendung der N-Funktion erzwungen werden.
Als Argument sind auch negative und komplexe Zahlen erlaubt.

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> Sqrt(16)
Out> 4;

In> Sqrt(15)
Out> Sqrt(15);

In> N(Sqrt(15))
Out> 3.8729833462;

In> Sqrt(4/9)
Out> 2/3;

In> Sqrt(-1)
Out> Complex(0,1);
siehe auch:
Exp , ^ , N .


Abs -- Absolutbetrag

mathematische Standardbibliothek
Funktionsaufruf:
Abs(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Diese Funktion berechnet den Betrag der Zahl "x".
Als Argument sind komplexe Zahlen erlaubt.

Abs(x)*Sign(x) ist immer gleich x.

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> Abs(-2)
Out> 2;

In> Abs(-1/2);
Out> -1/2;

In> Abs(3+4*I);
Out> 5;
siehe auch:
Sign , Arg .


Sign -- Signum

mathematische Standardbibliothek
Funktionsaufruf:
Sign(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Das Ergebnis dieser Funktion ist 1, falls "x" positiv oder Null ist, sonst -1.

Abs(x)*Sign(x) ist immer gleich x.

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> Sign(2)
Out> 1;

In> Sign(-3)
Out> -1;

In> Sign(0)
Out> 1;

In> Sign(-3) * Abs(-3)
Out> -3;
siehe auch:
Arg , Abs .


Complex -- Darstellung einer komplexen Zahl

mathematische Standardbibliothek
Funktionsaufruf:
Complex(x, y)
Parameter:
x - eine reelle Zahl
y - eine reelle Zahl
Beschreibung:
Diese Funktion repräsentiert die komplexe Zahl x+i*y, wobei i die imaginäre Einheit ist.
Es gilt i=Sqrt(-1).
Beispiele:
In> I
Out> Complex(0,1);

In> z := 2+3*I
Out> Complex(2,3);

In> Complex(-2,0)
Out> -2;
siehe auch:
Re , Im , I , Abs , Arg .


Re -- Realteil einer komplexen Zahl

mathematische Standardbibliothek
Funktionsaufruf:
Re(x)
Parameter:
x - eine komplexe Zahl
Beschreibung:
Diese Funktion liefert als Ergebnis den Realteil der komplexen Zahl "x".
Beispiele:
In> Re(5)
Out> 5;

In> Re(I)
Out> 0;

In> Re(Complex(3,4))
Out> 3;
siehe auch:
Complex , Im .


Im -- Imaginärteil einer komplexen Zahl

mathematische Standardbibliothek
Funktionsaufruf:
Im(x)
Parameter:
x - eine komplexe Zahl
Beschreibung:
Diese Funktion liefert als Ergebnis den Imaginärteil der komplexen Zahl "x".
Beispiele:
In> Im(5)
Out> 0;

In> Im(I)
Out> 1;

In> Im(Complex(3,4))
Out> 4;
siehe auch:
Complex , Re .


I -- imaginäre Einheit

mathematische Standardbibliothek
Funktionsaufruf:
I
Parameter:
keine
Beschreibung:
Diese Symbol repräsentiert die imaginäre Einheit i. i wird in der Form Complex(0,1) dargestellt.
Beispiele:
In> I
Out> Complex(0,1);

In> I = Sqrt(-1)
Out> True;
siehe auch:
Complex .


Conjugate -- konjugiert komplexe Zahl

mathematische Standardbibliothek
Funktionsaufruf:
Conjugate(x)
Parameter:
x - eine komplexe Zahl
Beschreibung:
Das Ergebnis dieser Funktion ist das konjugiert Komplexe zu "x".
Beispiele:
In> Conjugate(2)
Out> 2;

In> Conjugate(Complex(a,b))
Out> Complex(a,-b);
siehe auch:
Complex , Re , Im .


Arg -- Argument einer komplexen Zahl

mathematische Standardbibliothek
Funktionsaufruf:
Arg(x)
Parameter:
x - eine komplexe Zahl
Beschreibung:
Das Ergebnis dieser Funktion ist das Argument der komplexen Zahl "x". Das Argument ist der Winkel "phi" in der Polardarstellung "r * Exp(I*phi)" von "x". Das Ergebnis liegt im Intervall ]-Pi | Pi].
Das Argument von 0 ist Undefined.
Beispiele:
In> Arg(2)
Out> 0;

In> Arg(-1)
Out> Pi;

In> Arg(1+I)
Out> Pi/4;
siehe auch:
Abs , Sign .


! -- Fakultät

mathematische Standardbibliothek
Funktionsaufruf:
n!
Parameter:
n - eine positive ganze Zahl
Beschreibung:
n! ist das Ergebnis von n*(n-1)*(n-2)*....*1.

Ist das Argument eine Liste, wird die Funktion auf alle Listenelemente angewendet.
Beispiele:
In> 10!
Out> 3628800;

In> 1 * 2 * 3 * 4 * 5
Out> 120;

In> (10!)/((6!)*(4!))
Out> 210;

In> (3/2)!
Out> (3*Sqrt(Pi))/4;
siehe auch:
Bin , Factorize .


Bin -- Binomialkoeffizient

mathematische Standardbibliothek
Funktionsaufruf:
Bin(n, m)
Parameter:
n, m - natürliche Zahlen
Beschreibung:
Das Ergebnis dieser Funktion ist der Binomialkoeffizient "n" über "m", der als "n! / (n! * (n-m)!)" definiert ist.
Beispiele:
In> Bin(10, 4)
Out> 210;
In> 10! / (4! * 6!)
Out> 210;
siehe auch:
! .


Sum -- Summe einer Liste von Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
Sum(list)
Sum(var, from, to, body)
Parameter:
list - eine Liste von Zahlen
var - Indexvariable
from - Startindex
to - Endindex
body - zu berechnender Ausdruck
Beschreibung:
In der ersten Form von Sum werden alle Listenelemente addiert und die Summe als Ergebnis zurückgegeben.

In der zweiten Form wird der Ausdruck "body" für alle ganzen Zahlen "var" aus dem Bereich "from" bis "to" berechnet und die Summe der Ergebnisse zurückgegeben.
Beispiele:
In> Sum({1,4,9});
Out> 14;
In> Sum(i, 1, 3, i^2);
Out> 14;
siehe auch:
Average , Factorize , Apply .


Average -- Mittelwert einer Liste von Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
Average(list)
Parameter:
list - eine Liste von Zahlen
Beschreibung:
Diese Funktion berechnet das arithmetische Mittel aller Listenelemente.
Beispiele:
In> Average({1,2,3,4,5});
Out> 3;

In> Average({2,6,7});
Out> 5;
siehe auch:
Sum .


Factorize -- Produkt einer Liste von Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
Factorize(list)
Factorize(var, from, to, body)
Parameter:
list - eine Liste von Zahlen
var - Indexvariable
from - Startindex
to - Endindex
body - zu berechnender Ausdruck
Beschreibung:
In der ersten Form von Factorize werden alle Listenelemente multipliziert und das Produkt als Ergebnis zurückgegeben.

In der zweiten Form wird der Ausdruck "body" für alle ganzen Zahlen "var" aus dem Bereich "from" bis "to" berechnet und das Produkt der Ergebnisse zurückgegeben.
Beispiele:
In> Factorize({1,2,3,4});
Out> 24;

In> Factorize(i, 1, 4, i);
Out> 24;
siehe auch:
Sum , Apply .


Min -- Minimum einer Liste von Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
Min(x,y)
Min(list)
Parameter:
x, y - zwei Zahlen
list - eine Liste von Zahlen
Beschreibung:
Das Ergebnis dieser Funktion ist das Minimum der im Argument übergebenen Zahlen. Als Argument sind nur numerische Werte erlaubt.
Beispiel:
In> Min(2,3);
Out> 2;

In> Min({5,8,4});
Out> 4;
siehe auch:
Max , Sum , Average .


Max -- Maximum einer Liste von Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
Max(x,y)
Max(list)
Parameter:
x, y - zwei Zahlen
list - eine Liste von Zahlen
Beschreibung:
Das Ergebnis dieser Funktion ist das Maximum der im Argument übergebenen Zahlen. Als Argument sind nur numerische Werte erlaubt.
Beispiele:
In> Max(2,3);
Out> 3;

In> Max({5,8,4});
Out> 8;
siehe auch:
Min , Sum , Average .


IsZero -- testen, ob das Argument Null ist

mathematische Standardbibliothek
Funktionsaufruf:
IsZero(n)
Parameter:
n - eine Zahl
Beschreibung:
Das Ergebnis von IsZero(x) ist True, falls x=0 ist, sonst False.
Beispiele:
In> IsZero(3.25)
Out> False;

In> IsZero(0)
Out> True;

In> IsZero(x)
Out> False;
siehe auch:
IsNumber , IsNotZero .


IsRational -- testen, ob das Argument ein Bruch ist

mathematische Standardbibliothek
Funktionsaufruf:
IsRational(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Das Ergebnis dieser Funktion ist True, falls der Ausdruck "expr" rational ist, ansonsten False.
Beispiele:
In> IsRational(5)
Out> False;

In> IsRational(2/7)
Out> True;

In> IsRational(a/b)
Out> True;

In> IsRational(x + 1/x)
Out> False;
siehe auch:
Numer , Denom .


Numer -- Zähler eines Ausdrucks

mathematische Standardbibliothek
Funktionsaufruf:
Numer(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Ist das Argument ein rationaler Term, dann wird als Ergebnis der Zähler des Terms zurückgegeben.
Beispiele:
In> Numer(2/7)
Out> 2;

In> Numer(a / x^2)
Out> a;

In> Numer(5)
Out> 5;
siehe auch:
Denom , IsRational , IsNumber .


Denom -- Nenner eines Ausdrucks

mathematische Standardbibliothek
Funktionsaufruf:
Denom(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Ist das Argument ein rationaler Term, dann wird als Ergebnis der Nenner des Terms zurückgegeben.
Beispiele:
In> Denom(2/7)
Out> 7;

In> Denom(a / x^2)
Out> x^2;

In> Denom(5)
Out> 1;
siehe auch:
Numer , IsRational , IsNumber .


Commutator -- Kommutator zweier Objekte

mathematische Standardbibliothek
Funktionsaufruf:
Commutator(a, b)
Parameter:
a, b - zwei Objekte
Beschreibung:
Diese Funktion berechnet den Kommutator von "a" und "b". Der Kommutator ist das Ergebnis von "a*b - b*a". Für Zahlen und andere Objekte mit kommutativer Multiplikation ist das Ergebnis Null. Die Multiplikation von Matrizen ist nicht kommutativ, so dass das Ergebnis i.a. von Null verschieden ist.
Beispiele:
In> Commutator(2,3)
Out> 0;

In> m1:=Identity(3)
Out> {{1,0,0},{0,1,0},{0,0,1}};

In> m1[1][2] := a
Out> True;

In> m2:=Identity(3)
Out> {{1,0,0},{0,1,0},{0,0,1}};

In> m2[2][2] := a
Out> True;

In> Commutator(m1,m2)
Out> {{0,a^2-a,0},{0,0,0},{0,0,0}};

In> PrettyPrinter("PrettyForm");

True

Out>

In> A := { {0,x}, {0,0} }

/              \
| ( 0 ) ( x )  |
|              |
| ( 0 ) ( 0 )  |
\              /

Out>

In> B := { {y,0}, {0,z} }

/              \
| ( y ) ( 0 )  |
|              |
| ( 0 ) ( z )  |
\              /

Out>

In> Commutator(A,B)

/                          \
| ( 0 ) ( x * z - y * x )  |
|                          |
| ( 0 ) ( 0 )              |
\                          /

Out>


Taylor -- univariate Taylorentwicklung

mathematische Standardbibliothek
Funktionsaufruf:
Taylor(var,at,order) expr
Parameter:
var - Variable nach der entwickelt wird
at - Entwicklungspunkt
order - maximale Ordnung
expr - Term, für den die Taylorentwicklung berechnet werden soll
Beschreibung:
Die Funktion berechnet die Taylorreihe des mit "expr" angegebenen Terms bis zur Ordnung "order".
Beispiele:
In> Taylor(x,0,9)Sin(x)

     3    5      7       9  
    x    x      x       x   
x - -- + --- - ---- + ------
    6    120   5040   362880

Out> True;
Siehe auch:
InverseTaylor , ReversePoly , BigOh .


InverseTaylor -- inverse Taylorentwicklung

mathematische Standardbibliothek
Funktionsaufruf:
InverseTaylor(var,at,order) expr
Parameter:
var - Variable nach der entwickelt wird
at - Entwicklungspunkt
order - maximale Ordnung
expr - Term, für den die inverse Taylorentwicklung berechnet werden soll
Beschreibung:
InverseTaylor berechnet die Taylorreihe der Umkehrfunktion des angegebenen Terms bis zur Ordnung "order".
Beispiele:
In> PrettyPrinter("PrettyForm")

True

Out>

In> exp1 := Taylor(x,0,7)Sin(x)

     3    5      7 
    x    x      x  
x - -- + --- - ----
    6    120   5040

Out>

In> exp2 := InverseTaylor(x,0,8)ArcSin(x)

 5      7     3    
x      x     x     
--- - ---- - -- + x
120   5040   6     

Out>

In> Simplify(exp1-exp2)

0

Out> 
Siehe auch:
ReversePoly , Taylor , BigOh .


ReversePoly -- berechnet "h(f(x)) = g(x) + O(x^n)" für h

mathematische Standardbibliothek
Funktionsaufruf:
ReversePoly(f, g, var, newvar, degree)
Parameter:
f - Funktion in einer Variablen "var"
g - Funktion in einer Variablen "var"
var - Funktionsvariable
newvar - Funktionsvariable des Ergebnispolynoms
degree - Grad des Ergebnispolynoms
Beschreibung:
Zu den angegebenen Polynomen f(var) und g(var) wird ein Polynom h(newvar) bestimmt, so dass h(f(var)) = g(var) gilt. Das resultierende Polynom h hat den Grad degree. Voraussetzung ist, dass die erste Ableitung von f nicht Null ist.

Diese Funktion wird zur Berechnung der Taylorreihe einer Funktion benötigt:
Ist g(var)=var, dann gilt h(f(var))=var und h ist somit die Umkehrfunktion von f.

Beispiele:
In> f(x):=Eval(Expand((1+x)^4))
Out> True;

In> g(x) := x^2
Out> True;

In> h(y):=Eval(ReversePoly(f(x),g(x),x,y,8))
Out> True;

In> BigOh(h(f(x)),x,8)
Out> x^2;

In> h(x)
Out> (-2695*(x-1)^7)/131072+(791*(x-1)^6)/32768+(-119*(x-1)^5)/4096+(37*(x-1)^4)/1024+(-3*(x-1)^3)/64+(x-1)^2/16;
Siehe auch:
InverseTaylor , Taylor , BigOh .


BigOh -- alle Terme ab einer best. Ordnung aus einem Polynom entfernen

mathematische Standardbibliothek
Funktionsaufruf:
BigOh(poly, var, degree)
Parameter:
poly - ein univariates Polynom (Polynom in einer Variablen)
var - eine freie Variable
degree - eine positive ganze Zahl
Beschreibung:
BigOh entfernt alle Terme vom Grad "degree" oder höher aus dem gegebenen Polynom "poly" in der Variablen "var".
Beispiele:
In> BigOh(1+x+x^2+x^3,x,2)
Out> x+1;
Siehe auch:
Taylor , InverseTaylor .


Newton -- Nullstellenbestimmung mit dem Newtonverfahren

mathematische Standardbibliothek
Funktionsaufruf:
Newton(expr, var, initial, accuracy)
Parameter:
expr - Term einer Funktion, für die die Nullstelle zu bestimmen ist
var - Funktionsvariable
initial - Startwert
accuracy - Mindestgenauigkeit der Näherung
Beschreibung:
Die Funktion berechnet mit Hilfe des Newtonverfahrens einen Näherungswert für die gesuchte Nullstelle.
Beispiele:
In> Newton(Sin(x),x,3,0.0001)
Out> 3.1415926535;
siehe auch:
Solve .


D -- Differentiation

mathematische Standardbibliothek
Funktionsaufruf:
D(var) expr
D(list) expr
D(var, n) expr
Parameter:
var - Variable nach der differenziert wird
list - eine Liste von Variablen
expr - Term der zu differenzierenden Funktion
n - Ordnung der Ableitung
Beschreibung:
Alle Funktionen berechnen analytisch die Ableitung des angegebenen Funktionsterms "expr".
Mit "D(var, n)expression" wird die n-te Ableitung bestimmt.

Ist "var" oder "expr" eine Liste, dann wird die Funktion auf jedes Listenelement angewendet. Die Ergebnisse werden als Liste zurückgegeben. Sind "var" und "expr" Listen gleicher Länge, dann wird das 1. Element in "expr" nach der 1. Variablen in "var" abgeleitet, das 2. Element in "expr" nach der 2. Variablen usw.
Beispiele:
In> D(x)Sin(x*y)
Out> y*Cos(x*y);

In> D({x,y,z})Sin(x*y)
Out> {y*Cos(x*y),x*Cos(x*y),0};

In> D(x,2)Sin(x*y)
Out> -Sin(x*y)*y^2;

In> D(x){Sin(x),Cos(x)}
Out> {Cos(x),-Sin(x)};
Siehe auch:
Integrate , Taylor , Diverge , Curl .


Curl -- Rotation eines Vektorfeldes

mathematische Standardbibliothek
Funktionsaufruf:
Diverge(vector, basis)
Curl(vector, basis)
Parameter:
vector - ein Vektor
basis - eine Liste von Variablen
Beschreibung:
Curl(vector, basis) berechnet die Rotation des Vektorfeldes "vector".
"vector" und "basis" müssen Listen mit jeweils 3 Elementen sein.
Beispiele:
In> Diverge({x*y,x*y,x*y},{x,y,z})
Out> {y,x,0};

In> Curl({x*y,x*y,x*y},{x,y,z})
Out> {x,-y,y-x};
Siehe auch:
D , Diverge .


Diverge -- Divergenz eines Vektorfeldes

mathematische Standardbibliothek
Funktionsaufruf:
Diverge(vector, basis)
Parameter:
vector - ein Vektor
basis - eine Liste von Variablen
Beschreibung:
Diverge(vector, basis) berechnet die Divergenz des Vektorfeldes "vector".
"vector" und "basis" müssen Listen gleicher Länge sein.
Beispiele:
In> Diverge({x*y,x*y,x*y},{x,y,z})
Out> y+x;
siehe auch:
D , Curl .


Integrate -- Integration

mathematische Standardbibliothek
Funktionsaufruf:
Integrate(var, from, to) expr
Integrate(var) expr
Parameter:
var - Integrationsvariable
from - untere Integrationsgrenze
to - obere Integrationsgrenze
expr - Term der zu integrierenden Funktion
Beschreibung:
Diese Funktion berechnet das bestimmte Integral in den angegebenen Grenzen oder das unbestimmte Integral.
Die einfachen Integrationsregeln sind implementiert. Integriert werden können transzendente Funktionen, Polynome, Produkte von transzendenten Funktionen und Polynomen und gebrochen rationale Funktionen.
Beispiele:
In> Integrate(x,a,b)Cos(x)
Out> Sin(b)-Sin(a);

In> Integrate(x)Cos(x)
Out> Sin(x)+C9;
Siehe auch:
D , UniqueConstant .


Simplify -- einen Ausdruck vereinfachen

Interne Funktion
mathematische Standardbibliothek
Funktionsaufruf:
Simplify(expression)
Parameter:
expression - ein Term
Beschreibung:
Simplify versucht den angegebenen Term soweit wie möglich zu vereinfachen.
Beispiele:
In> a*b*a^2/b-a^3
Out> (b*a^3)/b-a^3;

In> Simplify(a*b*a^2/b-a^3)
Out> 0;
Siehe auch:
TrigSimpCombine , RadSimp .


RadSimp -- einen Ausdruck mit verschachtelten Wurzelausdrücken vereinfachen

mathematische Standardbibliothek
Funktionsaufruf:
RadSimp(expr)
Parameter:
expr - ein Term mit verschachtelten Wurzelausdrücken
Beschreibung:
RadSimp versucht den Term so zu vereinfachen, dass keine verschachtelten Wurzelterme mehr auftreten. Das Ergebnis ist dann von der Form
Sqrt(e1) + Sqrt(e2) + ... .

Der Algorithmus geht so vor, dass alle möglichen Kombination von "e1", "e2" usw. ausprobiert werden. Für jede Kombination wird ein Näherungswert berechnet und mit dem Näherungswert von "expr" verglichen. Sind die Näherungswerte gleich (bis zu einer best. Genauigkeit), dann wird die zugehörige Kombination als Ergebnis zurückgegeben, ansonsten der ursprüngliche Ausdruck.

Aufgrund der numerischen Berechnung ist es möglich, dass das Ergebnis von RadSimp nicht exakt gleich dem ursprünglichen Term "expr" ist.
Die Anzahl der möglichen Kombinationen wächst mit der numerischen Größe von "expr" an, was zu sehr zeitaufwendigen Berechnungen führen kann.
Beispiele:
In> RadSimp(Sqrt(9+4*Sqrt(2)))
Out> 1+Sqrt(8);

In> RadSimp(Sqrt(5+2*Sqrt(6))+Sqrt(5-2*Sqrt(6)))
Out> Sqrt(12);

In> RadSimp(Sqrt(14+3*Sqrt(3+2*Sqrt(5-12*Sqrt(3-2*Sqrt(2)))))) 
Out> 3+Sqrt(2);

Im folgenden Beispiel wird aufgrund der numerischen Berechnung ein falsches Ergebnis geliefert:

In> RadSimp(Sqrt(1+10^(-6)))
Out> 1;
Siehe auch:
Simplify , N .


Rationalize -- Umwandlung einer Dezimalzahl in einen Bruch

mathematische Standardbibliothek
Funktionsaufruf:
Rationalize(expr)
Parameter:
expr - ein Term mit Fließkommazahlen
Beschreibung:
Rationalize wandelt alle im Term vorkommenden Fließkommazahlen in Bruchzahlen der Form p/q um. Diese Funktion wird angewendet, wenn die Berechnung eines Terms mit Fließkommazahlen instabil ist. Die Umwandlung in Bruchzahlen erzwingt die Berechnung mit unendlicher Genauigkeit.
Beispiele:
In> {1.2,3.123,4.5}
Out> {1.2,3.123,4.5};

In> Rationalize(%)
Out> {6/5,3123/1000,9/2};
See Also:
IsRational .


Solve -- Lösung einer Gleichung bzw. eines Gleichungssystems

Interne Funktion
mathematische Standardbibliothek
Funktionsaufruf:
Solve(eq, var)
Solve(eqlist, varlist)
Parameter:
eq - eine Gleichung
var - eine Variable
eqlist - eine Liste von Gleichungen
varlist - eine Liste von Variablen
Beschreibung:
Solve versucht die Gleichung bzw. das Gleichungssystem zu lösen. Das Verfahren löst alle linearen Gleichungen und eine Vielzahl einfacher nichtlinearer Gleichungen.

Der erste Funktionsaufruf löst die Gleichung "eq" in der Variablen "var". Die Gleichung wird mit Hilfe des == Operators formuliert. Der Wert von "var", der die Gleichung erfüllt, wird zurückgegeben.
Es wird nur eine Lösung bestimmt.

Gleichungssysteme werden mit dem zweiten Funktionsaufruf gelöst. Das System der in "eqlist" enthaltenen Gleichungen wird für die in "varlist" enthaltenen Variablen gelöst. Das Ergebnis ist eine Liste der Lösungen.
Beispiele:
In> Solve(a+x*y==z,x)
Out> (z-a)/y;

In> Solve({a*x+y==0,x+z==0},{x,y})
Out> {{-z,z*a}};

Ein mit Solve nicht lösbares Beispiel:

In> Solve({x^2-x == y^2-y, x^2-x == y^3+y}, {x,y});
Out> {};
Siehe auch:
SuchThat , Eliminate , PSolve , == .


SuchThat -- einen Wert so bestimmen, dass ein Ausdruck Null wird

mathematische Standardbibliothek
Funktionsaufruf:
SuchThat(expression,variable)
Parameter:
expr - ein Term
var - ein Teilterm
Beschreibung:
SuchThat(expr, var) versucht den Teilterm "var" so zu bestimmen, dass die Gleichung expr=0 erfüllt ist.
Beispiele:
In> SuchThat(a+b*x,x)
Out> (-a)/b;

In> SuchThat(Cos(a)+Cos(b)^2,Cos(b))
Out> (-Cos(a))^(1/2);

In> Expand(a*x+b*x+c,x)
Out> c+(a+b)*x;

In> SuchThat(%,x)
Out> (-c)/(a+b);
Siehe auch:
Solve , Subst , Simplify .


Eliminate -- substituieren und vereinfachen

mathematische Standardbibliothek
Funktionsaufruf:
Eliminate(var, value, expr)
Parameter:
var - ein Teilterm
value - ein Teilterm
expr - ein Term
Beschreibung:
Ersetzt im Term expr jeden vorkommenden Teilterm var durch den Teilterm value. Auf das Ergebnis wird die Funktion Simplify angewendet.
Beispiele:
In> Subst(Cos(b), c) (Sin(a)+Cos(b)^2/c)
Out> Sin(a)+c^2/c;

In> Eliminate(Cos(b), c, Sin(a)+Cos(b)^2/c)
Out> Sin(a)+c;
Siehe auch:
SuchThat , Subst , Simplify .


PSolve -- Nullstellen eines Polynoms berechnen

mathematische Standardbibliothek
Funktionsaufruf:
PSolve(poly, var)
Parameter:
poly - ein Polynom
var - Variable
Beschreibung:
PSolve berechnet die Nullstellen des Polynoms expr. Polynome bis 4. Grades können gelöst werden. Das Ergebnis ist eine Liste mit den Nullstellen.
Beispiele:
In> PSolve(b*x+a,x)
Out> -a/b;

In> PSolve(c*x^2+b*x+a,x)
Out> {(Sqrt(b^2-4*c*a)-b)/(2*c),(-(b+Sqrt(b^2-4*c*a)))/(2*c)};
Siehe auch:
Solve , Factor .


Pi -- Näherungswert für pi

Interne Funktion
Funktionsaufruf:
Pi()
Parameter:
keine
Beschreibung:
Das Ergebnis der Funktion Pi() ist der Wert der Kreiszahl in der voreingestellten Genauigkeit. Diese Funktion wird in der Regel nicht direkt aufgerufen. In Berechnungen sollte immer die Konstante Pi verwendet werden, da nur dann die Vereinfachungsregeln funktionieren können. Die Funktion N ersetzt am Schluss einer Berechnung die Konstante Pi durch den Funktionswert von Pi().
Beispiele:
In> Pi()
Out> 3.14159265358979323846;

In> Precision(40)
Out> True;

In> Pi()
Out> 3.1415926535897932384626433832795028841971;
Siehe auch:
N , Pi , Precision .


Random -- Zufallszahl zwischen 0 und 1

mathematische Standardbibliothek
Funktionsaufruf:
Random()
Parameter:
keine
Beschreibung:
Random() liefert eine Zufallszahl aus dem Intervall [0 ; 1].
siehe auch:
RandomInteger , RandomPoly .


VarList -- Liste aller in einem Term enthaltenen Variablen

mathematische Standardbibliothek
Funktionsaufruf:
VarList(expression)
Parameter:
expr - ein Term
Beschreibung:
Das Ergebnis von VarList ist eine Liste mit allen im Term vorkommenden Variablen.
Beispiele:
In> VarList(Sin(x))
Out> {x};

In> VarList(x+a*y)
Out> {x,a,y};
siehe auch:
IsFreeOf , IsVariable .


Limit -- Grenzwert eines Ausdrucks

mathematische Standardbibliothek
Funktionsaufruf:
Limit(var, val) expr
Limit(var, val, dir) expr
Parameter:
var - die Funktionsvariable
val - eine Zahl
dir - Richtung der Annäherung (Left oder Right)
expr - ein Funktionsterm
Beschreibung:
Limit berechnet den Grenzwert der Funktion "expression" bei Annäherung der Variablen "var" an den Wert "val". Für "val" sind auch die Werte Infinity und -Infinity erlaubt.

Über den Parameter "dir" kann die Richtung der Annäherung vorgegeben werden. Erlaubt sind die Werte Left oder Right.

Beispiele:
In> Limit(x,0) Sin(x)/x
Out> 1;

In> Limit(x,0) (Sin(x)-Tan(x))/(x^3)
Out> -1/2;

In> Limit(x,0) 1/x
Out> Undefined;

In> Limit(x,0,Left) 1/x
Out> -Infinity;

In> Limit(x,0,Right) 1/x
Out> Infinity;


TrigSimpCombine -- Produkte trig. Funktionen in Summen umformen

mathematische Standardbibliothek
Funktionsaufruf:
TrigSimpCombine(expr)
Parameter:
expr - ein Term mit trigonometrischen Funktionen
Beschreibung:
Mit dieser Funktion werden Produkte trigonometrischer Funktionen in Summen umgeformt:
Cos(...)*Sin(...) -> Cos(...)+Sin(...)

Das Ergebnis der Umformung wird soweit wie möglich vereinfacht.

Diese Funktion wird z.B. bei Integrate verwendet, um den Integranden in eine leichter integrierbare Form zu bringen.

Beispiele:
In> PrettyPrinter("PrettyForm");

True

Out>

In> TrigSimpCombine(Cos(a)^2+Sin(a)^2)

1

Out>

In> TrigSimpCombine(Cos(a)^2-Sin(a)^2)

Cos( 2 * a )

Out>

In> TrigSimpCombine(Cos(a)^2*Sin(b))

Sin( b )   Sin( -2 * a + b )   Sin( -2 * a - b )
-------- + ----------------- - -----------------
   2               4                   4        

Out> 
Siehe auch:
Simplify , Integrate , Expand , Sin, Cos, Tan .


LagrangeInterpolant -- Lagrange-Interpolation

mathematische Standardbibliothek
Funktionsaufruf:
LagrangeInterpolant(xlist, ylist, var)
Parameter:
xlist - eine Liste von Zahlen
ylist - eine Liste von Zahlen
var - die Variable des resultierenden Polynoms
Beschreibung:
Die durch xlist und ylist angegeben Zahlen werden als Koordinaten einer Menge von Punkten interpretiert. Das Interpolationsverfahren nach Lagrange berechnet mit Hilfe dieser Koordinaten ein Polynom, das alle Punkte enthält.
Beispiele:
In> LagrangeInterpolant({x1,x2,x3},{y1,y2,y3},x)

y1 * ( x - x2 ) * ( x - x3 )   y2 * ( x - x1 ) * ( x - x3 ) 
---------------------------- + ---------------------------- 
 ( x1 - x2 ) * ( x1 - x3 )      ( x2 - x1 ) * ( x2 - x3 )   

  y3 * ( x - x1 ) * ( x - x2 )
+ ----------------------------
   ( x3 - x1 ) * ( x3 - x2 )  

Out> 
siehe auch:
Subst .


Fibonacci -- Fibonacci-Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
Fibonacci(n)
Parameter:
n - eine natürliche Zahl
Beschreibung:
Das Ergebnis von Fibonacci(n) ist das n-te Element der Folge von Fibonacci-Zahlen.
Beispiele:
In> Fibonacci(4)
Out> 3;

In> Fibonacci(8)
Out> 21;