Yacas Funktionsreferenz

DefaultDirectory , PrettyPrinter , Help , HistorySize .

Startkonfiguration

Yacas erlaubt das Speichern persönlicher Einstellungen in der Datei ~/.yacasrc. Mit den folgenden Funktionen lässt sich die Arbeitsweise von Yacas beeinflussen:

DefaultDirectory Verzeichnis zum Suchpfad für Yacas Skripte hinzufügen
PrettyPrinter Funktion für die formatierte Ausgabe setzen
Help Hilfefunktion aufrufen
HistorySize Größe der history-Datei setzen


DefaultDirectory -- Verzeichnis zum Suchpfad für Yacas Skripte hinzufügen

interne Funktion
Funktionsaufruf:
DefaultDirectory(path)
Parameter:
path - vollständiger Pfad zum Yacas Arbeitsverzeichnis
Beschreibung:
Das in "path" angegebene Verzeichnis wird dem Suchpfad für Yacas Skriptdateien hinzugefügt. Zunächst versucht Yacas zu ladende Dateien im aktuellen Arbeitsverzeichnis zu finden. Gelingt das nicht, sucht Yacas alle im Suchpfad aufgelisteten Verzeichnisse ab. Der jeweilige Pfad wird dem Dateinamen vorangestellt. Der Pfad muss daher mit einem "/" enden.
Beispiele:
In> DefaultDirectory("/home/user/myscripts/");
Out> True;
Siehe auch:
Load , Use , DefLoad , FindFile .


PrettyPrinter -- Funktion für die formatierte Ausgabe setzen

mathematische Standardbibliothek
Funktionsaufruf:
PrettyPrinter(printer)
Parameter:
printer - Der Name einer Funktion, die mathematische Ausdrücke formatiert ausgibt.
Beschreibung:
Mit PrettyPrinter(printer) wird eine Funktion für die formatierte Ausgabe mathematischer Ausdrücke festgelegt.
Mit PrettyPrinter() wird die interne Ausgabefunktion ausgewählt.
Beispiele:
In> Taylor(x,0,5)Sin(x)
Out> x-x^3/6+x^5/120;
In> PrettyPrinter("PrettyForm");

True

Out>
In> Taylor(x,0,5)Sin(x)

     3    5
    x    x
x - -- + ---
    6    120

Out>
In> PrettyPrinter();
Out> True;
In> Taylor(x,0,5)Sin(x)
Out> x-x^3/6+x^5/120;
Siehe auch:
PrettyForm , Write .


Help -- Hilfefunktion aufrufen

mathematische Standardbibliothek
Funktionsaufruf:
Help()
Help(function)
Parameter:
function - Der Name einer Funktion, für die ein Hilfetext ausgegeben werden soll.
Beschreibung:
Die eingebaute Hilfefunktion wird durch ?function bzw, ?? aktiviert. Dazu wird intern die Funktion Help(function) bzw. Help() aufgerufen. Die Hilfedateien befinden sich im Unterverzeichnis yacas/documentation/, die mit der Funktion FindFile durchsucht werden. Als Browser ist lynx voreingestellt.
Beispiele:
Folgende Eingaben sind notwendig, wenn Netscape als Browser verwendet werden soll:
Help(_f) <-- SystemCall("netscape ":FindFile("documentation/ref.html"):"#":f);
Help() := SystemCall("netscape ":FindFile("documentation/books.html"));
Siehe auch:
SystemCall , FindFile .


HistorySize -- Größe der history-Datei setzen

interne Funktion
Funktionsaufruf:
HistorySize(n)
Parameter:
n - Anzahl der in der history-Datei zu speichernden Zeilen
Beschreibung:
Beim Beenden speichert Yacas die 50 zuletzt eingegebenen Befehle in der Datei ~/.yacas_history. Die voreingestellte Anzahl kann mit dieser Funktion verändert werden. Durch Angabe von n=-1 werden alle Befehle gespeichert.
Beispiele:
In> HistorySize(200)
Out> True;
In> quit
Siehe auch:


+, -, *, /, ^ .

Arithmetik

+, -, *, /, ^ Rechenoperatoren


+, -, *, /, ^ -- Rechenoperatoren

mathematische Standardbibliothek
Funktionsaufruf:
x+y (Hierarchieebene 6)
+x
x-y (Hierarchieebene 5)
-x
x*y (Hierarchieebene 3)
x/y (Hierarchieebene 3)
x^y (Hierarchieebene 2)
Parameter:
x und y - Objekte, für die arithmetische Operationen definiert sind.
Beschreibung:
Dies sind die grundlegenden Rechenoperatoren. Sie können auf ganze Zahlen, rationale Zahlen, komplexe Zahlen, Vektoren, Matrizen und Listen angewendet werden.
Diese Operatoren sind in der mathematischen Standardbibliothek implementiert (im Gegensatz zu internen Funktionen), so dass sie durch den Anwender erweiterbar sind.
Beispiele:
In> 2+3
Out> 5;

In> 2*3
Out> 6;


Div, Mod , Gcd , Lcm , <<, >> , FromBase, ToBase , Precision , GetPrecision , N , Rationalize , IsPrime , IsPrimePower , Factors , Factor , PAdicExpand , ContFrac , Decimal , TruncRadian , Floor , Ceil , Round , Pslq .

Weitere Operationen mit Zahlen

Zusätzlich zu den im vorigen Abschnitt beschriebenen Grundrechenarten lassen sich die folgenden Funktionen auf Zahlen anwenden. Viele dieser Funktionen lassen sich auch auf Polynome anwenden.

Div, Mod Division mit Rest
Gcd größter gemeinsamer Teiler
Lcm kleinstes gemeinsames Vielfaches
<<, >> Schiebeoperatoren
FromBase, ToBase Umrechnung zwischen unterschiedlichen Stellenwertsystemen
Precision Rechengenauigkeit einstellen
GetPrecision eingestellte Rechengenauigkeit ermitteln
N numerischen Näherungswert berechnen
Rationalize Umwandlung von Dezimalzahlen in Brüche
IsPrime testen, ob das Argument eine Primzahl ist
IsPrimePower testen, ob das Argument eine Primzahlpotenz ist
Factors Primfaktorzerlegung
Factor Primfaktorzerlegung mit formatierter Ausgabe
PAdicExpand p-adische Erweiterung
ContFrac Umwandlung in einen Kettenbruch
Decimal Umwandlung eines Bruches in die vollständige Dezimaldarstellung
TruncRadian Umwandlung ins Bogenmaß modulo 2*Pi
Floor eine Zahl abrunden
Ceil eine Zahl aufrunden
Round eine Zahl zur nächsten ganzen Zahl runden
Pslq ganzzahlige Relationen zwischen Zahlen suchen


Div, Mod -- Division mit Rest

mathematische Standardbibliothek
Funktionsaufruf:
Div(x,y)
Mod(x,y)
Parameter:
x und y - ganze Zahlen
Beschreibung:
Die Funktion Div führt eine Integerdivision durch, Mod berechnet den Rest.
Div und Mod sind auch für Polynome definiert.
Beispiele:
In> Div(5,3)
Out> 1;
In> Mod(5,3)
Out> 2;
Siehe auch:
Gcd , Lcm .


Gcd -- größter gemeinsamer Teiler

mathematische Standardbibliothek
Funktionsaufruf:
Gcd(n,m)
Gcd(list)
Parameter:
n,m - ganze Zahlen oder univariate Polynome (Polynome mit einer Variablen)
list - eine Liste von ganzen Zahlen oder univariaten Polynomen
Beschreibung:
Die Funktion Gcd(n,m) berechnet den größten gemeinsamen Teiler (ggT) von n und m. Der ggT ist die größte Zahl, die gleichzeitig Teiler von n und von m ist.
Die Bibliotheksfunktion ruft die interne Funktion MathGcd auf, die den ggT mit Hilfe des binären Eulerschen Algorithmus berechnet:

Prozedur zur Berechnung von Gcd(n,m)

1) if n = m then return n
2) if both n and m are even then return 2*Gcd(n/2,m/2)
3) if exactly one of n or m (say n) is even then return Gcd(n/2,m)
4) if both n and m are odd and, say, n>m then return Gcd( (n-m)/2,m)

Dies ist ein sehr schneller Algorithmus auf Rechnern mit effizienten Schiebeoperationen.
Gcd(list), wobei list eine beliebig lange Liste ganzer Zahlen ist, berechnet den ggT aller Zahlen der Liste. Gcd nutzt dabei folgenden Zusammenhang:

Gcd({a,b,c}) = Gcd(Gcd(a,b),c)
Beispiele:
In> Gcd(55,10)
Out> 5;
In> Gcd({60,24,120})
Out> 12;
Siehe auch:
Lcm .


Lcm -- kleinstes gemeinsames Vielfaches

mathematische Standardbibliothek
Funktionsaufruf:
Lcm(n,m)
Parameter:
n,m - ganze Zahlen
Beschreibung:
Die Funktion Lcm(n,m) berechnet das kleinste gemeinsame Vielfache (kgV) von n und m. Das kgV ist die kleinste Zahl, die gleichzeitig Vielfaches von n und von m ist. Das kgV wird mit folgender Gleichung berechnet:

Lcm(n,m) = Div(n*m,Gcd(n,m))
Da Div und Gcd auch für Polynome definiert sind, gilt dies auch für die Funktion Lcm.
Beispiele:
In> Lcm(60,24)
Out> 120;
Siehe auch:
Gcd .


<< und >> -- Schiebeoperatoren

mathematische Standardbibliothek
Funktionsaufruf:
n<<m
n>>m
Parameter:
n,m - ganze Zahlen
Beschreibung:
Diese Operatoren verschieben ganze Zahlen nach links bzw. nach rechts. Sie entsprechen den C-Schiebeoperatoren. Die Schiebeoperatoren erhalten das Vorzeichen, entsprechen also einer Multiplikation bzw. Division mit Zweierpotenzen.
Beispiele:
Beispiele:
1<<10; ergibt 1024
-1024>>10; ergibt -1


FromBase, ToBase -- Umrechnung zwischen unterschiedlichen Stellenwertsystemen

Interne Funktion
Funktionsaufruf:
FromBase(base,number)
ToBase(base,number)
Parameter:
base - Basis des Stellenwertsystems
number - Zahl, die umgewandelt werden soll
Beschreibung:
Umwandlung von Zahlen ins bzw. aus dem Zehnersystem.
Beispiele:
In> FromBase(2,111111)
Out> 63;
In> ToBase(16,255)
Out> ff;
Siehe auch:
PAdicExpand


Precision -- Rechengenauigkeit einstellen

Interne Funktion
Funktionsaufruf:
Precision(n)
Parameter:
n - Anzahl der Nachkommastellen im Zehnersystem
Beschreibung:
Die Funktion setzt die Anzahl der Nachkommastellen. Alle nachfolgenden Rechenoperationen arbeiten mit der eingestellten Genauigkeit.
Beispiele:
In> Precision(10)
Out> True;
In> N(Sin(1))
Out> 0.8414709848;
In> Precision(20)
Out> True;
In> N(Sin(1))
Out> 0.84147098480789650665;
In> GetPrecision()
Out> 20;
Siehe auch:
GetPrecision , N .


GetPrecision -- eingestellte Rechengenauigkeit ermitteln

interne Funktion
Funktionsaufruf:
GetPrecision()
Parameter:
keine
Beschreibung:
Das Ergebnis dieser Funktion ist die mit Precision eingestellte Rechengenauigkeit.
Beispiele:
In> GetPrecision();
Out> 10;
In> Precision(20);
Out> True;
In> GetPrecision();
Out> 20;
siehe auch:
Precision , N .


N -- numerischen Näherungswert berechnen

mathematische Standardbibliothek
Funktionsaufruf:
N(expr)
N(expr, prec)
Parameter:
expr - zu berechnender Ausdruck
prec - Anzahl der Nachkommastellen
Beschreibung:
Numerische Werte verbleiben wenn möglich im ursprünglichen Format, z.B. bei Divisionen oder bei triginometrischen Funktionen. Mit N wird die Umwandlung in eine Fließkommazahl erzwungen, soweit dies möglich ist. Das Ergebnis wird mit der voreingestellten Genauigkeit oder mit der im Argument angegebenen Genauigkeit berechnet.
Beispiele:
In> 1/2
Out> 1/2;
In> N(1/2)
Out> 0.5;
In> Sin(1)
Out> Sin(1);
In> N(Sin(1),10)
Out> 0.8414709848;
In> Pi
Out> Pi;
In> N(Pi,20)
Out> 3.14159265358979323846;
Siehe auch:
Precision , GetPrecision , Pi .


Rationalize -- Umwandlung von Dezimalzahlen in Brüche

mathematische Standardbibliothek
Funktionsaufruf:
Rationalize(expr)
Parameter:
expr - umzuwandelnder Term
Beschreibung:
Die Funktion Rationalize wandelt alle im Term vorkommenden Fließkommazahlen in Bruchzahlen der Form p/q um.
Beispiele:
In> {1.2,3.123,4.5}
Out> {1.2,3.123,4.5};
In> Rationalize(%)
Out> {6/5,3123/1000,9/2};

In> Sin(1.234)
Out> Sin(1.234);
In> Rationalize(%)
Out> Sin(617/500);
Siehe auch:
IsRational .


IsPrime -- testen, ob das Argument eine Primzahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsPrime(n)
Parameter:
n - eine natürliche Zahl
Beschreibung:
Das Ergebnis von IsPrime(n) ist True, falls n eine Primzahl ist, andernfalls False.
Beispiele:
In> IsPrime(1)
Out> False;
In> IsPrime(2)
Out> True;
In> IsPrime(10)
Out> False;
In> IsPrime(23)
Out> True;
In> Select("IsPrime", 1 .. 100)
Out> {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
siehe auch:
IsPrimePower , Factors .


IsPrimePower -- testen, ob das Argument eine Primzahlpotenz ist

mathematische Standardbibliothek
Funktionsaufruf:
IsPrime(n)
Parameter:
n - eine natürliche Zahl
Beschreibung:
Das Ergebnis ist True, falls es eine Primzahl p gibt, so dass p^m = n ist.
Beispiele:
In> IsPrimePower(9)
Out> True;
In> IsPrimePower(10)
Out> False;
In> Select("IsPrimePower", 1 .. 50)
Out> {2,3,4,5,7,8,9,11,13,16,17,19,23,25,27,29,31,32,37,41,43,47,49};
siehe auch:
IsPrime , Factors .


Factors -- Primfaktorzerlegung

mathematische Standardbibliothek
Funktionsaufruf:
Factors(x)
Parameter:
x - eine ganze Zahl oder ein univariates Polynom (Polynom in einer Variablen)
Beschreibung:
Die Funktion Factors zerlegt eine ganze Zahl oder ein univariates Polynom in Primfaktoren oder irreduzible Polynome.

Das Ergebnis ist eine Liste der Form {p,n}, wobei jedes p^n ein Teiler von x ist.

Die Funktion Factor gibt das Ergebnis von Factors in einem übersichtlicheren Format aus.
Beispiele:
In> Factors(24);
Out> {{2,3},{3,1}};
In> Factors(2*x^3 + 3*x^2 - 1);
Out> {{2,1},{x+1,2},{x-1/2,1}};
Siehe auch:
Factor , IsPrime .


Factor -- Primfaktorzerlegung mit formatierter Ausgabe

mathematische Standardbibliothek
Funktionsaufruf:
Factor(x)
Parameter:
x - eine ganze Zahl oder ein univariates Polynom (Polynom in einer Variablen)
Beschreibung:
Die Funktion Factor zerlegt eine ganze Zahl oder ein univariates Polynom in Primfaktoren oder irreduzible Polynome und gibt das Ergebnis übersichtlich formatiert aus.
Beispiele:
In> PrettyForm(Factor(24));

 3
2  * 3

Out> True;
In> PrettyForm(Factor(2*x^3 + 3*x^2 - 1));

             2   /     1 \
2 * ( x + 1 )  * | x - - |
                 \     2 /

Out> True;
Siehe auch:
Factors , IsPrime , PrettyForm .


PAdicExpand -- p-adische Erweiterung

mathematische Standardbibliothek
Funktionsaufruf:
PAdicExpand(n, p)
Parameter:
n - eine Zahl oder ein Polynom
p - die Basis der Erweiterung
Beschreibung:
Die Funktion wandelt die Zahl (bzw. das Polynom) "n" in die p-adische Form um:

n = a0 +a1*p +a2*p^2+...

Beispiel:

In> PrettyForm(PAdicExpand(1234,10))

                   2     3
4 + 3 * 10 + 2 * 10  + 10

Out> True;

In> PrettyForm(PAdicExpand(x^3, x-1));

                             2            3
3 * ( x - 1 ) + 3 * ( x - 1 )  + ( x - 1 )  + 1

Out> True;

See Also:
Mod , ContFrac , FromBase, ToBase .


ContFrac -- Umwandlung in einen Kettenbruch

mathematische Standardbibliothek
Funktionsaufruf:
ContFrac(x) oder ContFrac(x,maxdepth)
Parameter:
x - umzuwandelnder Ausdruck
maxdepth - maximale Tiefe
Beschreibung:
Die Funktion ContFrac wandelt eine Fließkommazahl oder ein Polynom um in einen Kettenbruch. Dies ist insbesondere bei Polynomen sinnvoll, da langsam konvergierende Reihenentwicklungen häufig in der Kettenbruchdarstellung sehr viel schneller konvergieren.
Beispiele:
In> PrettyForm(ContFrac(N(Pi)))

             1
--------------------------- + 3
           1
----------------------- + 7
        1
------------------ + 15
      1
-------------- + 1
   1
-------- + 292
rest + 1

Out> True;

In> PrettyForm(ContFrac(x^2+x+1, 3))

       x
---------------- + 1
         x
1 - ------------
       x
    -------- + 1
    rest + 1

Out> True;
Siehe auch:
PAdicExpand , N .


Decimal -- Umwandlung eines Bruches in die vollständige Dezimaldarstellung

mathematische Standardbibliothek
Funktionsaufruf:
Decimal(frac)
Parameter:
frac - eine Bruchzahl
Beschreibung:
Die Funktion Decimal wandelt eine Bruchzahl in die vollständige Dezimaldarstellung um. Das Ergebnis ist eine Liste, deren erstes Element der ganzzahlige Anteil ist und deren letztes Element die sich periodisch wiederholende Ziffernfolge ist. Die Listenelemente dazwischen sind die Ziffern vor Beginn der Periode bei gemischt periodischen Dezimalbrüchen.
Beispiele:
In> Decimal(1/22)
Out> {0,0,{4,5}};
In> N(1/22,30)
Out> 0.045454545454545454545454545454;
siehe auch:
N .


TruncRadian -- Umwandlung ins Bogenmaß modulo 2*Pi

mathematische Standardbibliothek
Funktionsaufruf:
TruncRadian(r)
Parameter:
r - ein Winkel im Bogenmaß
Beschreibung:
Die Funktion TruncRadian berechnet r mod 2*Pi und liefert ein Ergebnis zwischen 0 und 2*Pi. Diese Funktion wird in den trigonometrischen Funktionen vor der eigentlichen Berechnung angewendet und reduziert bei großen Winkeln deutlich die Rechenzeit.

Die Funktion arbeitet nach folgender Formel:


             /   r    \
r - MathFloor| ------ | * 2 * Pi
             \ 2 * Pi /



r und 2*Pi gehen mit doppelter Genauigkeit in die Berechnung ein, so dass Rundungsfehler ausgeschlossen sind.
Beispiele:
In> 2*Pi()
Out> 6.283185307;
In> TruncRadian(6.28)
Out> 6.28;
In> TruncRadian(6.29)
Out> 0.0068146929;
Siehe auch:
Sin , Cos , Tan .


Floor -- eine Zahl abrunden

mathematische Standardbibliothek
Funktionsaufruf:
Floor(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Die Funktion Floor liefert als Ergebnis die nächst kleinere ganze Zahl.
Beispiele:
In> Floor(1.1)
Out> 1;
In> Floor(-1.1)
Out> -2;
Siehe auch:
Ceil , Round .


Ceil -- eine Zahl aufrunden

mathematische Standardbibliothek
Funktionsaufruf:
Ceil(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Die Funktion Ceil liefert als Ergebnis die nächst größere ganze Zahl.
Beispiele:
In> Ceil(1.1)
Out> 2;
In> Ceil(-1.1)
Out> -1;
Siehe auch:
Floor , Round .


Round -- eine Zahl zur nächsten ganzen Zahl runden

mathematische Standardbibliothek
Funktionsaufruf:
Round(x)
Parameter:
x - eine Fließkommazahl
Beschreibung:
Die Funktion Round rundet auf die nächste ganze Zahl.
Beispiele:
In> Round(1.49)
Out> 1;
In> Round(1.51)
Out> 2;
In> Round(-1.49)
Out> -1;
In> Round(-1.51)
Out> -2;

Siehe auch:
Floor , Ceil .


Pslq -- ganzzahlige Relationen zwischen Zahlen suchen

mathematische Standardbibliothek
Funktionsaufruf:
Pslq(xlist,precision)
Parameter:
xlist - eine Liste von Fließkommazahlen
precision - Rechengenauigkeit
Beschreibung:
Die Funktion Pslq berechnet zu einer Liste von Konstanten x Koeffizienten sol[i] so, dass sum(sol[i]*x[i], i=1..n) = 0 (mit n=Length(x)) ist.
Beispiele:
In> Pslq({ 2*Pi+3*Exp(1) , Pi , Exp(1) },20)
Out> {1,-2,-3};

Hinweis: In diesem Beispiel erkennt die Funktion richtig, dass
1* (2*Pi+3*E) -2*(Pi) - 3*(E) = 0
ist.
Siehe auch:
N .


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;


LeviCivita , Permutations , InProduct , CrossProduct , ZeroVector , BaseVector , Identity , ZeroMatrix , DiagonalMatrix , IsMatrix , Normalize , Transpose , Determinant , Trace , Inverse , Minor , CoFactor , SolveMatrix , CharacteristicEquation , EigenValues , EigenVectors , IsHermitean , IsUnitary .

Lineare Algebra

In diesem Kapitel werden die Befehle für die Lineare Algebra erläutert. Die Möglichkeiten umfassen Operationen mit Vektoren (repräsentiert durch Listen) und Matrizen (repräsentiert durch Listen von Listen.

LeviCivita der vollständig antisymmetrische Levi-Civita-Tensor
Permutations Permutationen einer Liste
InProduct Skalarprodukt von Vektoren
CrossProduct Kreuzprodukt von Vektoren
ZeroVector Nullvektor
BaseVector Basisvektor
Identity Einheitsmatrix
ZeroMatrix Nullmatrix
DiagonalMatrix Diagonalmatrix
IsMatrix testet, ob das Argument eine Matrix ist
Normalize Einheitsvektor
Transpose transponierte Matrix
Determinant Determinante einer Matrix
Trace Spur einer Matrix
Inverse Inverses einer Matrix
Minor Streichungsdeterminante
CoFactor Unterdeterminante
SolveMatrix Lösung eines linearen Gleichungssystems
CharacteristicEquation charakteristisches Polynom einer Matrix
EigenValues Eigenwerte einer Matrix
EigenVectors Eigenvectors of a matrix
IsHermitean testet, ob das Argument eine hermitesche Matrix ist
IsUnitary testet, ob das Argument eine unitäre Matrix ist


LeviCivita -- Der vollständig antisymmetrische Levi-Civita-Tensor

mathematische Standardbibliothek
Funktionsaufruf:
LeviCivita(list)
Parameter:
list - eine geordnete Liste natürlicher Zahlen
Beschreibung:
"LeviCivita" implementiert das Levi Civita Symbol der Tensorrechnung. {list} ist eine geordnete Liste natürlicher Zahlen. Das Ergebnis der Funktion ist +1, wenn die Liste in aufsteigender Ordnung sortiert ist, sonst -1. Angewendet auf die Liste {1,2,3,...} ergibt sich z.B. +1, werden 2 Elemente der Liste vertauscht (z.B. {2,1,3}) ergibt sich -1.
Beispiele:
In> LeviCivita({1,2,3})
Out> 1;

In> LeviCivita({2,1,3})
Out> -1;

In> LeviCivita({2,2,3})
Out> 0;
Siehe auch:
Permutations .


Permutations -- Permutationen einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
Permutations(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis von Permutations ist eine Liste aller Permutationen der ursprünglichen Liste.
Beispiele:
In> Permutations({a,b,c})
Out> {{a,b,c},{a,c,b},{c,a,b},{b,a,c},{b,c,a},{c,b,a}};
Siehe auch:
LeviCivita .


InProduct -- Skalarprodukt von Vektoren

mathematische Standardbibliothek
Funktionsaufruf:
InProduct(a,b)
a . b
Parameter:
a, b - Vektoren gleicher Länge
Beschreibung:
Berechnet das Skalarprodukt der Vektoren "a" und "b". Die Vektoren müssen die gleiche Länge haben.
Beispiele:
In> {a,b,c} . {d,e,f};
Out> a*d+b*e+c*f;
Siehe auch:
CrossProduct .


CrossProduct -- Kreuzprodukt von Vektoren

mathematische Standardbibliothek
Funktionsaufruf:
CrossProduct(a,b)
a X b
Parameter:
a, b - dreidimensionale Vektoren
Beschreibung:
Berechnet das Vektorprodukt (auch Kreuzprodukt genannt) der Vektoren "a" und "b". Das Vektorprodukt ist nur für dreidimensionale Vektoren definiert.
Beispiele:
In> {a,b,c} X {d,e,f};
Out> {b*f-c*e,c*d-a*f,a*e-b*d};
Siehe auch:
InProduct .


ZeroVector -- Nullvektor

mathematische Standardbibliothek
Funktionsaufruf:
ZeroVector(n)
Parameter:
n - Größe des Nullvektors
Beschreibung:
Das Ergebnis ist ein Nullvektor mit "n" Komponenten.
Beispiele:
In> ZeroVector(4)
Out> {0,0,0,0};
Siehe auch:
BaseVector , ZeroMatrix , IsZeroVector .


BaseVector -- Basisvektor

mathematische Standardbibliothek
Funktionsaufruf:
BaseVector(k, n)
Parameter:
k - Index des zu berechnenden Basisvektors
n - Länge des Vektors
Beschreibung:
Das Ergebnis ist der "k"-te Basisvektor mit der Länge "n". Dies ist ein Vektor mit "n" Komponenten, die alle den Wert 0 haben außer der "k"-ten Komponente, die den Wert 1 hat.
Beispiele:
In> BaseVector(2,4)
Out> {0,1,0,0};
Siehe auch:
ZeroVector , Identity .


Identity -- Einheitsmatrix

mathematische Standardbibliothek
Funktionsaufruf:
Identity(n)
Parameter:
n - Größe der Matrix
Beschreibung:
Das Ergebnis ist die Einheitsmatrix mit "n" Zeilen und "n" Spalten. Die Hauptdiagonale der Matrix besteht aus Einsen, alle anderen Element sind Nullen.
Beispiele:
In> Identity(3)
Out> {{1,0,0},{0,1,0},{0,0,1}};
Siehe auch:
BaseVector , ZeroMatrix , DiagonalMatrix .


ZeroMatrix -- Nullmatrix

mathematische Standardbibliothek
Funktionsaufruf:
ZeroMatrix(n, m)
Parameter:
n - Anzahl der Zeilen
m - Anzahl der Spalten
Beschreibung:
Das Ergebnis ist eine Matrix mit "n" Zeilen und "m" Spalten deren Elemente alle Nullen sind.
Beispiele:
In> ZeroMatrix(3,4)
Out> {{0,0,0,0},{0,0,0,0},{0,0,0,0}};
Siehe auch:
ZeroVector , Identity .


DiagonalMatrix -- Diagonalmatrix

mathematische Standardbibliothek
Funktionsaufruf:
DiagonalMatrix(d)
Parameter:
d - eine Liste von Werten
Beschreibung:
Das Ergebnis ist eine Diagonalmatrix deren Hauptdiagonale die in der Liste angegebenen Werte enthält. Alle übrigen Elemente sind Nullen.
Beispiele:
In> DiagonalMatrix(1 .. 4)
Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}};
Siehe auch:
Identity , ZeroMatrix .


IsMatrix -- testet, ob das Argument eine Matrix ist

mathematische Standardbibliothek
Funktionsaufruf:
IsMatrix(M)
Parameter:
M - ein mathematisches Objekt
Beschreibung:
Das Ergebnis ist True, wenn M eine Matrix ist, sonst False. M wird als Matrix interpretiert, wenn es eine Liste von Listen ist.
Beispiele:
In> IsMatrix(ZeroMatrix(3,4))
Out> True;

In> IsMatrix(ZeroVector(4))
Out> False;

In> IsMatrix(3)
Out> False;
Siehe auch:
IsVector .


Normalize -- Einheitsvektor

mathematische Standardbibliothek
Funktionsaufruf:
Normalize(v)
Parameter:
v - ein Vektor
Beschreibung:
Das Ergebnis ist der Einheitsvektor von v, d.h. ein Vektor gleicher Richtung mit Betrag 1.
Beispiele:
In> Normalize({3,4})
Out> {3/5,4/5};

In> % . %
Out> 1;
Siehe auch:
InProduct , CrossProduct .


Transpose -- Transponierte Matrix

mathematische Standardbibliothek
Funktionsaufruf:
Transpose(M)
Parameter:
M - eine Matrix
Beschreibung:
Das Ergebnis ist die Transponierte der Matrix M, die dadurch entsteht, dass Zeilen als Spalten geschrieben werden. Ist M eine quadratische Matrix, dann entsteht die Transponierte durch Spiegelung aller Komponenten an der Hauptdiagonalen.
Beispiele:
In> Transpose({{a,b}})
Out> {{a},{b}};


Determinant -- Determinante einer Matrix

mathematische Standardbibliothek
Funktionsaufruf:
Determinant(M)
Parameter:
M - eine Matrix
Beschreibung:
Berechnet die Determinante der Matrix M.
Beispiele:
In> DiagonalMatrix(1 .. 4)
Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}};

In> Determinant(%)
Out> 24;


Trace -- Spur einer Matrix

mathematische Standardbibliothek
Funktionsaufruf:
Trace(M)
Parameter:
M - eine Matrix
Beschreibung:
Das Ergebnis ist die Spur der Matrix M. Die Spur ist die Summe der Komponenten der Hauptdiagonalen.
Beispiele:
In> DiagonalMatrix(1 .. 4)
Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}};

In> Trace(%)
Out> 10;


Inverse -- Inverse Matrix

mathematische Standardbibliothek
Funktionsaufruf:
Inverse(M)
Parameter:
M - eine Matrix
Beschreibung:
Das Ergebnis ist die zu M inverse Matrix. Die Determinante von M darf nicht Null sein.
Beispiele:
In> DiagonalMatrix({a,b,c})
Out> {{a,0,0},{0,b,0},{0,0,c}};

In> Inverse(%)
Out> {{(b*c)/(a*b*c),0,0},{0,(a*c)/(a*b*c),0},{0,0,(a*b)/(a*b*c)}};

In> Simplify(%)
Out> {{1/a,0,0},{0,1/b,0},{0,0,1/c}};


Minor -- Streichungsdeterminante

mathematische Standardbibliothek
Funktionsaufruf:
Minor(M,i,j)
Parameter:
M - eine Matrix
i, j - natürliche Zahlen
Beschreibung:
Das Ergebnis ist die Streichungsdeterminante um die Komponente (i,j). Das ist die Determinante der Matrix, die durch Streichen der "i"-ten Zeile und "j"-ten Spalte entsteht.
Beispiele:
In> A := {{1,2,3}, {4,5,6}, {7,8,9}};
Out> {{1,2,3},{4,5,6},{7,8,9}};

In> PrettyForm(A);

/                    \
| ( 1 ) ( 2 ) ( 3 )  |
|                    |
| ( 4 ) ( 5 ) ( 6 )  |
|                    |
| ( 7 ) ( 8 ) ( 9 )  |
\                    /

Out> True;

In> Minor(A,1,2);
Out> -6;

In> Determinant({{2,3}, {8,9}});
Out> -6;
Siehe auch:
CoFactor , Determinant , Inverse .


CoFactor -- Unterdeterminante

mathematische Standardbibliothek
Funktionsaufruf:
CoFactor(M,i,j)
Parameter:
M - eine Matrix
i, j - natürliche Zahlen
Beschreibung:
Das Ergebnis ist die nach dem Element (i,j) entwickelte Unterdeterminante, die durch Multiplikation der Streichungsdeterminante mit dem Faktor (-1)^(i+j) entsteht.
Beispiele:
In> A := {{1,2,3}, {4,5,6}, {7,8,9}};
Out> {{1,2,3},{4,5,6},{7,8,9}};

In> PrettyForm(A);

/                    \
| ( 1 ) ( 2 ) ( 3 )  |
|                    |
| ( 4 ) ( 5 ) ( 6 )  |
|                    |
| ( 7 ) ( 8 ) ( 9 )  |
\                    /

Out> True;

In> CoFactor(A,1,2);
Out> 6;

In> Minor(A,1,2);
Out> -6;

In> Minor(A,1,2) * (-1)^(1+2);
Out> 6;
Siehe auch:
Minor , Determinant , Inverse .


SolveMatrix -- Lösung eines linearen Gleichungssystems

mathematische Standardbibliothek
Funktionsaufruf:
SolveMatrix(M,v)
Parameter:
M - eine Matrix
v - ein Vektor
Beschreibung:
SolveMatrix berechnet den Lösungsvektor x der Gleichung
"M x = v". Die Determinante von M darf nicht Null sein.
Beispiele:
In> A := {{1,2}, {3,4}};
Out> {{1,2},{3,4}};

In> v := {5,6};
Out> {5,6};

In> x := SolveMatrix(A, v);
Out> {-4,9/2};

In> A * x;
Out> {5,6};
Siehe auch:
Inverse , Solve , PSolve .


CharacteristicEquation -- charakteristisches Polynom einer Matrix

mathematische Standardbibliothek
Funktionsaufruf:
CharacteristicEquation(matrix,var)
Parameter:
matrix - eine Matrix
var - eine Variable
Beschreibung:
Berechnet das charakteristische Polynom der Matrix "matrix". Die Nullstellen des charakteristische Polynoms sind die Eigenwerte der Matrix.
Beispiele:
In> DiagonalMatrix({a,b,c})
Out> {{a,0,0},{0,b,0},{0,0,c}};

In> CharacteristicEquation(%,x)
Out> (a-x)*(b-x)*(c-x);

In> Expand(%,x)
Out> (b+a+c)*x^2-x^3-((b+a)*c+a*b)*x+a*b*c;
Siehe auch:
EigenValues , EigenVectors .


EigenValues -- Eigenwerte einer Matrix

mathematische Standardbibliothek
Funktionsaufruf:
EigenValues(matrix)
Parameter:
matrix - eine quadratische Matrix
Beschreibung:
Berechnet die Eigenwerte einer quadratischen Matrix. Eine Zahl x heißt Eigenwert einer Matrix M, wenn es einen Vektor v gibt, so dass M*v=x*v gilt.
Beispiele:
In> M:={{1,2},{2,1}}
Out> {{1,2},{2,1}};

In> EigenValues(M)
Out> {3,-1};
Siehe auch:
EigenVectors , CharacteristicEquation .


EigenVectors -- Eigenvektoren einer Matrix

mathematische Standardbibliothek
Funktionsaufruf:
EigenVectors(matrix, eigenvalues) mathematische Standardbibliothek
Parameter:
matrix - eine quadratische Matrix
eigenvalues - eine Liste von Eigenwerten wie sie die Funktion EigenValues liefert
Beschreibung:
EigenVectors berechnet eine Liste von Eigenvektoren der Matrix.
Beispiele:
In> M:={{1,2},{2,1}}
Out> {{1,2},{2,1}};

In> e:=EigenValues(M)
Out> {3,-1};

In> EigenVectors(M,e)
Out> {{-ki2/ -1,ki2},{-ki2,ki2}};
Siehe auch:
EigenValues , CharacteristicEquation .


IsHermitean - testet, ob das Argument eine hermitesche Matrix ist

mathematische Standardbibliothek
Funktionsaufruf:
IsHermitean(A)
Parameter:
A - eine quadratische Matrix
Beschreibung:
Das Ergebnis ist True, wenn A eine hermitesche Matrix ist, sonst False. Eine Matrix A ist hermitesch, wenn Conjugate(Transpose(A))=A gilt.
Beispiele:
In> IsHermitean({{0,I},{-I,0}})
Out> True;

In> IsHermitean({{0,I},{2,0}})
Out> False;
Siehe auch:
IsUnitary .


IsUnitary -- testet, ob das Argument eine unitäre Matrix ist

mathematische Standardbibliothek
Funktionsaufruf:
IsUnitary(A)
Parameter:
A - eine quadratische Matrix
Beschreibung:
Das Ergebnis ist True, wenn A eine unitäre Matrix ist, sonst False. Eine Matrix A heißt unitär, wenn
A^(-1) = Transpose(Conjugate(A)) gilt.
Beispiele:
In> IsUnitary({{0,I},{-I,0}})
Out> True;

In> IsUnitary({{0,I},{2,0}})
Out> False;
Siehe auch:
IsHermitean .


Expand , Degree , Coef , Content , PrimitivePart , LeadingCoef , Monic , RandomPoly , Horner , ExpandBrackets , OrthoP , OrthoH , OrthoG , OrthoL , OrthoT , OrthoU , OrthoPSum , OrthoHSum , OrthoLSum , OrthoGSum , OrthoTSum , OrthoUSum , OrthoPoly , OrthoPolySum .

Polynome

In diesem Abschnitt werden die für das Arbeiten mit Polynomen notwendigen Befehle erläutert. Dies schließt Funktionen zur Erzeugung und Berechnung orthogonaler Polynom ein.

Expand formt das Polynom um in die Summenschreibweise
Degree Grad eines Polynoms
Coef Koeffizient eines Polynoms
Content Inhalt eines univariaten Polynoms
PrimitivePart primitiver Teil eines univariaten Polynoms
LeadingCoef führender Koeffizient eines Polynoms
Monic normierter Teil eines Polynoms
RandomPoly Zufallspolynom
Horner Hornerform eines Polynoms
ExpandBrackets Auflösen aller im Polynom enthaltenen Klammerausdrücke
OrthoP orthogonale Legendre und Jacobi Polynome
OrthoH hermitesche orthogonale Polynome
OrthoG orthogonale Gegenbauer Polynome
OrthoL orthogonale Laguerre Polynome
OrthoT Tshebyscheff Polynome erster Art
OrthoU Tshebyscheff Polynome zweiter Art
OrthoPSum Summe einer Folge von Legendre und Jacobi Polynomen
OrthoHSum Summe einer Folge von hermiteschen Polynomen
OrthoLSum Summe einer Folge von Laguerre Polynomen
OrthoGSum Summe einer Folge von Gegenbauer Polynomen
OrthoTSum Summe einer Folge von Tschebyscheff Polynomen erster Art
OrthoUSum Summe einer Folge von Tschebyscheff Polynomen zweiter Art
OrthoPoly interne Funktion zum Erzeugen orthogonaler Polynome
OrthoPolySum interne Funktion zum Berechnen von Reihen orthogonaler Polynome


Expand - formt das Polynom um in die Summenschreibweise

mathematische Standardbibliothek
Funktionsaufruf:
Expand(expr)
Expand(expr, var)
Expand(expr, varlist)
Parameter:
expr - ein Polynom
var - eine Variable
varlist - eine Liste von Variablen
Beschreibung:
Das Ergebnis ist das Polynom "expr" in der Form:
c0 + c1*x + c2*x^2 + ... + cn*x^n.

Enthält der Term "expr" nur eine Variable, so kann der erste Funktionsaufruf verwendet werden, ansonsten muss die Funktionsvariable mit "var" explizit angegeben werden.
Der dritte Funktionsaufruf wird bei multivariaten Polynomen verwendet. Zunächst wird das Polynom "expr" nach der ersten Variablen der Liste "varlist" umgeformt. Dann werden alle Koeffizienten nach der zweiten Variablen umgeformt usw.
Beispiele:
In> PrettyPrinter("PrettyForm");

True

Out>

In> Expand((1+x)^5);

 5        4         3         2
x  + 5 * x  + 10 * x  + 10 * x  + 5 * x + 1

Out>

In> Expand((1+x-y)^2, x);

 2                                2
x  + 2 * ( 1 - y ) * x + ( 1 - y )

Out>

In> Expand((1+x-y)^2, {x,y});

 2                         2
x  + ( -2 * y + 2 ) * x + y  - 2 * y + 1

Out>
Siehe auch:
ExpandBrackets


Degree - Grad eines Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
Degree(expr)
Degree(expr, var)
Parameter:
expr - ein Polynom
var - eine Variable
Beschreibung:
Das Ergebnis ist der Grad des Polynoms "expr" bezüglich der Variablen "var". Der Grad eines Polynoms ist der größte vorkommende Exponent von "var". Enthält der Term "expr" nur eine Variable, so kann der erste Funktionsaufruf verwendet werden, ansonsten muss die Funktionsvariable mit "var" explizit angegeben werden.
Beispiele:
In> Degree(x^5+x-1);
Out> 5;

In> Degree(a+b*x^3, a);
Out> 1;

In> Degree(a+b*x^3, x);
Out> 3;
Siehe auch:
Expand , Coef .


Coef -- Koeffizient eines Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
Coef(expr, var, order)
Parameter:
expr - ein Polynom
var - eine Variable
order - nat. Zahl oder Liste nat. Zahlen
Beschreibung:
Das Ergebnis ist der Koeffizient der Variablen "var" mit dem Exponenten "order". Ist der Parameter "order" eine Liste von Exponenten, so ist das Ergebnis eine Liste der zugehörigen Koeffizienten.
Beispiele:
In> e := Expand((a+x)^4,x)
Out> x^4+4*a*x^3+(a^2+(2*a)^2+a^2)*x^2+(a^2*2*a+2*a^3)*x+a^4;

In> Coef(e,a,2)
Out> 6*x^2;

In> Coef(e,a,0 .. 4)
Out> {x^4,4*x^3,6*x^2,4*x,1};
Siehe auch:
Expand , Degree , LeadingCoef .


Content - Inhalt eines univariaten Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
Content(expr)
Parameter:
expr - ein univariates Polynom
Beschreibung:
Das Ergebnis ist der Inhalt eines univariaten Polynoms. Der Inhalt ist der größtmögliche Term durch den das Polynom ohne Rest teilbar ist. Jedes Polynom kann als Produkt von Inhalt und primitivem Teil geschrieben werden.
Beispiele:
In> poly := 2*x^2 + 4*x;
Out> 2*x^2+4*x;

In> c := Content(poly);
Out> 2*x;

In> pp := PrimitivePart(poly);
Out> x+2;

In> Expand(pp*c);
Out> 2*x^2+4*x;
Siehe auch:
PrimitivePart , Gcd .


PrimitivePart - primitiver Teil eines univariaten Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
PrimitivePart(expr)
Parameter:
expr - ein univariates Polynom
Beschreibung:
Das Ergebnis ist der primitive Teil eines univariaten Polynoms. Der primitive Teil ist der Rest, der bei Division des Polynoms durch seinen Inhalt verbleibt. Das Produkt von Inhalt und primitivem Teil ist das ursprüngliche Polynom.
Beispiele:
In> poly := 2*x^2 + 4*x;
Out> 2*x^2+4*x;

In> c := Content(poly);
Out> 2*x;

In> pp := PrimitivePart(poly);
Out> x+2;

In> Expand(pp*c);
Out> 2*x^2+4*x;
Siehe auch:
Content .


LeadingCoef - führender Koeffizient eines Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
LeadingCoef(poly)
LeadingCoef(poly, var)
Parameter:
poly - ein Polynom
var - eine Variable
Beschreibung:
Das Ergebnis ist der führende Koeffizient des Polynoms "poly" bzgl. der Varibalen "var". Der führende Koeffizient ist der Koeffizient der Variablen mit dem größten Exponenten. Enthält der Term "poly" nur eine Variable, so kann der erste Funktionsaufruf verwendet werden, ansonsten muss die Funktionsvariable mit "var" explizit angegeben werden.
Beispiele:
In> poly := 2*x^2 + 4*x;
Out> 2*x^2+4*x;

In> lc := LeadingCoef(poly);
Out> 2;

In> m := Monic(poly);
Out> x^2+2*x;

In> Expand(lc*m);
Out> 2*x^2+4*x;

In> LeadingCoef(2*a^2 + 3*a*b^2 + 5, a);
Out> 2;

In> LeadingCoef(2*a^2 + 3*a*b^2 + 5, b);
Out> 3*a;
Siehe auch:
Coef , Monic .


Monic - normierter Teil eines Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
Monic(poly)
Monic(poly, var)
Parameter:
poly - ein Polynom
var - eine Variable
Beschreibung:
Das Ergebnis ist der normierte Teil des Polynoms "poly" bzgl. der Variablen "var". Der normierte Teil entsteht durch Division des Polynoms durch den führenden Koeffizienten. Der führende Koeffizient des normierten Polynoms ist somit immer Eins. Enthält der Term "poly" nur eine Variable, so kann der erste Funktionsaufruf verwendet werden, ansonsten muss die Funktionsvariable mit "var" explizit angegeben werden.
Beispiele:
In> poly := 2*x^2 + 4*x;
Out> 2*x^2+4*x;

In> lc := LeadingCoef(poly);
Out> 2;

In> m := Monic(poly);
Out> x^2+2*x;

In> Expand(lc*m);
Out> 2*x^2+4*x;

In> Monic(2*a^2 + 3*a*b^2 + 5, a);
Out> a^2+(a*3*b^2)/2+5/2;

In> Monic(2*a^2 + 3*a*b^2 + 5, b);
Out> b^2+(2*a^2+5)/(3*a);
Siehe auch:
LeadingCoef .


RandomPoly - Zufallspolynom

mathematische Standardbibliothek
Funktionsaufruf:
RandomPoly(var,deg,coefmin,coefmax)
Parameter:
var - Funktionsvariable des gesuchten Polynoms
deg - Grad des gesuchten Polynoms
coefmin - minimaler Wert der Koeffizienten
coefmax - maximaler Wert der Koeffizienten
Beschreibung:
Die Funktion erzeugt ein Zufallspolynom vom Grad "deg" in der Variablen "var". Alle Koeffizienten sind ganzzahlige unabhängige Zufallszahlen aus dem Intervall [coefmin | coefmax].
Beispiele:
In> RandomPoly(x,3,-10,10)
Out> 3*x^3+10*x^2-4*x-6;

In> RandomPoly(x,3,-10,10)
Out> -2*x^3-8*x^2+8;
Siehe auch:
Random , RandomIntegerVector .


Div und Mod für Polynome

mathematische Standardbibliothek

Die Funktionen Div und Mod entsprechen den gleichnamigen Funktionen für ganze Zahlen. Das Argument ist hier jedoch ein Polynom.
Siehe auch:
Div , Mod .


Horner - Hornerform eines Polynoms

mathematische Standardbibliothek
Funktionsaufruf:
Horner(expr, var)
Parameter:
expr - ein univariates Polynom
var - eine Variable
Beschreibung:
Die Funktion wandelt das Polynom "expr" in die Hornerform um. Die Normalform eines Polynoms ist ein Ausdruck der Form:

                                  n-1           n
c(0) + c(1) * x + ... + c(n-1) * x    + c(n) * x  

Die Hornerform ist ein Ausdruck der Form:

(...( c(n) * x + c(n-1) ) * x + ...  + c(1) ) * x + c(0)

Beide Terme sind äquivalent. Berechnungen in der Hornerform sind jedoch effizienter, da keine Potenzen zu berechnen sind.
Beispiele:
In> expr1:=Expand((1+x)^4)
Out> x^4+4*x^3+6*x^2+4*x+1
In>  Horner(expr1,x)
Out> (((x+4)*x+6)*x+4)*x+1
Siehe auch:
Expand , ExpandBrackets .


ExpandBrackets - Auflösen aller im Polynom enthaltenen Klammerausdrücke

mathematische Standardbibliothek
Funktionsaufruf:
ExpandBrackets(expr)
Parameter:
expr - ein Term
Beschreibung:
Die Funktion versucht durch wiederholte Anwendung der Distributivgesetze

a * (b+c) = a*b + a*c und (a+b) * c = a*c + b*c

alle im Term vorkommenden Klammerausdrücke aufzulösen.
Beispiele:
In> Expand((a-x)*(b-x),x)
Out> x^2-(b+a)*x+a*b;

In> Expand((a-x)*(b-x),{x,a,b})
Out> x^2-(b+a)*x+b*a;

In> ExpandBrackets((a-x)*(b-x))
Out> a*b-x*b+x^2-a*x;
Siehe auch:
Expand .


OrthoP -- orthogonale Legendre und Jacobi Polynome

mathematische Standardbibliothek
Funktionsaufruf:
OrthoP(n, x);
OrthoP(n, a, b, x);
Parameter:
n - Grad des Polynoms
x - zu berechnender Wert
a, b - Parameter für Jacobi Polynome
Beschreibung:
Der erste Funktionsaufruf berechnet das Legendre Polynom vom Grad "n" an der Stelle "x".
Der zweite Funktionsaufruf führt die gleiche Berechnung für das Jacobi Polynom mit den Parametern "a" und "b" durch. "a" und "b" sollten größer als -1 sein.

Die Jacobi Polynome sind orthogonal bzgl. der Gewichtsfunktion (1-x)^a (1+x)^b auf dem Intervall [-1 | 1]. Sie erfüllen die Gleichungen:

P(0,a,b,x) = 1

             a - b     /     a + b \
P(1,a,b,x) = ----- + x | 1 + ----- |
               2       \       2   /

                                 2   2
                                a - b + x (2n+a+b-2) (n+a+b)
P(n,a,b,x) = (2n + a + b - 1) * ---------------------------- P(n-1,a,b,x)
                                   2n (2n+a+b-2) (n+a+b)


                (n+a-1) (n+b-1) (2n+a+b)
             -  ------------------------ P(n-2,a,b,x),         for n > 1.
                  n (n+a+b) (2n+a+b-2)

Legendre Polynome sind spezielle Jacobi Polynome mit den Parametern a = b = 0. Sie erfüllen die Gleichungen:

P(0,x) = 1

P(1,x) = x

         (2n - 1) x            n - 1
P(n,x) = ---------- P(n-1,x) - ----- P(n-2,x),     for n > 1.
             2n                  n

Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
Beispiele:
In> PrettyPrinter("PrettyForm");

True

Out>

In> OrthoP(3, x);

    /      2     \
    | 5 * x    3 |
x * | ------ - - |
    \   2      2 /

Out>

In> OrthoP(3, 1, 2, x);

1       /     / 21 * x   7 \   7 \
- + x * | x * | ------ - - | - - |
2       \     \   2      2 /   2 /

Out>

In> Expand(%)

      3        2
21 * x  - 7 * x  - 7 * x + 1
----------------------------
             2

Out>

In> OrthoP(3, 1, 2, 0.5);

-0.8124999999

Out>
siehe auch:
OrthoPSum , OrthoG , OrthoPoly .


OrthoH -- hermitesche orthogonale Polynome

mathematische Standardbibliothek
Funktionsaufruf:
OrthoH(n, x);
Parameter:
n - Grad des Polynoms
x - zu berechnender Wert
Beschreibung:
Diese Funktion berechnet das hermitesche Polynom vom Grad "n" an der Stelle "x".

Die hermiteschen Polynome sind orthogonal bzgl. der Gewichtsfunktion e^(-x^2/2). Sie erfüllen die Gleichungen:

H(0,x) = 1

H(1,x) = 2x

H(n,x) = 2x H(n-1,x) - 2(n-1) H(n-2,x),     for n > 1.

Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
Beispiele:
In> OrthoH(3, x);
Out> x*(8*x^2-12);

In> OrthoH(6, 0.5);
Out> 31;
siehe auch:
OrthoHSum , OrthoPoly .


OrthoG -- orthogonale Gegenbauer Polynome

mathematische Standardbibliothek
Funktionsaufruf:
OrthoG(n, a, x);
Parameter:
n - Grad des Polynoms
a - Parameter
x - zu berechnender Wert
Beschreibung:
Diese Funktion berechnet das Gegenbauer Polynom vom Grad "n" mit dem Parameter "a" an der Stelle "x". Der Parameter "a" sollte größer -1/2 sein.

Die Gegenbauer Polynome sind orthogonal bzgl. der Gewichtsfunktion (1-x^2)^(a-1/2) auf dem Intervall [-1 | 1]. Zu den Jacobi Polynomen besteht demnach folgender Zusammenhang: G(n, a, x) = P(n, a-1/2, a-1/2, x). Sie erfüllen die Gleichungen:

G(0,a,x) = 1

G(1,a,x) = 2x

             /     a - 1 \                /     2 (a-2) \
G(n,a,x) = 2 | 1 + ----- | x G(n-1,a,x) - | 1 + ------- | G(n-2,a,x), for n>1.
             \       n   /                \        n    /

Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
Beispiele:
In> OrthoG(5, 1, x);
Out> x*((32*x^2-32)*x^2+6);

In> OrthoG(5, 2, -0.5);
Out> 2;
siehe auch:
OrthoP , OrthoT , OrthoU , OrthoGSum , OrthoPoly .


OrthoL -- orthogonale Laguerre Polynome

mathematische Standardbibliothek
Funktionsaufruf:
OrthoL(n, a, x);
Parameter:
n - Grad des Polynoms
a - Parameter
x - zu berechnender Wert
Beschreibung:
Diese Funktion berechnet das Laguerre Polynom vom Grad "n" mit dem Parameter "a" an der Stelle "x". Der Parameter "a" sollte größer -1 sein.

Die Laguerre Polynome sind orthogonal bzgl. der Gewichtsfunktion x^a * e^(-x). Sie erfüllen die Gleichungen:

L(0,a,x) = 1

L(1,a,x) = a + 1 - x

           /     a - 1 - x \              /     a - 1 \
L(n,a,x) = | 2 + --------- | L(n-1,a,x) - | 1 + ----- | L(n-2,a,x), for n>1.
           \         n     /              \       n   /

Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
Beispiele:
In> OrthoL(3, 1, x);
Out> x*(x*(2-x/6)-6)+4;

In> OrthoL(3, 1/2, 0.25);
Out> 1.2005208334;
siehe auch:
OrthoLSum , OrthoPoly .


OrthoT -- Tshebyscheff Polynome erster Art

mathematische Standardbibliothek
Funktionsaufruf:
OrthoT(n, x);
Parameter:
n - Grad des Polynoms
x - zu berechnender Wert
Beschreibung:
Diese Funktion berechnet das Tschebyscheff Polynom erster Art vom Grad "n" an der Stelle "x".

Die Tschebyscheff Polynome erster Art sind orthogonal bzgl. der Gewichtsfunktion (1-x^2)^(-1/2). Sie sind spezielle Gegenbauer Polynome mit dem Parameter a=0. Sie erfüllen die Gleichungen:

T(0,x) = 1

T(1,x) = x

T(n,x) = 2x T(n-1,x) - T(n-2,x),     for n > 1.

Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
Beispiele:
IIn> OrthoT(3, x);
Out> x*(4*x^2-3);

In> OrthoT(10, 0.9);
Out> -0.2007474688;
siehe auch:
OrthoG , OrthoU , OrthoTSum , OrthoPoly .


OrthoU -- Tshebyscheff Polynome zweiter Art

mathematische Standardbibliothek
Funktionsaufruf:
OrthoU(n, x);
Parameter:
n - Grad des Polynoms
x - zu berechnender Wert
Beschreibung:
Diese Funktion berechnet das Tschebyscheff Polynom zweiter Art vom Grad "n" an der Stelle "x".

Die Tschebyscheff Polynome zweiter Art sind orthogonal bzgl. der Gewichtsfunktion (1-x^2)^(1/2). Sie sind spezielle Gegenbauer Polynome mit dem Parameter a=1. Sie erfüllen die Gleichungen:

U(0,x) = 1

U(1,x) = 2x

U(n,x) = 2x U(n-1,x) - u(n-2,x),     for n > 1.

Die Hauptarbeit übernimmt die interne Funktion OrthoPoly.
Beispiele:
In> OrthoU(3, x);
Out> x*(8*x^2-4);

In> OrthoU(10, 0.9);
Out> -2.2234571776;
siehe auch:
OrthoG , OrthoT , OrthoUSum , OrthoPoly .


OrthoPSum -- Summe einer Folge von Legendre and Jacobi Polynomen


OrthoHSum -- Summe einer Folge von hermiteschen Polynomen


OrthoLSum -- Summe einer Folge von Laguerre Polynomen


OrthoGSum -- Summe einer Folge von Gegenbauer Polynomen


OrthoTSum -- Summe einer Folge von Tschebyscheff Polynomen erster Art


OrthoUSum -- Summe einer Folge von Tschebyscheff Polynomen zweiter Art

mathematische Standardbibliothek
Funktionsaufruf:
OrthoPSum(c, x);
OrthoPSum(c, a, b, x);
OrthoHSum(c, x);
OrthoLSum(c, a, x);
OrthoGSum(c, a, x);
OrthoTSum(c, x);
OrthoUSum(c, x);
Parameter:
c - eine Liste von Koeffizienten
a, b - Parameter des jeweiligen Polynoms
x - zu berechnender Wert
Beschreibung:
Diese Funktionen berechnen die Summe einer Folge von orthogonalen Polynomen (mit konstanten Parametern "a" und "b") an der Stelle "x". Die Koeffizienten der Reihe werden in der Liste "c" angegeben.

Die Liste der Koeffizienten beginnt mit der kleinsten Ordnung, z.B.:

OrthoLSum(c, a, x) = c[1] L_0(a,x) + c[2] L_1(a,x) + ... + c[N] L_{N-1}(a,x).

Die Hauptarbeit übernimmt die interne Funktion OrthoPolySum.
Beispiele:
In> Expand(OrthoPSum({1,0,0,1/7,1/8}, 3/2, 2/3, x));
Out> (7068985*x^4)/3981312+(1648577*x^3)/995328+(-3502049*x^2)/4644864+(-4372969*x)/6967296+28292143/27869184;
siehe auch:
OrthoP , OrthoG , OrthoH , OrthoL , OrthoT , OrthoU , OrthoPolySum .


OrthoPoly -- interne Funktion zum Erzeugen orthogonaler Polynome

mathematische Standardbibliothek
Funktionsaufruf:
OrthoPoly(name, n, par, x)
Parameter:
name - String mit dem Namen der Polynomfamilie
n - Grad des Polynoms
par - Liste der Parameter
x - zu berechnender Wert
Beschreibung:
Diese Funktion wird intern zum Konstruieren orthogonaler Polynome verwendet. Das Ergebnis ist das Polynom vom Grad "n" der Familie "name" mit den Parametern "par" an der Stelle "x".

Alle bekannten Polynomfamilien sind in der Schlüsselliste KnownOrthoPoly abgespeichert. Der Name wird als Schlüssel verwendet. Zurzeit kennt Yacas folgende Polynomfamilien:
"Jacobi", "Gegenbauer", "Laguerre", "Hermite", "Tscheb1" und "Tscheb2".
Das zum Schlüssel gehörige Listenelement ist eine Funktion mit den beiden Argumenten "n" und "p", die eine Liste von zwei Listen als Ergebnis liefert: Die erste Liste enthält die Koeffizienten {A,B} des Polynoms vom Grad n=1, die zweite Liste enthält die Koeffizienten {A,B,C} der Gewichtsfunktion.

Ist der Wert "x" numerisch, wird die Funktion OrthoPolyNumeric aufgerufen, andernfalls wird mit OrthoPolyCoeffs eine Liste von Koeffizienten berechnet, die mit EvaluateHornerScheme in ein Polynom umgewandelt wird.
siehe auch:
OrthoP , OrthoG , OrthoH , OrthoL , OrthoT , OrthoU , OrthoPolySum .


OrthoPolySum -- interne Funktion zum Berechnen von Reihen orthogonaler Polynome

mathematische Standardbibliothek
Funktionsaufruf:
OrthoPolySum(name, c, par, x)
Parameter:
name - String mit dem Namen der Polynomfamilie
c - Liste von Koeffizienten
par - Liste der Parameter
x - zu berechnender Wert
Beschreibung:
Diese Funktion wird intern zum Berechnen einer Reihe von orthogonalen Polynomen verwendet. Sie entspricht der Funktion OrthoPoly und liefert als Ergebnis die Summe einer Folge von Polynomen der Familie "name" an der Stelle "x". "c" ist die Liste der Koeffizienten der Folge.

Ist der Wert "x" numerisch, wird die Funktion OrthoPolySumNumeric aufgerufen, andernfalls wird mit OrthoPolySumCoeffs eine Liste von Koeffizienten berechnet, die mit EvaluateHornerScheme in ein Polynom umgewandelt wird.
siehe auch:
OrthoPSum , OrthoGSum , OrthoHSum , OrthoLSum , OrthoTSum , OrthoUSum , OrthoPoly .


Head , Tail , Length , Map , MapSingle , RandomIntegerVector , MakeVector , Select , Nth , DestructiveReverse , List , UnList , Listify , Concat , Delete , Insert , DestructiveDelete , DestructiveInsert , Replace , DestructiveReplace , FlatCopy , Contains , Find , Append , DestructiveAppend , RemoveDuplicates , Push , Pop , PopFront , PopBack , Swap , Count , Intersection , Union , Difference , FillList , Drop , Take , Partition , Assoc , AssocIndices , Flatten , UnFlatten , Type , NrArgs , BubbleSort , Table , TableForm .

Das Arbeiten mit Listen

Fast alle Objekte variabler Größer werden als Listen repräsentiert (intern als verkettete Listen implementiert).

Head erstes Element einer Liste
Tail Liste ohne das erste Element
Length Länge einer Liste oder einer Zeichenkette (String)
Map Anwenden einer Funktion auf alle Elemente der Liste
MapSingle Anwenden einer Funktion auf alle Elemente der Liste
RandomIntegerVector Zufallsvektor
MakeVector Vektor mit numerierten Variablen
Select Selektieren bestimmter Elemente einer Liste
Nth das n-te Element einer Liste
DestructiveReverse Vertauschen der Reihenfolge aller Elemente
List Erzeugen einer Liste
UnList Umwandlung einer Liste in einen Funktionsaufruf
Listify Umwandlung eines Funktionsaufrufs in eine Liste
Concat Aneinanderhängen von Listen
Delete Löschen eines Listenelements
Insert Einfügen eines Listenelements
DestructiveDelete Löschen eines Listenelements mit Änderung der ursprünglichen Liste
DestructiveInsert Einfügen eines Listenelements mit Änderung der ursprünglichen Liste
Replace Ersetzen eines Listenelements
DestructiveReplace Ersetzen eines Listenelements mit Änderung der ursprünglichen Liste
FlatCopy Kopieren einer Liste
Contains Testen, ob eine Liste ein best. Element enthält
Find Durchsuchen einer Liste
Append Hinzufügen eines Listenelements am Ende der Liste
DestructiveAppend Hinzufügen eines Listenelements am Ende der Liste mit Änderung der ursprünglichen Liste
RemoveDuplicates Entfernen von Duplikaten
Push Hinzufügen eines Elements zu einem Stack
Pop Entfernen eines Elements aus einem Stack
PopFront Entfernen des obersten Elements aus einem Stack
PopBack Entfernen des untersten Elements aus einem Stack
Swap Vertauschen zweier Listenelemente
Count Anzahl des Auftretens eines best. Ausdrucks in der Liste
Intersection Schnittmenge zweier Listen
Union Vereinigungsmenge zweier Listen
Difference Differenz zweier Listen
FillList Füllen einer Liste mit einem best. Ausdruck
Drop Entfernen eines Bereichs von Listenelementen
Take Abspalten eines Bereichs von Listenelementen
Partition Umformen einer Liste in Teillisten gleicher Länge
Assoc Suchen eines Listenelements anhand eines Schlüssels
AssocIndices Schlüssel einer Schlüsselliste
Flatten Zerlegen eines Terms in eine Liste
UnFlatten Erzeugen eines Terms aus den Elementen einer Liste
Type den Typ eines Ausdrucks bestimmen
NrArgs Anzahl der Argumente eines Ausdrucks bestimmen
BubbleSort Sortieren einer Liste
Table Erzeugen einer Liste über eine Schleife
TableForm gibt die Elemente einer Liste formatiert aus


Head -- erstes Element einer Liste

interne Funktion
Funktionsaufruf:
Head(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist das erste Element der Liste. Angewendet auf einen Term wird der erste Operand zurückgegeben.
Beispiele:
In> Head({a,b,c})
Out> a;

In> Head(f(a,b,c));
Out> a;
siehe auch:
Tail , Length .


Tail -- Liste ohne das erste Element

interne Funktion
Funktionsaufruf:
Tail(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist eine Liste ohne das erste Element.
Beispiele:
In> Tail({a,b,c})
Out> {b,c};
siehe auch:
Head , Length .


Length -- Länge einer Liste oder einer Zeichenkette (String)

interne Funktion
Funktionsaufruf:
Length(object)
Parameter:
object - eine Liste, ein Array oder ein String
Beschreibung:
Das Ergebnis ist die Länge der Liste. Die Funktion kann auch auf Arrays oder Strings angewendet werden.
Beispiele:
In> Length({a,b,c})
Out> 3;

In> Length("abcdef");
Out> 6;
siehe auch:
Head , Tail , Nth , Count .


Map -- Anwenden einer Funktion auf alle Elemente der Liste

mathematische Standardbibliothek
Funktionsaufruf:
Map(fn, list)
Parameter:
fn - eine Funktion
list - eine Liste mit Listen von Argumenten
Beschreibung:
Diese Funktion wendet die Funktion "fn" auf alle in "list" enthaltenen Argumentlisten an. Das erste Element von "list" ist eine Liste deren Elemente das 1., 2., 3., ... Argument von "fn" sind. Das gleiche gilt für die weiteren Elemente in "list".
Beispiele:
In> MapSingle("Sin",{a,b,c});
Out> {Sin(a),Sin(b),Sin(c)};

In> Map("+",{{a,b},{c,d}});
Out> {a+c,b+d};
siehe auch:
MapSingle , MapArgs .


MapSingle -- Anwenden einer Funktion auf alle Elemente der Liste

mathematische Standardbibliothek
Funktionsaufruf:
MapSingle(fn, list)
Parameter:
fn - eine Funktion
list - eine Liste von Argumenten
Beschreibung:
Die Funktion "fn" wird nacheinander auf alle Elemente der Liste "list" angewendet. Zurückgegeben wird eine Liste mit den entsprechenden Ergebnissen.

Der /@ Operator ist eine Abkürzung für MapSingle.
Beispiele:
In> MapSingle("Sin",{a,b,c});
Out> {Sin(a),Sin(b),Sin(c)};

In> MapSingle({{x},x^2}, {a,2,c});
Out> {a^2,4,c^2};
siehe auch:
Map , MapArgs , /@ .


RandomIntegerVector -- Zufallsvektor

mathematische Standardbibliothek
Funktionsaufruf:
RandomIntegerVector(nr, from, to)
Parameter:
nr - Anzahl der Komponenten
from - untere Grenze
to - obere Grenze
Beschreibung:
Das Ergebnis ist eine Liste mit "nr" ganzzahligen Zufallszahlen. Die Zufallszahlen sind gleichmäßig im Intervall [from ; to] verteilt.
Beispiele:
In> RandomIntegerVector(4,-3,3)
Out> {0,3,2,-2};
siehe auch:
Random , RandomPoly .


MakeVector -- Vektor mit numerierten Variablen

mathematische Standardbibliothek
Funktionsaufruf:
MakeVector(var, n)
Parameter:
var - freie Variable
n - Länge des Vektors
Beschreibung:
Das Ergebnis ist eine Liste der Länge "n". Die Elemente sind jeweils die Variable "var" mit hinzugefügtem Index.
Beispiele:
In> MakeVector(a,3)
Out> {a1,a2,a3};
siehe auch:
RandomIntegerVector , ZeroVector .


Select -- Selektieren bestimmter Elemente einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
Select(pred, list)
Parameter:
pred - eine Eigenschaft
list - eine Liste
Beschreibung:
Das Ergebnis ist eine Teilliste von "list", die alle Elemente mit der angegebenen Eigenschaft "pred" enthält.
Beispiele:
In> Select("IsInteger",{a,b,2,c,3,d,4,e,f})
Out> {2,3,4};
siehe auch:
Length , Find , Count .


Nth -- das n-te Element einer Liste

interne Funktion
Funktionsaufruf:
Nth(list, n)
Parameter:
list - eine Liste
n - Index
Beschreibung:
Das Ergebnis ist das Element der Liste "list" mit dem Index "n". Das erste Element hat den Index 1. Ist "n" eine Liste von Indizees, ist das Ergebnis eine Liste mit den entsprechenden Elementen.

Auf einen Term angewendet ist das Ergebnis der n-te Operand.

Eine äquivalente Form von Nth(list, n) ist list[n].
Beispiele:
In> lst := {a,b,c,13,19};
Out> {a,b,c,13,19};

In> Nth(lst, 3);
Out> c;

In> lst[3];
Out> c;

In> Nth(lst, {3,4,1});
Out> {c,13,a};

In> Nth(b*(a+c), 2);
Out> a+c;
siehe auch:
Select , Nth .


DestructiveReverse -- Vertauschen der Reihenfolge aller Elemente

interne Funktion
Funktionsaufruf:
DestructiveReverse(list)
Parameter:
list - eine Liste
Beschreibung:
Die Funktion dreht die Reihenfolge der Elemente der Liste "list" um. Das Original bleibt nicht erhalten.
Die gedrehte Liste wird als Ergebnis zurückgegeben.

Es gibt keine Funktion, die eine Liste dreht ohne das Original zu zerstören. Soll das Original erhalten bleiben, muss die Liste zunächst mit FlatCopy kopiert werden.
Beispiele:
In> lst := {a,b,c,13,19};
Out> {a,b,c,13,19};

In> revlst := DestructiveReverse(lst);
Out> {19,13,c,b,a};

In> lst;
Out> {a};
siehe auch:
FlatCopy .


List -- Erzeugen einer Liste

interne Funktion
Funktionsaufruf:
List(expr1, expr2, ...)
Parameter:
expr1, expr2 - Listenelemente
Beschreibung:
Es wird eine Liste erzeugt, deren erstes Element "expr1" ist, das zweite "expr2" usw. Das Ergebnis ist äquivalent zum Ausdruck "{expr1, expr2, ...}".
Beispiele:
In> List();
Out> {};

In> List(a,b);
Out> {a,b};

In> List(a,{1,2},d);
Out> {a,{1,2},d};
siehe auch:
UnList , Listify .


UnList -- Umwandlung einer Liste in einen Funktionsaufruf

interne Funktion
Funktionsaufruf:
UnList(list)
Parameter:
list - eine Liste
Beschreibung:
Diese Funktion wandelt die Liste in einen Funktionsaufruf um. Das erste Listenelement wird als Funktionsterm interpretiert, die folgenden Elemente als Argumente der Funktion.

Die Liste "list" wird vor dem Erstellen des Funktionsaufrufs berechnet, der resultierende Funktionsaufruf jedoch nicht.
Beispiele:
In> UnList({Cos, x});
Out> Cos(x);

In> UnList({f});
Out> f();

In> UnList({Taylor,x,0,5,Cos(x)});
Out> Taylor(x,0,5)Cos(x);

In> Eval(%);
Out> 1-x^2/2+x^4/24;
siehe auch:
List , Listify .


Listify -- Umwandlung eines Funktionsaufrufs in eine Liste

interne Funktion
Funktionsaufruf:
Listify(expr)
Parameter:
expr - ein Funktionsterm
Beschreibung:
Das Ergebnis ist eine Liste. Das erste Element ist der Operator, die übrigen Elemente sind die Operanden.
Beispiele:
In> Listify(Cos(x));
Out> {Cos,x};

In> Listify(3*a);
Out> {*,3,a};
siehe auch:
List , UnList , IsAtom .


Concat -- Aneinanderhängen von Listen

interne Funktion
Funktionsaufruf:
Concat(list1, list2, ...)
Parameter:
list1, list2 - Listen
Beschreibung:
Die Listen "list1", "list2", ... werden berechnet und aneinandergehängt. Das Ergebnis ist die neue Liste.
Beispiele:
In> Concat({a,b}, {c,d});
Out> {a,b,c,d};

In> Concat({5}, {a,b,c}, {{f(x)}});
Out> {5,a,b,c,{f(x)}};
siehe auch:
ConcatStrings , : , Insert .


Delete -- Löschen eines Listenelements

interne Funktion
Funktionsaufruf:
Delete(list, n)
Parameter:
list - eine Liste
n - Index des zu löschenden Elements
Beschreibung:
Die Funktion löscht das n-te Element der Liste "list". Das Ergebnis ist die resultierende Liste.
Beispiele:
In> Delete({a,b,c,d,e,f}, 4);
Out> {a,b,c,e,f};
siehe auch:
DestructiveDelete , Insert , Replace .


Insert -- Einfügen eines Listenelements

interne Funktion
Funktionsaufruf:
Insert(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Der Term "expr" wird unmittelbar vor dem n-ten Listenelement in die Liste "list" eingefügt. Ist n=1, wird "expr" an den Anfang der Liste gesetzt (entspricht dem : Operator); ist n um 1 größer als die Listenlänge, wird "expr" an das Ende der Liste gesetzt (entspricht Append). Das Ergebnis ist die resultierende Liste.
Beispiele:
In> Insert({a,b,c,d}, 4, x);
Out> {a,b,c,x,d};

In> Insert({a,b,c,d}, 5, x);
Out> {a,b,c,d,x};

In> Insert({a,b,c,d}, 1, x);
Out> {x,a,b,c,d};
siehe auch:
DestructiveInsert , : , Append , Delete , Remove .


DestructiveDelete -- Löschen eines Listenelements mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveDelete(list, n)
Parameter:
list - eine Liste
n - Index des zu löschenden Elements
Beschreibung:
Im Gegensatz zur Funktion Delete wird das Original hier verändert.
Beispiele:
In> lst := {a,b,c,d,e,f};
Out> {a,b,c,d,e,f};

In> Delete(lst, 4);
Out> {a,b,c,e,f};

In> lst;
Out> {a,b,c,d,e,f};

In> DestructiveDelete(lst, 4);
Out> {a,b,c,e,f};

In> lst;
Out> {a,b,c,e,f};
siehe auch:
Delete , DestructiveInsert , DestructiveReplace .


DestructiveInsert -- Einfügen eines Listenelements mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveInsert(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Im Gegensatz zur Funktion Insert wird das Original hier verändert.
Beispiele:
In> lst := {a,b,c,d};
Out> {a,b,c,d};

In> Insert(lst, 2, x);
Out> {a,x,b,c,d};

In> lst;
Out> {a,b,c,d};

In> DestructiveInsert(lst, 2, x);
Out> {a,x,b,c,d};

In> lst;
Out> {a,x,b,c,d};
siehe auch:
Insert , DestructiveDelete , DestructiveReplace .


Replace -- Ersetzen eines Listenelements

interne Funktion
Funktionsaufruf:
Replace(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Die Funktion ersetzt das n-te Listenelement der Liste "list" durch den Term "expr". Die Funktion ist äquivalent zu
Insert(Delete(list, n), n, expr).
Beispiele:
In> Replace({a,b,c,d,e,f}, 4, x);
Out> {a,b,c,x,e,f};
siehe auch:
Delete , Insert , DestructiveReplace .


DestructiveReplace -- Ersetzen eines Listenelements mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveReplace(list, n, expr)
Parameter:
list - eine Liste
n - ein Index
expr - ein Term
Beschreibung:
Im Gegensatz zur Funktion Replace wird hier das Original verändert.
Beispiele:
In> lst := {a,b,c,d,e,f};
Out> {a,b,c,d,e,f};

In> Replace(lst, 4, x);
Out> {a,b,c,x,e,f};

In> lst;
Out> {a,b,c,d,e,f};

In> DestructiveReplace(lst, 4, x);
Out> {a,b,c,x,e,f};

In> lst;
Out> {a,b,c,x,e,f};
siehe auch:
Replace , DestructiveDelete , DestructiveInsert .


FlatCopy -- Kopieren einer Liste

interne Funktion
Funktionsaufruf:
FlatCopy(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist eine Kopie der Liste "list". Es wird keine Rekursion durchgeführt, nur die oberste Ebene wird kopiert.
Beispiel:
Das folgende Beispiel dreht die Reihenfolge der Listenelemente ohne das Original zuverändern.
In> reverse(l_IsList) <-- DestructiveReverse(FlatCopy(l));
Out> True;

In> lst := {a,b,c,d,e};
Out> {a,b,c,d,e};

In> reverse(lst);
Out> {e,d,c,b,a};

In> lst;
Out> {a,b,c,d,e};


Contains -- Testen, ob eine Liste ein best. Element enthält

mathematische Standardbibliothek
Funktionsaufruf:
Contains(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Diese Funktion testet, ob die Liste "list" den Term "expr" als Listenelement enthält. Wenn ja ist das Ergebnis True, sonst False.
Ist der Parameter "list" ein Term, werden die Operanden nach "expr" abgesucht.
Beispiele:
In> Contains({a,b,c,d}, b);
Out> True;

In> Contains({a,b,c,d}, x);
Out> False;

In> Contains({a,{1,2,3},z}, 1);
Out> False;

In> Contains(a*b, b);
Out> True;
siehe auch:
Find , Count .


Find -- Durchsuchen einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
Find(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Die Funktion durchsucht die Liste "list" nach dem Term "expr". Wird "expr" als Listenelement gefunden, ist das Ergebnis der Index des Elements. Ist die Suche erfolglos, ist das Ergebnis -1.
Beispiele:
In> Find({a,b,c,d,e,f}, d);
Out> 4;

In> Find({1,2,3,2,1}, 2);
Out> 2;

In> Find({1,2,3,2,1}, 4);
Out> -1;
siehe auch:
Contains .


Append -- Hinzufügen eines Listenelements am Ende der Liste

mathematische Standardbibliothek
Funktionsaufruf:
Append(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Der Term "expr" wird am Listenende hinzugefügt. Das Ergebnis ist die resultierende Liste.

Hinweis: Die Zeit für das Anhängen am Listenende wächst proportional mit der Listenlänge; die Zeit für das Hinzufügen am Listenanfang ist konstant.
Beispiele:
In> Append({a,b,c,d}, 1);
Out> {a,b,c,d,1};
siehe auch:
Concat , : , DestructiveAppend .


DestructiveAppend -- Hinzufügen eines Listenelements am Ende der Liste mit Änderung der ursprünglichen Liste

interne Funktion
Funktionsaufruf:
DestructiveAppend(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Im Gegensatz zur Funktion Append wird hier das Original verändert.
Beispiele:
In> lst := {a,b,c,d};
Out> {a,b,c,d};

In> Append(lst, 1);
Out> {a,b,c,d,1};

In> lst
Out> {a,b,c,d};

In> DestructiveAppend(lst, 1);
Out> {a,b,c,d,1};

In> lst;
Out> {a,b,c,d,1};
siehe auch:
Concat , : , Append .


RemoveDuplicates -- Entfernen von Duplikaten

mathematische Standardbibliothek
Funktionsaufruf:
RemoveDuplicates(list)
Parameter:
list - eine Liste
Beschreibung:
Diese Funktion entfernt alle Duplikate in der Liste "list". Das Ergebnis ist die resultierende Liste.
Beispiele:
In> RemoveDuplicates({1,2,3,2,1});
Out> {1,2,3};

In> RemoveDuplicates({a,1,b,1,c,1});
Out> {a,1,b,c};


Push -- Hinzufügen eines Elements zu einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
Push(stack, expr)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
expr - ein Term
Beschreibung:
Diese Funktion ist Teil einer einfachen Implementation eines Stacks. Der Stack wird durch eine Liste repräsentiert.
Der Term "expr" wird dem Stack hinzugefügt. Das Ergebnis ist der resultierende Stack.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> PopFront(stack);
Out> x2;
siehe auch:
Pop , PopFront , PopBack .


Pop -- Entfernen eines Elements aus einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
Pop(stack, n)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
n - ein Index
Beschreibung:
Das Stackelement mit Index "n" wird vom Stack entfernt und als Ergebnis zurückgegeben. Das oberste Stackelement hat den Index 1. Ungültige Indizees führen zu einem Fehler.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> Push(stack, x3);
Out> {x3,x2,x};

In> Pop(stack, 2);
Out> x2;

In> stack;
Out> {x3,x};
siehe auch:
Push , PopFront , PopBack .


PopFront -- Entfernen des obersten Elements aus einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
PopFront(stack)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
Beschreibung:
Das oberste Stackelement wird vom Stack entfernt und als Ergebnis zurückgegeben. Das ist das Element, das mit dem letzten Push -Befehl dem Stack hinzugefügt wurde.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> Push(stack, x3);
Out> {x3,x2,x};
In> PopFront(stack);
Out> x3;

In> stack;
Out> {x2,x};
siehe auch:
Push , Pop , PopBack .


PopBack -- Entfernen des untersten Elements aus einem Stack

mathematische Standardbibliothek
Funktionsaufruf:
PopBack(stack)
Parameter:
stack - ein Stack (repräsentiert durch eine Liste)
Beschreibung:
Das unterste Stackelement wird vom Stack entfernt und als Ergebnis zurückgegeben.
Beispiele:
In> stack := {};
Out> {};

In> Push(stack, x);
Out> {x};

In> Push(stack, x2);
Out> {x2,x};

In> Push(stack, x3);
Out> {x3,x2,x};

In> PopBack(stack);
Out> x;

In> stack;
Out> {x3,x2};
siehe auch:
Push , Pop , PopFront .


Swap -- Vertauschen zweier Listenelemente

mathematische Standardbibliothek
Funktionsaufruf:
Swap(list, i1, i2)
Parameter:
list - eine Liste
i1, i2 - Indizees
Beschreibung:
Die Listenelemente mit den Indizees "i1" und "i2" werden vertauscht. Das Ergebnis ist die resultierende Liste.
Beispiele:
In> lst := {a,b,c,d,e,f};
Out> {a,b,c,d,e,f};

In> Swap(lst, 2, 4);
Out> {a,d,c,b,e,f};
siehe auch:
Replace , DestructiveReplace .


Count -- Anzahl des Auftretens eines best. Ausdrucks in der Liste

mathematische Standardbibliothek
Funktionsaufruf:
Count(list, expr)
Parameter:
list - eine Liste
expr - ein Term
Beschreibung:
Die Anzahl des Auftretens des Terms "expr" in der Liste "list"wird bestimmt und als Ergebnis zurückgegeben.
Beispiele:
In> lst := {a,b,c,b,a};
Out> {a,b,c,b,a};

In> Count(lst, a);
Out> 2;

In> Count(lst, c);
Out> 1;

In> Count(lst, x);
Out> 0;
siehe auch:
Length , Select , Contains .


Intersection -- Schnittmenge zweier Listen

mathematische Standardbibliothek
Funktionsaufruf:
Intersection(l1, l2)
Parameter:
l1, l2 - zwei Listen
Beschreibung:
Die Schnittmenge der Listen "l1" and "l2" wird bestimmt und als Ergebnis zurückgegeben. Die Schnittmenge enthält alle Elemente, die in beiden Listen vorkommen. Die Elemente der Schnittmenge sind in der gleichen Reihenfolge wie in der Liste "l1" angeordnet.
Beispiele:
In> Intersection({a,b,c}, {b,c,d});
Out> {b,c};

In> Intersection({a,e,i,o,u}, {f,o,u,r,t,e,e,n});
Out> {e,o,u};

In> Intersection({1,2,2,3,3,3}, {1,1,2,2,3,3});
Out> {1,2,2,3,3};
siehe auch:
Union , Difference .


Union -- Vereinigungsmenge zweier Listen

mathematische Standardbibliothek
Funktionsaufruf:
Intersection(l1, l2)
Parameter:
l1, l2 - zwei Listen
Beschreibung:
Die Vereinigungsmenge der Listen "l1" and "l2" wird bestimmt und als Ergebnis zurückgegeben. Die Vereinigungsmenge enthält alle Elemente, die in "l1" oder "l2" enthalten sind. In der resultierenden Liste kommt jedes Element nur einmal vor.
Beispiele:
In> Union({a,b,c}, {b,c,d});
Out> {a,b,c,d};

In> Union({a,e,i,o,u}, {f,o,u,r,t,e,e,n});
Out> {a,e,i,o,u,f,r,t,n};

In> Union({1,2,2,3,3,3}, {2,2,3,3,4,4});
Out> {1,2,3,4};
siehe auch:
Intersection , Difference .


Difference -- Differenz zweier Listen

mathematische Standardbibliothek
Funktionsaufruf:
Intersection(l1, l2)
Parameter:
l1, l2 - zwei Listen
Beschreibung:
Die Differenz der Listen "l1" and "l2" wird bestimmt und als Ergebnis zurückgegeben. Die Differenz enthält alle Elemente, die in "l1" vorkommen aber nicht in "l2". Die Reihenfolge der Elemente in "l1" bleibt erhalten. Ist ein Element n1-mal in "l1" und n2-mal in "l2" enthalten, erscheint es (n1-n2)-mal im Ergebnis.
Beispiele:
In> Difference({a,b,c}, {b,c,d});
Out> {a};

In> Difference({a,e,i,o,u}, {f,o,u,r,t,e,e,n});
Out> {a,i};

In> Difference({1,2,2,3,3,3}, {2,2,3,4,4});
Out> {1,3,3};
siehe auch:
Intersection , Union .


FillList -- Füllen einer Liste mit einem best. Ausdruck

mathematische Standardbibliothek
Funktionsaufruf:
FillList(expr, n)
Parameter:
expr - ein Term
n - die Länge der Liste
Beschreibung:
Die Funktion erzeugt eine Liste mit "n" gleichen Elementen "expr". Das Ergebnis ist die resultierende Liste.
Beispiele:
In> FillList(x, 5);
Out> {x,x,x,x,x};
siehe auch:
MakeVector , ZeroVector , RandomIntegerVector .


Drop -- Entfernen eines Bereichs von Listenelementen

mathematische Standardbibliothek
Funktionsaufruf:
Drop(list, n)
Drop(list, -n)
Drop(list, {m,n})
Parameter:
list - eine Liste
n, m - positive ganze Zahlen
Beschreibung:
Diese Funktion entfernt eine Teilliste der Liste "list". Das Ergebnis ist eine Liste mit den übrigen Elementen.
Der erste Funktionsaufruf entfernt die ersten "n" Elemente. Der zweite Funktionsaufruf entfernt die letzten "n" Elemente. Der dritte Funktionsaufruf entfernt die Elemente mit Indizees von "m" bis "n".
Beispiele:
In> lst := {a,b,c,d,e,f,g};
Out> {a,b,c,d,e,f,g};

In> Drop(lst, 2);
Out> {c,d,e,f,g};

In> Drop(lst, -3);
Out> {a,b,c,d};

In> Drop(lst, {2,4});
Out> {a,e,f,g};
siehe auch:
Take , Select , Remove .


Take -- Abspalten eines Bereichs von Listenelementen

mathematische Standardbibliothek
Funktionsaufruf:
Take(list, n)
Take(list, -n)
Take(list, {m,n})
Parameter:
list - eine Liste
n, m - positive ganze Zahlen
Beschreibung:
Diese Funktion spaltet eine Teilliste der Liste "list" ab und entfernt alle restlichen Elemente. Das Ergebnis ist die Teilliste.
Der erste Funktionsaufruf spaltet die ersten "n" Elemente ab. Der zweite Funktionsaufruf spaltet die letzten "n" Elemente ab. Der dritte Funktionsaufruf spaltet die Elemente mit Indizees von "m" bis "n" ab.
Beispiele:
In> lst := {a,b,c,d,e,f,g};
Out> {a,b,c,d,e,f,g};

In> Take(lst, 2);
Out> {a,b};

In> Take(lst, -3);
Out> {e,f,g};

In> Take(lst, {2,4});
Out> {b,c,d};
siehe auch:
Drop , Select , Remove .


Partition -- Umformen einer Liste in Teillisten gleicher Länge

mathematische Standardbibliothek
Funktionsaufruf:
Partition(list, n)
Parameter:
list - eine Liste
n - Länge der Teillisten
Beschreibung:
Diese Funktion zerlegt die Liste "list" in nicht überlappende Teillisten der Länge "n". Das Ergebnis ist eine Liste dieser Teillisten. Ist "n" kein Teiler der Listenlänge, werden die überzähligen Elemente nicht berücksichtigt.
Beispiele:
In> Partition({a,b,c,d,e,f,}, 2);
Out> {{a,b},{c,d},{e,f}};

In> Partition(1 .. 11, 3);
Out> {{1,2,3},{4,5,6},{7,8,9}};
siehe auch:
Take , Permutations .


Assoc -- Suchen eines Listenelements anhand eines Schlüssels

mathematische Standardbibliothek
Funktionsaufruf:
Assoc(key, alist)
Parameter:
key - ein Schlüssel
alist - eine Schlüsselliste
Beschreibung:
Die Schlüsselliste "alist" wird nach einem Element mit dem Schlüssel "key" durchsucht. Das Ergebnis ist das gesuchte Element oder Empty, falls das Element nicht gefunden wurde.

Schlüssellisten werden durch Listen von zweielementigen Listen repräsentiert. Das erste Element der zweielementigen Liste ist der Schlüssel, das zweite Element ist der dem Schlüssel zugeordnete Wert.

Ein zu Assoc(key, alist) äquivalenter Funktionsaufruf ist alist[key].
Beispiele:
In> writer := {};
Out> {};

In> writer["Iliad"] := "Homer";
Out> True;

In> writer["Henry IV"] := "Shakespeare";
Out> True;

In> writer["Ulysses"] := "James Joyce";
Out> True;

In> Assoc("Henry IV", writer);
Out> {"Henry IV","Shakespeare"};

In> Assoc("War and Peace", writer);
Out> Empty;
siehe auch:
AssocIndices , [] , := .


AssocIndices -- Schlüssel einer Schlüsselliste

mathematische Standardbibliothek
Funktionsaufruf:
AssocIndices(alist)
Parameter:
alist - eine Schlüsselliste
Beschreibung:
Das Ergebnis dieser Funktion ist eine Liste aller Schlüssel der Schlüsselliste "alist".
Beispiele:
In> writer := {};
Out> {};

In> writer["Iliad"] := "Homer";
Out> True;

In> writer["Henry IV"] := "Shakespeare";
Out> True;

In> writer["Ulysses"] := "James Joyce";
Out> True;

In> AssocIndices(writer);
Out> {"Iliad","Henry IV","Ulysses"};
siehe auch:
Assoc .


Flatten -- Zerlegen eines Terms in eine Liste

mathematische Standardbibliothek
Funktionsaufruf:
Flatten(expression,operator)
Parameter:
expression - ein Term
operator - ein String, der einen Operator enthält
Beschreibung:
Diese Funktion zerlegt einen Term in die Operanden bezgl. des angegebenen Operators. Das Ergebnis ist eine Liste mit den Operanden.
Diese Funktion wird eingesetzt, um verschachtelte Term aufzuspalten. Sie wird in den Vereinfachungsregeln verwendet.
Beispiele:
In> Flatten(a+b*c+d,"+");
Out> {a,b*c,d};

In> Flatten({a,{b,c},d},"List");
Out> {a,b,c,d};
siehe auch:
UnFlatten .


UnFlatten -- Erzeugen eines Terms aus den Elementen einer Liste

mathematische Standardbibliothek
Funktionsaufruf:
UnFlatten(list, operator, identity)
Parameter:
list - eine Liste
operator - ein Operator
identity - neutrales Element bzgl. des Operators
Beschreibung:
UnFlatten ist die umgekehrte Funktion zu Flatten. Die Elemente der Liste "list" werden mit dem Operator "operator" verknüpft.
Beispiele:
In> UnFlatten({a,b,c},"+",0)
Out> a+b+c;

In> UnFlatten({a,b,c},"*",1)
Out> a*b*c;
siehe auch:
Flatten .


Type -- den Typ eines Ausdrucks bestimmen

interne Funktion
Funktionsaufruf:
Type(expr)
Parameter:
expr - ein Term
Beschreibung:
Der Typ des Terms "expr" wird als String zurückgegeben. Ist z.B. "expr" eine Liste, dann wird als Ergebnis der String "List" zurückgegeben.
Beispiele:
In> Type({a,b,c});
Out> "List";

In> Type(a*(b+c));
Out> "*";

In> Type(123);
Out> "";
siehe auch:
IsAtom , NrArgs .


NrArgs -- Anzahl der Argumente eines Ausdrucks bestimmen

mathematische Standardbibliothek
Funktionsaufruf:
NrArgs(expr)
Parameter:
expr - ein Term
Beschreibung:
Das Ergebnis ist die Anzahl der Argumente des Terms "expr".
Beispiele:
In> NrArgs(f(a,b,c))
Out> 3;

In> NrArgs(Sin(x));
Out> 1;

In> NrArgs(a*(b+c));
Out> 2;
siehe auch:
Type , Length .


BubbleSort -- Sortieren eine Liste

mathematische Standardbibliothek
Funktionsaufruf:
BubbleSort(list, fn)
Parameter:
list - eine Liste
fn - eine Funktionen
Beschreibung:
Diese Funktion sortiert die Elemente der Liste "list" und gibt die sortierte Liste als Ergebnis zurück. Die Listenelemente werden mit Hilfe der Funktion "fn" verglichen. Die Funktion "fn" hat als Argumente zwei Listenelemente, die zu vergleichen sind. Ist das Ergebnis von "fn" True, wird in der sortierten Liste das zweite Argument hinter dem ersten angeordnet, sonst umgekehrt.

Die Funktion verwendet den BubbleSort-Algorithmus.
Beispiele:
In> BubbleSort({4,7,23,53,-2,1}, "<");
Out> {-2,1,4,7,23,53};

In> BubbleSort({4,7,23,53,-2,1}, ">");
Out> {53,23,7,4,1,-2};


Table -- Erzeugen einer Liste über eine Schleife

mathematische Standardbibliothek
Funktionsaufruf:
Table(body, var, from, to, step)
Parameter:
body - ein Term, der mehrfach ausgewertet wird
var - eine Schleifenvariable
from - der Startwert für "var"
to - der Endwert für "var"
step - die Schrittweite in der "var" erhöht wird
Beschreibung:
Diese Funktion erzeugt eine Liste von Werten. Der Term "body" wird dazu in Abhängigkeit von "var" ausgewertet. "var" durchläuft alle Werte von "from" bis "to" mit der Schrittweite "step". Das Ergebnis ist eine Liste aller berechneten Werte.
Beispiele:
In> Table(i!, i, 1, 10, 1);
Out> {1,2,6,24,120,720,5040,40320,362880,3628800};

In> Table(i, i, 3, 16, 4);
Out> {3,7,11,15};

In> Table(i^2, i, 10, 1, -1);
Out> {100,81,64,49,36,25,16,9,4,1};
siehe auch:
For , MapSingle , .. , TableForm .


TableForm -- gibt die Elemente einer Liste formatiert aus

mathematische Standardbibliothek
Funktionsaufruf:
TableForm(list)
Parameter:
list - eine Liste
Beschreibung:
Diese Funktion gibt die Liste "list" formatiert aus. Pro Zeile wird genau ein Listenelement ausgegeben.
Beispiele:
In> TableForm(Table(i!, i, 1, 10, 1));
 1
 2
 6
 24
 120
 720
 5040
 40320
 362880
 3628800
Out> True;
siehe auch:
PrettyForm , Echo , Table .


: , @ , /@ , .. .

Funktionale Operatoren

Diese Operatoren ermöglichen die Programmierung im Stile funktionaler Programmiersprachen wie Miranda und Haskell.

: Listenelement hinzufügen oder Strings aneinanderhängen
@ eine Funktion anwenden
/@ eine Funktion auf alle Elemente einer Liste anwenden
.. Erzeugen einer Liste aufeinanderfolgender ganzer Zahlen


: -- Listenelement hinzufügen oder Strings aneinanderhängen

mathematische Standardbibliothek
Funktionsaufruf:
item : list
string1 : string2
Parameter:
item - ein Listenelement
list - eine Liste
string1 - ein String
string2 - ein String
Beschreibung:
Der erste Funktionsaufruf fügt das Element "item" am Anfang der Liste "list" ein.
Der zweite Funktionsaufruf hängt die Strings "string1" und "string2" aneinander.
Beispiele:
In> a:b:c:{}
Out> {a,b,c};

In> "This":"Is":"A":"String"
Out> "ThisIsAString";
siehe auch:
Concat , ConcatStrings .


@ -- eine Funktion anwenden

mathematische Standardbibliothek
Funktionsaufruf:
fn @ arglist
Parameter:
fn - eine Funktion
arglist - ein Argument oder eine Liste von Argumenten
Beschreibung:
Dieser Operator ist eine Abkürzung für die Funktion Apply. Die Funktion "fn" wird auf alle Argumente in "arglist" angewendet.
Beispiele:
In> "Sin" @ a
Out> Sin(a);

In> {{a},Sin(a)} @ a
Out> Sin(a);

In> "f" @ {a,b}
Out> f(a,b);
siehe auch:
Apply .


/@ -- eine Funktion auf alle Elemente einer Liste anwenden

mathematische Standardbibliothek
Funktionsaufruf:
fn /@ list
Parameter:
fn - eine Funktion
list - eine Liste von Argumenten
Beschreibung:
Dieser Operator ist eine Abkürzung für die Funktion MapSingle. Die Funktion "fn" wird nacheinander auf alle Elemente der Liste "list" angewendet. Das Ergebnis ist eine Liste der berechneten Werte.
Beispiele:
In> "Sin" /@ {a,b}
Out> {Sin(a),Sin(b)};

In> {{a},Sin(a)*a} /@ {a,b}
Out> {Sin(a)*a,Sin(b)*b};
siehe auch:
MapSingle , Map , MapArgs .


.. -- Erzeugen einer Liste aufeinanderfolgender ganzer Zahlen

mathematische Standardbibliothek
Funktionsaufruf:
n .. m
Parameter:
n - eine ganze Zahl
m - eine ganze Zahl
Beschreibung:
Das Ergebnis ist die Liste "{n, n+1, n+2, ..., m}". Ist "m" kleiner als "n", wird eine leere Liste zurückgegeben. Um Parserfehler zu vermeiden, sollte der Operator .. von Leerzeichen umgeben sein, z.B. 1 .. 4.
Beispiele:
In> 1 .. 4
Out> {1,2,3,4};
siehe auch:
Table .


MaxEvalDepth , Hold , Eval , While , Until , If , SystemCall , Function , Use , For , ForEach , Apply , MagArgs , Subst , WithValue , /:, /:: , SetHelpBrowser , TraceStack , TraceExp , TraceRule .

Kontrollfunktionen

MaxEvalDepth Setzen der max. Berechnungstiefe
Hold das Argument nicht berechnen
Eval das Argument berechnen
While eine Schleife durchlaufen, solange eine Bedingung erfüllt ist
Until eine Schleife durchlaufen, bis eine Bedingung erfüllt ist
If eine Verzweigung
SystemCall einen Befehl an die Shell weitergeben
Function eine Funktion definieren
Use eine Datei laden
For eine Schleife in C-Syntax
ForEach alle Elemente einer Liste in einer Schleife abarbeiten
Apply eine Funktion anwenden
MagArgs eine Funktion auf alle Argumente anwenden
Subst eine Substitution durchführen
WithValue eine nur für die aktuelle Berechnung gültige Wertzuweisung
/:, /:: lokale Vereinfachungsregeln
SetHelpBrowser setzt den für die Hilfefunktion zu verwendenden HTML-Browser
TraceStack gibt im Fehlerfall den Inhalt des Stacks aus
TraceExp schrittweise Berechnung von Termen
TraceRule schrittweise Berechnung einer best. Funktion


MaxEvalDepth -- Setzen der max. Berechnungstiefe

interne Funktion
Funktionsaufruf:
MaxEvalDepth(n)
Parameter:
n - eine pos. ganze Zahl
Beschreibung:
Diese Funktion setzt die maximale Berechnungstiefe auf den Wert "n". Die voreingestellte Berechnungstiefe ist n=1000.
Das Ergebnis der Funktion MaxEvalDepth ist True.

Das Festlegen einer max. Berechnungstiefe verhindert unendliche Rekursionen. Wird z.B. die Funktion f(x) := f(x) definiert, dann ruft sich die Funktion f(x) selber auf, was zu einer unendlichen Rekursion führt. Bei Erreichen der max. Berechnungstiefe wird die Rekursion abgebrochen. Indirekte Rekursionen wie z.B.
f(x) := g(x) und g(x) := f(x)
werden abgefangen.
Beispiele:
In> f(x) := f(x)
Out> True;

In> f(x)
Error on line 1 in file [CommandLine]
Max evaluation stack depth reached.
Please use MaxEvalDepth to increase the stack size as needed.

Bei komplexeren Berechnungen kann die max. Berechnungstiefe auch erreicht werden, ohne dass eine unendliche Rekursion vorliegt. In solchen Fällen kann die Berechnungstiefe mit MaxEvalDepth entsprechend angepasst werden.

In> 10 # g(0) <-- 1;
Out> True;

In> 20 # g(n_IsPositiveInteger) <-- 2 * g(n-1);
Out> True;

In> g(1001);
Error on line 1 in file [CommandLine]
Max evaluation stack depth reached.
Please use MaxEvalDepth to increase the stack size as needed.

In> MaxEvalDepth(10000);
Out> True;

In> g(1001);
Out> 214301721437253464189685009812000362112280962341106721488750077674070210224
98722449863967576313917162551893458351062936503742905713846280871969155149397149
60786913554964846197084214921012474228375590836430609294996716388253479753511833
1087892154125829142392955373084335320859663305248773674411336138752;


Hold -- das Argument nicht berechnen

interne Funktion
Funktionsaufruf:
Hold(expr)
Parameter:
expr - ein Term
Beschreibung:
Der Term "expr" wird ohne Berechnung zurückgegeben.
Beispiel:
In> Echo({ Hold(1+1), "=", 1+1 });
 1+1 = 2
Out> True;
siehe auch:
Eval , HoldArg .


Eval -- das Argument berechnen

interne Funktion
Funktionsaufruf:
Eval(expr)
Parameter:
expr - ein Term
Beschreibung:
Diese Funktion berechnet explizit den Term "expr" und gibt das Ergebnis als Funktionswert zurück.
Beispiele:
In> a := x;
Out> x;

In> x := 5;
Out> 5;

In> a;
Out> x;

In> Eval(a);
Out> 5;
Die Variable a hat den Wert x, und x hat den Wert 5. Die Berechnung von a ergibt somit x. Soll der Wert 5 zurückgegeben werden, so muss dies explizit gefordert werden.

Ein verändertes Verhalten ergibt sich, wenn x bei der Zuweisung a := x bereits den Wert 5 hat. a würde dann ebenfalls den Wert 5 erhalten, da der Zuweisungsoperator die rechte Seite zunächst berechnet.
siehe auch:
Hold , HoldArg , :=


While -- eine Schleife durchlaufen, solange eine Bedingung erfüllt ist

interne Funktion
Funktionsaufruf:
While(pred) body
Parameter:
pred - eine boolsche Funktion
body - ein Term
Beschreibung:
Der Term "body" wird berechnet, solange die Funktion "pred" den Wert True liefert. Die While-Schleife ist eine abweisende Schleife. Ist das Ergebnis von "pred" bereits beim ersten Mal False, dann wird der Term "body" gar nicht berechnet.
Beispiele:
In> x := 0;
Out> 0;
In> While (x! < 10^6) [ Echo({x, x!}); x++; ];
 0  1
 1  1
 2  2
 3  6
 4  24
 5  120
 6  720
 7  5040
 8  40320
 9  362880
Out> True;
siehe auch:
Until , For .


Until -- eine Schleife durchlaufen, bis eine Bedingung erfüllt ist

mathematische Standardbibliothek
Funktionsaufruf:
Until(pred) body
Parameter:
pred - eine boolsche Funktion
body - ein Term
Beschreibung:
Der Term "body" wird solange berechnet, bis die Funktion "pred" den Wert True liefert. Die Funktion "pred" wird nach der Berechnung von "body" ausgewertet. Im Unterschied zur While-Schleife wird der Term "body" in jedem Falle mindestens einmal berechnet.
Beispiele:
In> x := 0;
Out> 0;
In> Until (x! > 10^6) [ Echo({x, x!}); x++; ];
 0  1
 1  1
 2  2
 3  6
 4  24
 5  120
 6  720
 7  5040
 8  40320
 9  362880
Out> True;
siehe auch:
While , For .


If -- eine Verzweigung

interne Funktion
Funktionsaufruf:
If(pred, then)
If(pred, then, else)
Parameter:
pred - eine boolsche Funktion
then - ein Term
else - ein Term
Beschreibung:
Die boolsche Funktion "pred" wird ausgewertet. Ist das Ergebnis True, wird der Term "then" berechnet und als Ergebnis zurückgegeben. Liefert "pred" den Wert False, wird der Term "else" berechnet und als Ergebnis zurückgegeben. Ist kein "else"-Zweig vorhanden, wird als Ergebnis False zurückgegeben.
Beispiele:
Das Ergebnis der Funktion sign ist +1, falls das Argument positiv ist, ansonsten -1. Die Funktion lässt sich wie folgt realisieren:

In> mysign(x) := If (IsPositiveReal(x), 1, -1);
Out> True;

In> mysign(Pi);
Out> 1;

In> mysign(-2.5);
Out> -1;

Die so definierte Funktion liefert allerdings falsche Ergebnisse, wenn sich "x" nicht numerisch berechnen lässt:

In> mysign(a);
Out> -1;

Mit der folgenden Lösung tritt dieser Fehler nicht auf:

In> mysign(_x)_IsNumber(N(x)) <-- If (IsPositiveReal(x), 1, -1);
Out> True;


SystemCall -- einen Befehl an die Shell weitergeben

interne Funktion
Funktionsaufruf:
SystemCall(str)
Parameter:
str - ein String
Beschreibung:
Der mit dem String übergebene Befehl wird vom Betriebssystem ausgeführt.
Das Ergebnis ist True.

Dieser Befehl darf im Rahmen der Funktion Secure nicht verwendet werden.
Beispiele:
In einer UNIX-Umgebung liefert der Befehl SystemCall("ls") den Inhalt des aktuellen Verzeichnisses.
siehe auch:
Secure .


Function -- eine Funktion definieren

mathematische Standardbibliothek
Funktionsaufruf:
Function("op", {arg,...}) body
Parameter:
op - Name der Funktion
arg - Argument der Funktion
body - Funktionsterm
Beschreibung:
Mit diesem Befehl lassen sich einfache Funktionen definieren. Der Befehl ist äquivalent zu op(_arg, ...) <-- body.
Beispiele:
In> Function("FirstOf", {list})  list[1];
Out> True;
In> FirstOf({a,b,c});
Out> a;

Hiermit wird eine Funktion FirstOf definiert, die das erste Element einer Liste zurückgibt. Äquivalente Definitionen sind FirstOf(_list) <-- list[1] oder FirstOf(list) := list[1].
siehe auch:
TemplateFunction , Rule , RuleBase , := .


Use -- eine Datei laden

interne Funktion
Funktionsaufruf:
Use(name)
Parameter:
name - Dateiname
Beschreibung:
Die Datei "name" wird geladen, und alle enthaltenen Befehle werden ausgeführt.
Die Datei wird nicht geladen, wenn dies bereits mit einem früheren Aufruf von Use oder durch die Funktion DefLoad geschehen ist.
siehe auch:
Load , DefLoad , DefaultDirectory .


For -- eine Schleife in C-Syntax

mathematische Standardbibliothek
Funktionsaufruf:
For(init, pred, incr) body
Parameter:
init - ein Term
pred - eine boolsche Funktion
incr - ein Term
body - ein Term
Beschreibung:
Mit diesem Befehl wird eine Schleife ähnlich der for-Schleife in der Programmiersprache C realisiert. Zunächst wird einmalig der Term "init" ausgewertet. Danach wird die Funktion "pred" ausgeführt. Ist das Ergebnis True, wird der Term "body" berechnet. Ein Schleifendurchlauf wird mit Berechnung des Terms "incr" beendet. Die Schleife wird solange wiederholt, bis das Ergebnis von "pred" False ist.

Der Befehl wird meist in der Form
For(i=1, i<=10, i++) body
angewendet. Der Term "body" wird hier 10-mal für die Werte i=1 bis i=10 berechnet.
Beispiele:
In> For (i:=1, i<=10, i++) Echo({i, i!});
 1  1
 2  2
 3  6
 4  24
 5  120
 6  720
 7  5040
 8  40320
 9  362880
 10  3628800
Out> True;
siehe auch:
While , Until , ForEach .


ForEach -- alle Elemente einer Liste in einer Schleife abarbeiten

mathematische Standardbibliothek
Funktionsaufruf:
ForEach(var, list) body
Parameter:
var - eine Variable
list - eine Liste von Werten
body - ein Term
Beschreibung:
Der Term "body" mit der Variablen "var" wird nacheinander für alle Listenelemente berechnet.
Das Ergebnis von ForEach ist True.
Beispiele:
 In> ForEach(i,{2,3,5,7,11}) Echo({i, i!});
 2  2
 3  6
 5  120
 7  5040
 11  39916800
Out> True;
siehe auch:
For .


Apply -- eine Funktion anwenden

mathematische Standardbibliothek
Funktionsaufruf:
Apply(fn, arglist)
Parameter:
fn - eine Funktion
arglist - eine Liste von Argumenten
Beschreibung:
Die Funktion "fn" wird auf die Argumente in "arglist" angewendet. Der Funktionswert wird als Ergebnis zurückgegeben.
Der Befehl kann mit dem Operator @ abgekürzt werden.
Beispiele:
In> Apply("+", {5,9});
Out> 14;

In> Apply({{x,y}, x-y^2}, {Cos(a), Sin(a)});
Out> Cos(a)-Sin(a)^2;
siehe auch:
Map , MapSingle , @ .


MagArgs -- eine Funktion auf alle Argumente anwenden

mathematische Standardbibliothek
Funktionsaufruf:
MapArgs(expr, fn)
Parameter:
expr - ein Term
fn - eine Funktion
Beschreibung:
Die Funktion "fn" wird auf jedes im Term "expr" vorkommende Argument angewendet.
Beispiele:
In> MapArgs(f(x,y,z),"Sin");
Out> f(Sin(x),Sin(y),Sin(z));

In> MapArgs({3,4,5,6}, {{x},x^2});
Out> {9,16,25,36};
siehe auch:
MapSingle , Map , Apply .


Subst -- eine Substitution durchführen

mathematische Standardbibliothek
Funktionsaufruf:
Subst(from, to) expr
Parameter:
from - ein Term
to - ein Term
expr - ein Term
Beschreibung:
Jedes Vorkommen des Terms "from" in "expr" wird ersetzt durch "to".
Beispiele:
In> Subst(x, Sin(y)) x^2+x+1;
Out> Sin(y)^2+Sin(y)+1;

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

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

Das letzte Beispiel erklärt sich wie folgt:
Der Term a+b+c wird intern als (a+b)+c gespeichert. Somit ist a+b ein Teilausdruck, b+c jedoch nicht.
siehe auch:
WithValue , /: .


WithValue -- eine nur für die aktuelle Berechnung gültige Wertzuweisung

mathematische Standardbibliothek
Funktionsaufruf:
WithValue(var, val, expr)
WithValue({var,...}, {val,...}, expr)
Parameter:
var - eine Variable
val - ein Wert
expr - ein Term
Beschreibung:
Der Variablen "var" wird der Wert "val" zugewiesen. Der Term "expr" wird mit diesem Wert berechnet und der Funktionswert als Ergebnis zurückgegeben. Danach wird die Wertzuweisung wieder rückgängig gemacht, so dass "var" wieder den urprünglichen Wert hat.

Mit dem zweiten Funktionsaufruf wird dem ersten Element in der Liste von Variablen das erste Element der Werteliste zugewiesen, der zweiten Variablen der zweite Wert usw.
Beispiele:
In> WithValue(x, 3, x^2+y^2+1);
Out> y^2+10;

In> WithValue({x,y}, {3,2}, x^2+y^2+1);
Out> 14;
siehe auch:
Subst , /: .


/:, /:: -- lokale Vereinfachungsregeln

mathematische Standardbibliothek
Funktionsaufruf:
expression /: patterns
expressions /:: patterns
Parameter:
expression - ein Term
patterns - eine Liste von Mustern
Beschreibung:
Mit Hilfe der Operatoren /: und /:: lassen sich die internen Vereinfachungsregeln ergänzen. Soll z.B. in einem Term der Ausdruck Ln(a*b) durch Ln(a)+Ln(b) ersetzt werden, dann lässt sich das wie folgt mit dem /:- Operator realisieren:

In> Sin(x)*Ln(a*b)
Out> Sin(x)*Ln(a*b);
In> % /: { Ln(_x*_y) <- Ln(x)+Ln(y) }
Out> Sin(x)*(Ln(a)+Ln(b));

Die Liste kann mehrere Vereinfachungsregeln enthalten, die auf den Term auf der linken Seite von /: angewendet werden.

Die Muster können dabei in einer der folgenden Formen angegeben werden:

Muster <- Ersetzung

{Muster, Ersetzung}

Lokale Regeln werden mit<- definiert, globale Regeln mit >--.

Der /: Operator durchläuft den Term von oben nach unten und versucht nacheinander die in der Liste angegebenen Regeln anzuwenden. Können die Regeln nicht angewendet werden, dann werden die Teilterme untersucht.

Manchmal ist es erforderlich, den /: Operator mehrfach anzuwenden. Dazu dient der /:: Operator, der die Vereinfachungsregeln so oft anwendet, bis sich der Term nicht mehr verändert.
Wenn sich die Regeln gegenseitig aufheben, kann dies zu einer unendlichen Schleife führen. Dieser Fall kann erkannt werden, wenn zunächst der /: Operator mehrfach angewendet wird.

Beispiele:
In> Sin(u)*Ln(a*b) /: { Ln(_x*_y) <- Ln(x)+Ln(y) }
Out> Sin(u)*(Ln(a)+Ln(b));

In> Sin(u)*Ln(a*b) /:: { a <- 2, b <- 3 }
Out> Sin(u)*Ln(6);
siehe auch:
Subst .


SetHelpBrowser -- setzt den für die Hilfefunktion zu verwendenden HTML-Browser

mathematische Standardbibliothek
Funktionsaufruf:
SetHelpBrowser(helpbrowser)
Parameter:
helpbrowser - ein String
Beschreibung:
Mit dieser Funktion wird der für die Hilfefunktion zu verwendende HTML-Browser festgelegt. Das mit dem String "helpbrowser" bezeichnete Programm wird mit der html-Seite als Argument aufgerufen. Der auch für die Textkonsole geeignete Browser lynx ist voreingestellt. Ein anderer Browser kann dauerhaft als Standard vorgegeben werden, wenn der Befehl in die Datei ~/.yacasrc eingefügt wird.
Beispiele:
In> SetHelpBrowser("netscape")
Out> "netscape";

In> ??
siehe auch:
Help .


TraceStack -- gibt im Fehlerfall den Inhalt des Stacks aus

interne Funktion
Funktionsaufruf:
TraceStack(expression)
Parameter:
expression - ein Term
Beschreibung:
Die Funktion gibt im Fehlerfall den Inhalt des Stacks aus. Dies ist das wichtigste Hilfsmittel bei der Fehlersuche in Yacas. Angezeigt werden die letzten Stackeinträge bevor der Fehler auftrat.

Für jeden Eintrag wird angezeigt, ob es sich um eine interne oder eine benutzerdefinierte Funktion handelt. Für benutzerdefinierte Funktionen wird zusätzlich angegeben, welche Regel bearbeitet wurde.

Die Funktion ist standardmäßig abgeschaltet, da sie die Ausführungsgeschwindigkeit stark beeinträchtigt.
Beispiele:
Das folgende Beispiel zeigt den Stack nachdem die sich selbst aufrufende Funktion durch unendliche Rekursion einen Stacküberlauf verursacht hat:

In> f(x):=f(Sin(x))
Out> True;

In> TraceStack(f(2))
Debug> 982 :  f (Rule # 0 in body)
Debug> 983 :  f (Rule # 0 in body)
Debug> 984 :  f (Rule # 0 in body)
Debug> 985 :  f (Rule # 0 in body)
Debug> 986 :  f (Rule # 0 in body)
Debug> 987 :  f (Rule # 0 in body)
Debug> 988 :  f (Rule # 0 in body)
Debug> 989 :  f (Rule # 0 in body)
Debug> 990 :  f (Rule # 0 in body)
Debug> 991 :  f (Rule # 0 in body)
Debug> 992 :  f (Rule # 0 in body)
Debug> 993 :  f (Rule # 0 in body)
Debug> 994 :  f (Rule # 0 in body)
Debug> 995 :  f (User function)
Debug> 996 :  Sin (Rule # 0 in pattern)
Debug> 997 :  IsList (interne Funktion)
Error on line 1 in file [CommandLine]
Max evaluation stack depth reached.
Please use MaxEvalDepth to increase the stack size as needed.
siehe auch:
TraceExp , TraceRule .


TraceExp -- schrittweise Berechnung von Termen

interne Funktion
Funktionsaufruf:
TraceExp(expr)
Parameter:
expr - ein Term
Beschreibung:
Der Term "expr" wird schrittweise berechnet. Jeder Teilterm wird vor und nach der Berechnung angezeigt. Die Ausgabe vor der Berechnung hat die Form TrEnter(x), wobei mit x der aktuell zu berechnende Teilterm bezeichnet ist. Die Ausgabe nach der Berechnung des Teilterms lautet TrLeave(x,y), wobei y das Ergebnis der Berechnung ist. Die Einrückungstiefe zeigt die Schachtelungsebene an.

Dieser Befehl erzeugt eine große Ausgabeflut. Bei etwas komplexeren Termen sollte daher der Befehl TraceRule verwendet werden.
Beispiele:
In> TraceExp(2+3);
  TrEnter(2+3);
    TrEnter(2);
    TrLeave(2, 2);
    TrEnter(3);
    TrLeave(3, 3);
    TrEnter(IsNumber(x));
      TrEnter(x);
      TrLeave(x, 2);
    TrLeave(IsNumber(x),True);
    TrEnter(IsNumber(y));
      TrEnter(y);
      TrLeave(y, 3);
    TrLeave(IsNumber(y),True);
    TrEnter(True);
    TrLeave(True, True);
    TrEnter(MathAdd(x,y));
      TrEnter(x);
      TrLeave(x, 2);
      TrEnter(y);
      TrLeave(y, 3);
    TrLeave(MathAdd(x,y),5);
  TrLeave(2+3, 5);
Out> 5;
siehe auch:
TraceStack , TraceRule .


TraceRule -- schrittweise Berechnung einer best. Funktion

interne Funktion
Funktionsaufruf:
TraceRule(templ) expr
Parameter:
templ - eine Vorlage
expr - ein Term
Beschreibung:
Die schrittweise Berechnung erfolgt nur für Teilterme die der in der Vorlage "templ" angegeben Form entsprechen. Die Vorlage ist ein Beispiel einer Funktion, die schrittweise berechnet werden soll. Die Teilterme werden vor der Berechnung (angezeigt durch TrEnter) und danach (TrLeave) ausgegeben. Zwischenergebnisse werden vor und nach der Berechnung mit (TrArg) ausgegeben.
Die schrittweise Berechnung kann nur bei in Skripten definierten Funktionen durchgeführt werden.

Der Befehl eignet sich insbesondere zur Untersuchung von Funktionen, die von anderen Funktionen aufgerufen werden.
Beispiele:
In> TraceRule(x+y) 2+3*5+4;
    TrEnter(2+3*5+4);
      TrEnter(2+3*5);
          TrArg(2, 2);
          TrArg(3*5, 15);
      TrLeave(2+3*5, 17);
        TrArg(2+3*5, 17);
        TrArg(4, 4);
    TrLeave(2+3*5+4, 21);
Out> 21;
siehe auch:
TraceStack , TraceExp .


< , > , <= , >= , != , = , Not , And , Or , IsFreeOf , IsZeroVector , IsNonObject , IsEven , IsOdd , IsFunction , IsAtom , IsString , IsNumber , IsList , IsBound , IsBoolean , IsNegativeNumber , IsNegativeInteger , IsPositiveNumber , IsPositiveInteger , IsNotZero , IsNonZeroInteger , IsInfinity , IsPositiveReal , IsNegativeReal , IsConstant .

boolsche Funktionen

Das Ergebnis einer boolschen Funktion ist einer der beiden Wahrheitswerte True oder False.

< testet, ob der linke Operand kleiner als der rechte ist
> testet, ob der linke Operand größer als der rechte ist
<= testet, ob der linke Operand kleiner oder gleich dem rechten ist
>= testet, ob der linke Operand größer oder gleich dem rechten ist
!= testet, ob die beiden Operanden ungleich sind
= testet, ob die beiden Operanden gleich sind
Not logische Negation
And logisches UND
Or logisches ODER
IsFreeOf testet, ob ein Term von einer Variablen abhängig ist
IsZeroVector testet, ob eine Liste nur Nullen enthält
IsNonObject testet, ob das Argument kein Objekt ist
IsEven testet, ob eine ganze Zahl gerade ist
IsOdd testet, ob eine ganze Zahl ungerade ist
IsFunction testet, ob das Argument ein zusammengesetztes Objekt ist
IsAtom testet, ob das Argument ein Atom ist
IsString testet, ob das Argument ein String ist
IsNumber testet, ob das Argument eine Zahl ist
IsList testet, ob das Argument eine Liste ist
IsBound testet, ob dem Argument ein Wert zugeordnet ist
IsBoolean testet, ob das Argument einen Wahrheitswert liefert
IsNegativeNumber testet, ob das Argument eine negative Zahl ist
IsNegativeInteger testet, ob das Argument eine negative ganze Zahl ist
IsPositiveNumber testet, ob das Argument eine positive Zahl ist
IsPositiveInteger testet, ob das Argument eine positive ganze Zahl ist
IsNotZero testet, ob das Argument eine von Null verschiedene Zahl ist
IsNonZeroInteger testet, ob das Argument eine von Null verschiedene ganze Zahl ist
IsInfinity testet, ob das Argument unendlich ist
IsPositiveReal testet, ob das Argument einen positiven Wert ergibt
IsNegativeReal testet, ob das Argument einen negativen Wert ergibt
IsConstant testet, ob das Argument eine Konstante ist


< -- testet, ob der linke Operand kleiner als der rechte ist

mathematische Standardbibliothek
Funktionsaufruf:
e1 < e2
Parameter:
e1, e2 - zwei Ausdrücke
Beschreibung:
Beide Ausdrücke werden ausgewertet. Sind beide numerisch, werden sie verglichen. Das Ergebnis ist True, falls der erste Ausdruck kleiner als der zweite ist, ansonsten False.
Ist ein Ausdruck nicht numerisch, wird dieser mit evtl. berechneten Argumenten zurückgegeben.

Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
Beispiele:
In> 2 < 5;
Out> True;

In> Cos(1) < 5;
Out> Cos(1)<5;

In> N(Cos(1)) < 5;
Out> True
siehe auch:
IsNumber , IsInfinity , N .


> -- testet, ob der linke Operand größer als der rechte ist

mathematische Standardbibliothek
Funktionsaufruf:
e1 > e2
Parameter:
e1, e2 - zwei Ausdrücke
Beschreibung:
Beide Ausdrücke werden ausgewertet. Sind beide numerisch, werden sie verglichen. Das Ergebnis ist True, falls der erste Ausdruck größer als der zweite ist, ansonsten False.
Ist ein Ausdruck nicht numerisch, wird dieser mit evtl. berechneten Argumenten zurückgegeben.

Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
Beispiele:
In> 2 > 5;
Out> False;

In> Cos(1) > 5;
Out> Cos(1)>5;

In> N(Cos(1)) > 5;
Out> False
siehe auch:
IsNumber , IsInfinity , N .


<= -- testet, ob der linke Operand kleiner oder gleich dem rechten ist

mathematische Standardbibliothek
Funktionsaufruf:
e1 <= e2
Parameter:
e1, e2 - zwei Terme
Beschreibung:
Beide Ausdrücke werden ausgewertet. Sind beide numerisch, werden sie verglichen. Das Ergebnis ist True, falls der erste Ausdruck kleiner oder gleich dem zweiten ist, ansonsten False.
Ist ein Ausdruck nicht numerisch, wird dieser mit evtl. berechneten Argumenten zurückgegeben.

Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
Beispiele:
In> 2 <= 5;
Out> True;

In> Cos(1) <= 5;
Out> Cos(1)<=5;

In> N(Cos(1)) <= 5;
Out> True
siehe auch:
IsNumber , IsInfinity , N .


>= -- testet, ob der linke Operand größer oder gleich dem rechten ist

mathematische Standardbibliothek
Funktionsaufruf:
e1 >= e2
Parameter:
e1, e2 - zwei Ausdrücke
Beschreibung:
Beide Ausdrücke werden ausgewertet. Sind beide numerisch, werden sie verglichen. Das Ergebnis ist True, falls der erste Ausdruck größer oder gleich dem zweiten ist, ansonsten False.
Ist ein Ausdruck nicht numerisch, wird dieser mit evtl. berechneten Argumenten zurückgegeben.

Ein Ausdruck ist numerisch, wenn das Ergebnis eine Zahl, ein Bruch oder unendlich ist.
Beispiele:
In> 2 >= 5;
Out> False;

In> Cos(1) >= 5;
Out> Cos(1)>=5;

In> N(Cos(1)) >= 5;
Out> False
siehe auch:
IsNumber , IsInfinity , N .


!= -- testet, ob die beiden Operanden ungleich sind

mathematische Standardbibliothek
Funktionsaufruf:
e1 != e2
Parameter:
e1, e2 - zwei Terme
Beschreibung:
Beide Ausdrücke werden berechnet und verglichen. Das Ergebnis ist True, falls die Ausdrücke ungleich sind, ansonsten False.

Der Ausdruck e1 != e2 ist äquivalent zu Not(e1 = e2).
Beispiele:
In> 1 != 2;
Out> True;

In> 1 != 1;
Out> False;
siehe auch:
= .


= -- testet, ob die beiden Operanden gleich sind

mathematische Standardbibliothek
Funktionsaufruf:
e1 = e2
Parameter:
e1, e2 - zwei Ausdrücke
Beschreibung:
Beide Ausdrücke werden berechnet und verglichen. Das Ergebnis ist True, falls die Ausdrücke gleich sind, ansonsten False.

Hinweis: Getestet wird, ob die beiden Ausdrücke syntaktisch gleich sind. Das Ergebnis kann False sein, obwohl beide Ausdrücke mathematisch gleich sind (s. Beispiele).
Beispiele:
In> e1 := (x+1) * (x-1);
Out> (x+1)*(x-1);

In> e2 := x^2 - 1;
Out> x^2-1;

In> e1 = e2;
Out> False;

In> Expand(e1) = e2;
Out> True;
!= , Equals .


Not -- logische Negation

interne Funktion
Funktionsaufruf:
Not bool
Parameter:
bool - ein boolscher Ausdruck
Beschreibung:
Das Ergebnis ist die logische Negation des Arguments "bool". Hat "bool" den Wert False, ist das Ergebnis True und umgekehrt.
Ist das Argument kein boolscher Ausdruck, wird als Ergebnis der Ausdruck mit evtl. berechneten Argumenten zurückgegeben.
Beispiele:
In> Not True
Out> False;

In> Not False
Out> True;

In> Not(a)
Out> Not a;
siehe auch:
And , Or .


And -- logisches UND

interne Funktion
Funktionsaufruf:
a1 And a2
And(a1,a2,a3,...,an)
Parameter:
a1 .. an - boolsche Werte (True oder False)
Beschreibung:
Das Ergebnis ist True, falls alle Argumente den Wert True haben.
Beispiele:
In> True And False
Out> False;

In> And(True,True)
Out> True;

In> False And a
Out> False;

In> True And a
Out> And(a);

In> And(True,a,True,b)
Out> b And a;
siehe auch:
Or , Not .


Or -- logisches ODER

interne Funktion
Funktionsaufruf:
a1 Or a2
Or(a1,a2,a3,...,an)
Parameter:
a1 .. an - boolsche Werte (True or False)
Beschreibung:
Das Ergebnis ist True, falls mindestens ein Argument den Wert True hat.
Beispiele:
In> True Or False
Out> True;

In> False Or a
Out> Or(a);

In> Or(False,a,b,True)
Out> True;
siehe auch:
And , Not .


IsFreeOf -- testet, ob ein Term von einer Variablen abhängig ist

mathematische Standardbibliothek
Funktionsaufruf:
IsFreeOf(expr, var)
IsFreeOf(expr, {var, ...})
Parameter:
expr - ein Ausdruck
var - eine Variable
Beschreibung:
Das Ergebnis ist True, falls der Ausdruck "expr" (nach Berechnung) nicht von der Variablen "var" abhängt, ansonsten False.

Mit dem zweiten Funktionsaufruf wird getestet, ob der Ausdruck von irgendeinem der Argumente abhängt. Das Ergebnis ist True, falls keines der Argumente in dem Ausdruck vorkommt, sonst False.
Beispiele:
In> IsFreeOf(Sin(x), x);
Out> False;

In> IsFreeOf(Sin(x), y);
Out> True;

In> IsFreeOf(D(x) a*x+b, x);
Out> True;

In> IsFreeOf(Sin(x), {x,y});
Out> False;

Das Ergebnis des dritten Beispiels ist True, weil der Ausdruck D(x) a*x+b zu a berechnet wird und somit nicht mehr von x abhängig ist.
siehe auch:
Contains .


IsZeroVector -- testet, ob eine Liste nur Nullen enthält

mathematische Standardbibliothek
Funktionsaufruf:
IsZeroVector(list)
Parameter:
list - eine Liste
Beschreibung:
Das Ergebnis ist True, falls alle Listenelemente Nullen sind, sonst False.
Beispiele:
In> IsZeroVector({0, x, 0});
Out> False;

In> IsZeroVector({x-x, 1 - D(x) x});
Out> True;
siehe auch:
IsList , ZeroVector .


IsNonObject -- testet, ob das Argument kein Objekt ist

mathematische Standardbibliothek
Funktionsaufruf:
IsNonObject(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Das Ergebnis ist True, falls der Ausdruck "expr" nicht von der Form Object(...) ist, sonst False.
Fehler:
Das Ergebnis ist immer True.
siehe auch:
Object .


IsEven -- testet, ob eine ganze Zahl gerade ist

mathematische Standardbibliothek
Funktionsaufruf:
IsEven(n)
Parameter:
n - eine ganze Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" geradzahlig ist, sonst False.
Beispiele:
In> IsEven(4);
Out> True;

In> IsEven(-1);
Out> False;
siehe auch:
IsOdd , IsInteger .


IsOdd -- testet, ob eine ganze Zahl ungerade ist

mathematische Standardbibliothek
Funktionsaufruf:
IsOdd(n)
Parameter:
n - eine ganze Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" ungeradzahlig ist, sonst False.
Beispiele:
In> IsOdd(4);
Out> False;

In> IsOdd(-1);
Out> True;
siehe auch:
IsEven , IsInteger .


IsFunction -- testet, ob das Argument ein zusammengesetztes Objekt ist

interne Funktion
Funktionsaufruf:
IsFunction(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Die Funktion testet, ob der Ausdruck "expr" ein zusammengesetztes Objekt, also kein Atom ist. Nicht nur Funktionen wie f(x) können getestet werden, sondern auch Ausdrücke wie z.B. x+5 oder auch Listen.
Beispiele:
In> IsFunction(x+5);
Out> True;

In> IsFunction(x);
Out> False;
siehe auch:
IsAtom , IsList , Type .


IsAtom -- testet, ob das Argument ein Atom ist

interne Funktion
Funktionsaufruf:
IsAtom(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Die Funktion testet, ob der Ausdruck "expr" ein Atom ist. Zahlen, Strings und Variablen sind z.B. Atome.
Beispiele:
In> IsAtom(x+5);
Out> Falso;

In> IsAtom(5);
Out> True;
siehe auch:
IsFunction , IsNumber , IsString .


IsString -- testet, ob das Argument ein String ist

interne Funktion
Funktionsaufruf:
IsString(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Die Funktion testet, ob der Ausdruck "expr" ein String ist. Ein String ist eine in Anführungszeichen gesetzte Zeichenfolge wie z.B. "duh".
Beispiele:
In> IsString("duh");
Out> True;

In> IsString(duh);
Out> False;
siehe auch:
IsAtom , IsNumber .


IsNumber -- testet, ob das Argument eine Zahl ist

interne Funktion
Funktionsaufruf:
IsNumber(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Die Funktion testet, ob der Ausdruck "expr" eine Zahl ist. Zahlen können sowohl ganze Zahlen als auch Fließkommazahlen sein. Komplexe Zahlen werden mit Hilfe der Funktion Complex dargestellt, so dass in diesem Fall das Ergebnis von IsNumber den Wert False hat.
Beispiele:
In> IsNumber(6);
Out> True;

In> IsNumber(3.25);
Out> True;

In> IsNumber(I);
Out> False;

In> IsNumber("duh");
Out> False;
siehe auch:
IsAtom , IsString , IsInteger , IsPositiveNumber , IsNegativeNumber , Complex .


IsList -- testet, ob das Argument eine Liste ist

interne Funktion
Funktionsaufruf:
IsList(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Die Funktion testet, ob der Ausdruck "expr" eine Liste ist. Eine Liste ist eine Folge von Ausdrücken, die von geschweiften Klammern eingeschlossen ist, z.B. {2, 3, 5}.
Beispiele:
In> IsList({2,3,5});
Out> True;

In> IsList(2+3+5);
Out> False;
siehe auch:
IsFunction .


IsBound -- testet, ob dem Argument ein Wert zugeordnet ist

interne Funktion
Funktionsaufruf:
IsBound(var)
Parameter:
var - eine Variable
Beschreibung:
Die Funktion testet, ob der Variablen "var" ein Wert zugeordnet ist. Das Argument "var" wird nicht berechnet.
Beispiele:
In> IsBound(x);
Out> False;

In> x := 5;
Out> 5;

In> IsBound(x);
Out> True;
siehe auch:
IsAtom .


IsBoolean -- testet, ob das Argument einen Wahrheitswert liefert

mathematische Standardbibliothek
Funktionsaufruf:
IsBoolean(expression)
Parameter:
expression - ein Ausdruck
Beschreibung:
Das Ergebnis ist True, falls das Argument einen Wahrheitswert liefert. Das Argument kann True, False oder eine boolsche Funktion wie z.B. =, >, <, >=, <=, !=, And, Not, Or sein.
Beispiele:
In> IsBoolean(a)
Out> False;

In> IsBoolean(True)
Out> True;

In> IsBoolean(a And b)
Out> True;
siehe auch:
True , False .


IsNegativeNumber -- testet, ob das Argument eine negative Zahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsNegativeNumber(n)
Parameter:
n - eine Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" eine negative Zahl (n<0) ist. Ist "n" positiv bzw. keine Zahl, ist das Ergebnis False.
Beispiele:
In> IsNegativeNumber(6);
Out> False;

In> IsNegativeNumber(-2.5);
Out> True;
siehe auch:
IsNumber , IsPositiveNumber , IsNotZero , IsNegativeInteger , IsNegativeReal .


IsNegativeInteger -- testet, ob das Argument eine negative ganze Zahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsNegativeInteger(n)
Parameter:
n - ein ganze Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" eine negative ganze Zahl ist. Ist "n" positiv bzw. keine ganze Zahl, ist das Ergebnis False.
Beispiele:
In> IsNegativeInteger(31);
Out> False;

In> IsNegativeInteger(-2);
Out> True;
siehe auch:
IsPositiveInteger , IsNonZeroInteger , IsNegativeNumber .


IsPositiveNumber -- testet, ob das Argument eine positive Zahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsPositiveNumber(n)
Parameter:
n - eine Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" eine positive Zahl (n>0) ist. Ist "n" negativ bzw. keine Zahl, ist das Ergebnis False.
Beispiele:
In> IsPositiveNumber(6);
Out> True;

In> IsPositiveNumber(-2.5);
Out> False;
siehe auch:
IsNumber , IsNegativeNumber , IsNotZero , IsPositiveInteger , IsPositiveReal .


IsPositiveInteger -- testet, ob das Argument eine positive ganze Zahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsPositiveInteger(n)
Parameter:
n - eine ganze Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" eine positive ganze Zahl ist. Ist "n" negativ bzw. keine ganze Zahl, ist das Ergebnis False.
Beispiele:
In> IsPositiveInteger(31);
Out> True;

In> IsPositiveInteger(-2);
Out> False;
siehe auch:
IsNegativeInteger , IsNonZeroInteger , IsPositiveNumber .


IsNotZero -- testet, ob das Argument eine von Null verschiedene Zahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsNotZero(n)
Parameter:
n - eine Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" ungleich Null ist. Ist "n" gleich Null oder keine Zahl, ist das Ergebnis False.
Beispiele:
In> IsNotZero(3.25);
Out> True;

In> IsNotZero(0);
Out> False;
siehe auch:
IsNumber , IsPositiveNumber , IsNegativeNumber , IsNonZeroInteger .


IsNonZeroInteger -- testet, ob das Argument eine von Null verschiedene ganze Zahl ist

mathematische Standardbibliothek
Funktionsaufruf:
IsNonZeroInteger(n)
Parameter:
n - eine ganze Zahl
Beschreibung:
Das Ergebnis ist True, falls "n" ungleich Null ist. Ist "n" gleich Null oder keine ganze Zahl, ist das Ergebnis False.
Beispiele:
In> IsNonZeroInteger(0)
Out> False;

In> IsNonZeroInteger(-2)
Out> True;
siehe auch:
IsPositiveInteger , IsNegativeInteger , IsNotZero .


IsInfinity -- testet, ob das Argument unendlich ist

mathematische Standardbibliothek
Funktionsaufruf:
IsInfinity(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Das Ergebnis ist True, falls der Ausdruck den Wert + Unendlich oder - Unendlich hat.
Beispiele:
In> IsInfinity(10^1000);
Out> False;

In> IsInfinity(-Infinity);
Out> True;
siehe auch:
Integer .


IsPositiveReal -- testet, ob das Argument einen positiven Wert ergibt

mathematische Standardbibliothek
Funktionsaufruf:
IsPositiveReal(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Es wird versucht, einen Näherungswert für den Ausdruck "expr" zu bestimmen. Ist dieser Näherungswert positiv, ist das Ergebnis True. Ist der Näherungswert negativ oder nicht bestimmbar, ist das Ergebnis False.
Rundungsfehler können falsche Ergebnisse zur Folge haben.
Beispiele:
In> IsPositiveReal(Sin(1)-3/4);
Out> True;

In> IsPositiveReal(Sin(1)-6/7);
Out> False;

In> IsPositiveReal(Exp(x));
Out> False;

Im letzten Beispiel ist das Ergebnis False, da x kein Wert zugeordnet ist und somit Exp(x) nicht numerisch berechnet werden kann.
siehe auch:
IsNegativeReal , IsPositiveNumber , N .


IsNegativeReal -- testet, ob das Argument einen negativen Wert ergibt

mathematische Standardbibliothek
Funktionsaufruf:
IsNegativeReal(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Es wird versucht, einen Näherungswert für den Ausdruck "expr" zu bestimmen. Ist dieser Näherungswert negativ, ist das Ergebnis True. Ist der Näherungswert positiv oder nicht bestimmbar, ist das Ergebnis False.
Rundungsfehler können falsche Ergebnisse zur Folge haben.
Beispiele:
In> IsNegativeReal(Sin(1)-3/4);
Out> False;

In> IsNegativeReal(Sin(1)-6/7);
Out> True;

In> IsNegativeReal(Exp(x));
Out> False;

Im letzten Beispiel ist das Ergebnis False, da x kein Wert zugeordnet ist und somit Exp(x) nicht numerisch berechnet werden kann.
siehe auch:
IsPositiveReal , IsNegativeNumber , N .


IsConstant -- testet, ob das Argument eine Konstante ist

mathematische Standardbibliothek
Funktionsaufruf:
IsConstant(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Das Ergebnis ist True, falls der Ausdruck eine Konstante oder eine Funktion mit konstanten Argumenten ist.
Beispiele:
In> IsConstant(Cos(x))
Out> False;

In> IsConstant(Cos(2))
Out> True;

In> IsConstant(Cos(2+x))
Out> False;
siehe auch:
IsNumber , IsInteger , VarList .


CanProve .

Überprüfen logischer Aussagen


CanProve

mathematische Standardbibliothek
Funktionsaufruf:
CanProve(proposition)
Parameter:
proposition - eine logische Aussage
Beschreibung:
Mit dieser Funktion lassen sich logische Aussagen überprüfen.
Ein Beispiel für eine logische Aussage ist:
Wenn aus a b folgt und aus b c, dann folgt aus a c.
Yacas unterstützt folgende Operatoren:

Not   Negation
And  UND
Or    ODER
=>    daraus folgt

Das angegebene Beispiel lautet dann:

( (a=>b) And (b=>c) ) => (a=>c)

Mit Hilfe von CanProve kann die Richtigkeit der Aussage überprüft werden:

In> CanProve(( (a=>b) And (b=>c) ) => (a=>c))
Out> True;

Die Funktion versucht die Aussage "p" zu beweisen, indem gezeigt wird, dass Not p falsch ist. Not p wird dazu schrittweise mit Hilfe folgender Regeln vereinfacht:

Not  ( Not x)  -->  x                      eliminate double negation
x=>y           -->  Not x  Or  y           eliminate implication
Not (x And y)  -->  Not x  Or  Not y       De Morgan's law
Not (x  Or  y) -->  Not x  And Not y       De Morgan's law
(x And y) Or z -->  (x Or z) And (y Or z)  Distribution
x Or (y And z) -->  (x Or y) And (x Or z)  Distribution

Durch Anwendung der Regeln wird die logische Aussage in folgende Form gebracht:

(p1  Or  p2  Or  ...)  And  (q1  Or  q2  Or  ...)  And ...

Ist einer der Klammerausdrücke logisch falsch, ist der gesammte Ausdruck falsch.
Beispiele:
In> CanProve(a  Or   Not a)
Out> True;

In> CanProve(True  Or  a)
Out> True;

In> CanProve(False  Or  a)
Out> a;

In> CanProve(a  And   Not a)
Out> False;

In> CanProve(a  Or b Or (a And b))
Out> a Or b;
siehe auch:
True , False , And , Or , Not .


% , True, False , EndOfFile , Infinity , Pi , Undefined .

Konstanten

% letztes Ergebnis
True, False Wahrheitswerte
EndOfFile Dateiende
Infinity math. Konstante für den Wert unendlich
Pi Kreiszahl, 3.14159...
Undefined undefiniertes Ergebnis


% -- letztes Ergebnis

interne Funktion
Funktionsaufruf:
%
Parameter:
Beschreibung:
Die golbale Variable % repräsentiert das Ergebnis der letzten Berechnung.

Typische Anwendungsbeispiele sind Simplify(%) und PrettyForm(%) zur Vereinfachung und formatierten Ausgabe von Ergebnissen.
Beispiele:
In> Taylor(x,0,5)Sin(x)
Out> x-x^3/6+x^5/120;

In> PrettyForm(%)

     3    5
    x    x
x - -- + ---
    6    120

siehe auch:
LazyGlobal .


True, False -- Wahrheitswerte

interne Funktion
Funktionsaufruf:
True
False
Beschreibung:
True und False sind die typischen Ergebnisse boolscher Ausdrücke wie z.B. 2 < 3 und True And False.
siehe auch:
And , Or , Not .


EndOfFile -- Dateiende

interne Funktion
Funktionsaufruf:
EndOfFile
Beschreibung:
EndOfFile markiert beim Einlesen einer Datei das Dateiende. Enthält eine Datei den Ausdruck EndOfFile;, wird das Einlesen an dieser Stelle abgebrochen.


Infinity -- math. Konstante für den Wert unendlich

mathematische Standardbibliothek
Funktionsaufruf:
Infinity
Beschreibung:
Eine Konstante, die einen unendlich großen Wert repräsentiert. Infinity kann als Ergebnis einer Berechnung zurückgegeben werden.

In den meisten Fällen erlaubt Yacas das Rechnen mit Infinity.

Beispiele:
In> 2*Infinity
Out> Infinity;

In> 2 True;


Pi -- Kreiszahl, 3.14159...

mathematische Standardbibliothek
Funktionsaufruf:
Pi
Beschreibung:
Pi repräsentiert die Kreiszahl. Der Zahlenwert wird erst bei Anwendung der Funktion N(..) eingesetzt.
Beispiele:
In> Sin(3*Pi/2)
Out> -1;

In> Pi
Out> Pi;

In> N(Pi)
Out> 3.1415926535;
siehe auch:
Sin , Cos .


Undefined -- undefiniertes Ergebnis

mathematische Standardbibliothek
Funktionsaufruf:
Undefined
Beschreibung:
Das Ergebnis Undefined wird zurückgegeben, wenn das Ergebnis einer Berechnung mathematisch undefiniert ist.
Beispiele:
In> 2*Infinity
Out> Infinity;

In> 0*Infinity
Out> Undefined;
siehe auch:
Infinity .


:= , Set , Clear , Local , ++ , -- , Object , LazyGlobal , UniqueConstant .

Variablen

:= Wertzuweisung
Set Wertzuweisung
Clear Wertzuweisung aufheben
Local eine Variable als lokal deklarieren
++ Variable inkrementieren
-- Variable dekrementieren
Object unvollständigen Objekttyp erzeugen
LazyGlobal erneute Berechnung einer globalen Variablen
UniqueConstant einzigartige Konstante erzeugen


:= -- Wertzuweisung

mathematische Standardbibliothek
Funktionsaufruf:
var := exp
{var, ...} := {exp, ...}
var[i] := exp
fn(param, ...) := exp
Parameter:
var - eine Variable
exp - ein Ausdruck
i - ein Index
fn - Funktionsname
param - Argument der Funktion "fn"
Beschreibung:
Der := Operator kann vielfältig eingesetzt werden. In allen Fällen erfolgt irgendeine Form der Zuweisung.

Am häufigsten wird der Operator in der ersten Form verwendet. Der Ausdruck auf der rechten Seite wird ausgewertet und das Ergebnis der Variablen auf der linken Seite zugewiesen. Daneben wird das Ergebnis zurückgegeben.

Die zweite Form erlaubt mehrfache Zuweisungen in einer Anweisung. Der erste Eintrag der Liste auf der rechten Seite wird der ersten Variablen in der Liste links zugewiesen, der zweite Eintrag rechts der zweiten Variablen links usw. Die rechte Liste muss mindestens so viele Elemente wie die linke haben. Überzählige Elemente werden ignoriert. Als Ergebnis wird die Liste der zugewiesenen Werte zurückgegeben.

Mit der dritten Form kann einem Listenelement ein neuer Wert zugewiesen werden. Ist "i" eine natürliche Zahl, dann wird dem i-ten Listenelement der Ausdruck auf der rechten Seite zugewiesen. Ist "i" ein String, dann wird "var" als Schlüsselliste interpretiert und der Schlüssel "i" wird dem Ausdruck "exp" zugeordnet. In beiden Fällen wird der Ausdruck auf der rechten Seite vor der Zuweisung berechnet. Das Ergebnis der Zuweisung ist immer True.

Mit der vierten Form wird eine Funktion definiert, z.B. f(x) := x^2. Der Funktionsterm auf der rechten Seite wird nicht sofort berechnet, sondern erst beim Aufruf von "f". Ist dies zu zeitaufwendig, kann eine sofortige Berechnung mit Eval erzwungen werden.
Beispiele:
Eine einfache Zuweisung:

In> a := Sin(x) + 3;
Out> Sin(x)+3;

In> a;
Out> Sin(x)+3;

Eine mehrfache Zuweisung:

In> {a,b,c} := {1,2,3};
Out> {1,2,3};

In> a;
Out> 1;

In> b+c;
Out> 5;

Zuweisung zu einer Liste:

In> xs := { 1,2,3,4,5 };
Out> {1,2,3,4,5};

In> xs[3] := 15;
Out> True;

In> xs;
Out> {1,2,15,4,5};

Erstellen einer Schlüsselliste:

In> alist := {};
Out> {};

In> alist["cherry"] := "red";
Out> True;

In> alist["banana"] := "yellow";
Out> True;

In> alist["cherry"];
Out> "red";

In> alist;
Out> {{"banana","yellow"},{"cherry","red"}};

Definition einer Funktion:

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

In> f(3);
Out> 9;

In> f(Sin(a));
Out> Sin(a)^2;

In> Infix("*&*",10);
Out> True;

In> x1 *&* x2 := x1/x2 + x2/x1;
Out> True;

In> Sin(a) *&* Cos(a);
Out> Tan(1)+Cos(1)/Sin(1);

In> Clear(a);
Out> True;

In> Sin(a) *&* Exp(a);
Out> Sin(a)/Exp(a)+Exp(a)/Sin(a);

Das folgende Beispiel zeigt eine Taylorentwicklung. Die zeitaufwendige Berechnung erfolgt bei jedem Aufruf der Funktion f erneut.

In> f(a) := Taylor(x,0,25) Sin(x);
Out> True;

In> f(1);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;

In> f(2);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;

Die wiederholte Taylorentwicklung kann durch den Einsatz von Eval vermieden werden. Die Taylorentwicklung wird dann nur einmal durchgeführt und nicht bei jedem Funktionsaufruf erneut.

In> f(a) := Eval(Taylor(x,0,25) Sin(x));
Out> True;

In> f(1);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;

In> f(2);
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880-x^11/39916800+x^13/6227020800-x^15/1307
674368000+x^17/355687428096000-x^19/121645100408832000+x^21/51090942171709440000
-x^23/25852016738884976640000+x^25/15511210043330985984000000;
siehe auch:
Set , Clear , [] , Rule , Infix , Eval .


Set -- Wertzuweisung

interne Funktion
Funktionsaufruf:
Set(var, exp)
Parameter:
var - eine Variable
exp - ein Ausdruck
Beschreibung:
Der Ausdruck "exp" wird berechnet und der Variablen "var" zugewiesen. Als Ergbnis wird True zurückgegeben.

Der Funktionsaufruf Set(var, exp) ist äquivalent zu var := exp.
Beispiele:
In> Set(a, Sin(x)+3);
Out> True;

In> a;
Out> Sin(x)+3;
siehe auch:
Clear , := .


Clear -- Wertzuweisung aufheben

interne Funktion
Funktionsaufruf:
Clear(var, ...)
Parameter:
var - eine Variable
Beschreibung:
Alle Wertzuweisungen zu den aufgelisteten Variablen werden gelöscht. In nachfolgenden Berechnungen verbleiben die Variablen solange unverändert bis eine erneute Zuweisung erfolgt. Als Ergbnis wird True zurückgegeben.
Beispiele:
In> a := 5;
Out> 5;

In> a^2;
Out> 25;

In> Clear(a);
Out> True;

In> a^2;
Out> a^2;
siehe auch:
Set , := .


Local -- eine Variable als lokal deklarieren

interne Funktion
Funktionsaufruf:
Local(var, ...)
Parameter:
var - eine Variable
Beschreibung:
Alle als Argument aufgelisteten Variablen werden als lokale Variablen deklariert. Die Argumente werden nicht berechnet. Als Ergbnis wird True zurückgegeben.

Standardmäßig sind alle Variablen in Yacas global. Eine globale Variable hat an jeder Stelle den gleichen Wert. Manchmal ist es sinnvoll, den Gültigkeitsbereich einer Variablen einzuschränken. Wird eine Variable als lokal deklariert, kann nur innerhalb eines Prog Blocks (oder dem syntaktischen äquivalenten [ ] Block) auf diese Variable zugegriffen werden. Eine innerhalb eines Blocks aufgerufene Funktion hat auf die lokalen Variablen des Blocks keinen Zugriff, außer der Zugriff wird explizit mit UnFence erlaubt.
Beispiele:
In> a := 3;
Out> 3;

In> [ a := 4; a; ];
Out> 4;

In> a;
Out> 4;

In> [ Local(a); a := 5; a; ];
Out> 5;

In> a;
Out> 4;

Im ersten Block ist a eine globale Variable. Die Änderung innerhalb des Blocks wirkt sich auch ausserhalb aus.
Im zweiten Block wird a lokal definiert. Die Änderung innerhalb des Blocks hat keinen Einfluss auf die globale Variable a.
siehe auch:
LocalSymbols , Prog , [] , UnFence .


++ -- Variable inkrementieren

mathematische Standardbibliothek
Funktionsaufruf:
var++
Parameter:
var - eine Variable
Beschreibung:
Die Variable "var" wird inkrementiert, d.h. um Eins vergrößert. Der Ausdruck x++ ist äquivalent zu x := x + 1 mit dem Unterschied, dass die Zuweisung den neuen Wert zurückgibt, während x++ immer das Ergebnis True hat.
Beispiele:
In> x := 5;
Out> 5;

In> x++;
Out> True;

In> x;
Out> 6;
siehe auch:
-- , := .


-- -- Variable dekrementieren

mathematische Standardbibliothek
Funktionsaufruf:
var--
Parameter:
var - eine Variable
Beschreibung:
Die Variable "var" wird dekrementiert, d.h. um Eins verkleinert. Der Ausdruck x-- ist äquivalent zu x := x - 1 mit dem Unterschied, dass die Zuweisung den neuen Wert zurückgibt, während x-- immer das Ergebnis True hat.
Beispiele:
In> x := 5;
Out> 5;

In> x--;
Out> True;

In> x;
Out> 4;
siehe auch:
++ , := .


Object -- unvollständigen Objekttyp erzeugen

mathematische Standardbibliothek
Funktionsaufruf:
Object("pred", exp)
Parameter:
pred - Objekttyp
exp - ein Ausdruck
Beschreibung:
Das Ergebnis dieser Funktion ist "exp", falls das Ergebnis von "pred" angewendet auf "exp" True ist.
Beispiele:
In> a := Object("IsNumber", x);
Out> Object("IsNumber",x);

In> Eval(a);
Out> Object("IsNumber",x);

In> x := 5;
Out> 5;

In> Eval(a);
Out> 5;
siehe auch:
IsNonObject .


LazyGlobal -- erneute Berechnung einer globalen Variablen

interne Funktion
Funktionsaufruf:
LazyGlobal(var)
Parameter:
var - eine Variable
Beschreibung:
LazyGlobal erzwingt die Berechnung einer globalen Variablen, wenn diese verwendet wird.

Bei den globalen Variablen % und I wird diese Funktion eingesetzt.

Das an die globale Variable gebundene Objekt wird erst berechnet, wenn die Variable aufgerufen wird. Das Ergebnis dieser Berechnung wird in der globalen Variablen gespeichert. Eine erneute Berechnung findet danach nicht mehr statt:

In> a:=Hold(Taylor(x,0,30)Sin(x))
Out> Taylor(x,0,30)Sin(x);
In> LazyGlobal(a)

Beim ersten Aufruf von a wird der Ausdruck Taylor(...) berechnet und das Ergebnis a zugewiesen. Bei folgenden Aufrufen von a wird das Ergebnis ohne erneute Berechnung zurückgegeben.
Beispiele:
In> a:=Hold(2+3)
Out> 2+3;

In> a
Out> 2+3;

In> LazyGlobal(a)
Out> True;

In> a
Out> 5;
siehe auch:
Set , Clear , Local , % , I .


UniqueConstant -- einzigartige Konstante erzeugen

mathematische Standardbibliothek
Funktionsaufruf:
UniqueConstant()
Parameter:
keine
Beschreibung:
Diese Funktion erzeugt bei jedem Aufruf eine neue einzigartige Konstante C#. Die Konstanten unterscheiden sich in der angefügten Zahl #.
Beispiele:
In> UniqueConstant()
Out> C9

In>  UniqueConstant()
Out> C10
siehe auch:
LocalSymbols .


FullForm , Echo , PrettyForm , EvalFormula , Write , WriteString , Space , NewLine , FromFile , FromString , ToFile , ToString , Read , LispRead , ReadToken , Load , Use , DefLoad , FindFile , PatchLoad , Nl .

Ein- und Ausgabe

In diesem Kapitel werden die Befehle für die Ein- und Ausgabe erläutert. Alle Ausgabebefehle schreiben in den sogenannten "current output", die meisten Eingabebefehle lesen vom "current input". In beiden Fällen ist das normalerweise die Konsole. Die Ein- und Ausgabe kann aber durch spezielle Befehle auch umgeleitet werden.

FullForm Ausgabe eines Ausdrucks im LISP-Format
Echo Ausgaberoutine
PrettyForm formatierte Ausgabe
EvalFormula formatierte Darstellung einer Berechnung
Write elementare Ausgaberoutine
WriteString elementare Ausgaberoutine für Strings
Space Ausgabe von Leerzeichen
NewLine Ausgabe von Zeilenvorschüben
FromFile Eingabeumleitung zum Lesen aus einer Datei
FromString Eingabeumleitung zum Lesen aus einem String
ToFile Ausgabeumleitung zur Ausgabe in eine Datei
ToString Ausgabeumleitung zur Ausgabe in einen String
Read einen Ausdruck einlesen
LispRead einen Ausdruck in LISP-Syntax einlesen
ReadToken ein Token einlesen
Load alle in einer Datei enthaltenen Ausdrücke auswerten
Use eine Datei einmalig einlesen
DefLoad eine .def-Datei einlesen
FindFile eine Datei suchen
PatchLoad alle Befehle zwischen <? und ?> einer Datei ausführen
Nl Zeilenvorschubzeichen


FullForm -- Ausgabe eines Ausdrucks im LISP-Format

interne Funktion
Funktionsaufruf:
FullForm(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Der Ausdruck "expr" wird berechnet und gefolgt von einem Zeilenvorschub im LISP-Format ausgegeben. Der berechnete Ausdruck wird als Funktionswert zurückgegeben.
Beispiele:
In> FullForm(a+b+c);
(+ (+ a b )c )
Out> a+b+c;

In> FullForm(2*I*b^2);
(* (Complex 0 2 )(^ b 2 ))
Out> Complex(0,2)*b^2;

Das erste Beispiel zeigt die interne Darstellung des Ausdrucks a+b+c. Im zweiten Beispiel wird zunächst 2*I umgerechnet in Complex(0,2), bevor der Ausdruck ausgegeben wird.
siehe auch:
LispRead , Listify , Unlist .


Echo -- Ausgaberoutine

mathematische Standardbibliothek
Funktionsaufruf:
Echo(item)
Echo(list)
Parameter:
item - ein Ausdruck
list - eine Liste
Beschreibung:
Der Ausdruck "item" wird berechnet und gefolgt von einem Zeilenvorschub ausgegeben. Ist "item" ein String, wird dieser ohne die Anführungszeichen ausgegeben.

In der zweiten Form werden alle Listenelemente nacheinander ausgegeben.

Das Ergebnis von Echo ist immer True.
Beispiele:
In> Echo(5+3);
 8
Out> True;

In> Echo({"The square of two is ", 2*2});
The square of two is  4
Out> True;

Zum Ausdrucken einer Liste muss die zweite Form verwendet werden:

In> Echo({a,b,c});
a  b  c
Out> True;

In> Echo({{a,b,c}});
{a,b,c}
Out> True;
siehe auch:
PrettyForm , Write , WriteString .


PrettyForm -- formatierte Ausgabe

mathematische Standardbibliothek
Funktionsaufruf:
PrettyForm(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Der Ausdruck "expr" wird berechnet und das Ergebnis übersichtlich formatiert ausgegeben.
Beispiele:
In> Taylor(x,0,9)Sin(x)
Out> x-x^3/6+x^5/120-x^7/5040+x^9/362880;

In> PrettyForm(%)

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

Out> True;
siehe auch:
EvalFormula , PrettyPrinter .


EvalFormula -- formatierte Darstellung einer Berechnung

mathematische Standardbibliothek
Funktionsaufruf:
EvalFormula(expr)
Parameter:
expr - ein Ausdruck
Beschreibung:
Stellt eine Berechnung in ansprechender Form dar.
Beispiele:
In> EvalFormula(Taylor(x,0,7)Sin(x))

                                      3    5      7
                                     x    x      x
Taylor( x , 0 , 7 , Sin( x ) ) = x - -- + --- - ----
                                     6    120   5040

Out> True
siehe auch:
PrettyForm .


Write -- elementare Ausgaberoutine

interne Funktion
Funktionsaufruf:
Write(expr, ...)
Parameter:
expr - ein Ausdruck
Beschreibung:
Der Ausdruck "expr" wird berechnet und auf dem "current output" ausgegeben. Sind mehrere Argumente vorhanden, werden diese nacheinander ausgegeben. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> Write(1);
1Out> True;
In> Write(1,2);
 1 2Out> True;

Write schließt die Ausgabe nicht mit einem Zeilenvorschub ab, so dass der Out> Prompt unmittelbar auf die Ausgabe folgt.
siehe auch:
Echo , WriteString .


WriteString -- elementare Ausgaberoutine für Strings

interne Funktion
Funktionsaufruf:
WriteString(string)
Parameter:
string - ein String
Beschreibung:
Der String "string" wird ohne die Anführungszeichen auf dem "current output" ausgegeben. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> Write("Hello, world!");
"Hello, world!"Out> True;
In> WriteString("Hello, world!");
Hello, world!Out> True;

siehe auch:
Echo , Write .


Space -- Ausgabe von Leerzeichen

mathematische Standardbibliothek
Funktionsaufruf:
Space()
Space(nr)
Parameter:
nr - Anzahl der Leerzeichen
Beschreibung:
Der Befehl Space() gibt "nr" Leerzeichen auf dem "current output" aus. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> Space(5);
     Out> True;
siehe auch:
Echo , Write , NewLine .


NewLine -- Ausgabe von Zeilenvorschüben

mathematische Standardbibliothek
Funktionsaufruf:
NewLine()
NewLine(nr)
Parameter:
nr - Anzahl der Zeilenvorschübe
Beschreibung:
Der Befehl NewLine() gibt "nr" Zeilenvorschübe auf dem "current output" aus. Als Ergebnis wird immer True zurückgegeben.
Beispiele:
In> NewLine();

Out> True;
siehe auch:
Echo , Write , Space .


FromFile -- Eingabeumleitung zum Lesen aus einer Datei

interne Funktion
Funktionsaufruf:
FromFile(name) body
Parameter:
name - ein Dateiname
body - eine Anweisung
Beschreibung:
Der "current input" wird mit der Datei "name" verbunden. Danach wird die Anweisung "body" ausgeführt. Eingaben, die während der Ausführung von "body" erwartet werden, werden aus der Datei gelesen. Zum Schluss wird die Datei geschlossen und das Ergebnis der Anweisung zurückgegeben.
Beispiele:
Angenommen die Datei foo enthält

2 + 5;

Die Datei lässt sich z.B. folgendermaßen auslesen:
In> FromFile("foo") res := Read();
Out> 2+5;

In> FromFile("foo") res := ReadToken();
Out> 2;
siehe auch:
ToFile , FromString , Read , ReadToken .


FromString -- Eingabeumleitung zum Lesen aus einem String

interne Funktion
Funktionsaufruf:
FromString(str) body;
Parameter:
str - ein String
body - eine Anweisung
Beschreibung:
Die Anweisung "body" wird ausgeführt, wobei alle notwendigen Eingaben aus dem String "str" gelesen werden. Das Ergebnis der Anweisung wird zurückgegeben.
Beispiele:
In> FromString("2+5; this is never read") res := Read();
Out> 2+5;

In> FromString("2+5; this is never read") res := Eval(Read());
Out> 7;
siehe auch:
ToString , FromFile , Read , ReadToken .


ToFile -- Ausgabeumleitung zur Ausgabe in eine Datei

interne Funktion
Funktionsaufruf:
ToFile(name) body
Parameter:
name - ein Dateiname
body - eine Anweisung
Beschreibung:
Der "current output" wird mit der Datei "name" verbunden. Danach wird die Anweisung "body" ausgeführt. Alle während der Ausführung von "body" erfolgenden Ausgaben werden in die Datei "name" geschrieben. Zum Schluss wird die Datei geschlossen und das Ergebnis der Anweisung zurückgegeben.
Beispiele:
Betrachten wir zunächst folgende Anweisung:

In> [ Echo("Result:");  PrettyForm(Taylor(x,0,9) Sin(x)); ];
Result:

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

Out> True;

Die Ausgabe soll jetzt in eine Datei umgeleitet werden:

In> ToFile("out") [ Echo("Result:");  PrettyForm(Taylor(x,0,9) Sin(x)); ];
Out> True;

Der Dateiinhalt nach der Anweisung:

Result:

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

siehe auch:
FromFile , ToString , Echo , Write , WriteString , PrettyForm , Taylor .


ToString -- Ausgabeumleitung zur Ausgabe in einen String

interne Funktion
Funktionsaufruf:
ToString() body
Parameter:
body - eine Anweisung
Beschreibung:
Die Anweisung "body" wird ausgeführt. Die während der Ausführung erfolgenden Ausgaben werden als String zurückgegeben.
Beispiele:
In> str := ToString() \
In>        [ WriteString("The square of 8 is "); Write(8^2); ];
Out> "The square of 8 is  64";
siehe auch:
FromFile , ToString , Echo , Write , WriteString .


Read -- einen Ausdruck einlesen

interne Funktion
Funktionsaufruf:
Read()
Parameter:
keine
Beschreibung:
Ein Ausdruck wird vom "current input" eingelesen und unausgewertet zurückgegeben.
Beispiele:
In> FromString("2+5;") Read();
Out> 2+5;

In> FromString("") Read();
Out> EndOfFile;
siehe auch:
FromFile , FromString , LispRead , ReadToken , Write .


LispRead -- einen Ausdruck in LISP-Syntax einlesen

interne Funktion
Funktionsaufruf:
LispRead()
Parameter:
keine
Beschreibung:
Ein Ausdruck in LISP-Syntax wird vom "current input" eingelesen und unausgewertet zurückgegeben.

Der Ausdruck a+b lautet in LISP-Syntax (+ a b).
Beispiele:
In> FromString("(+ a b)") LispRead();
Out> a+b;

In> FromString("(List (Sin x) (- (Cos x)))") LispRead();
Out> {Sin(x),-Cos(x)};
siehe auch:
FromFile , FromString , Read , ReadToken , FullForm .


ReadToken -- ein Token einlesen

interne Funktion
Funktionsaufruf:
ReadToken()
Parameter:
keine
Beschreibung:
Ein Token wird vom "current input" eingelesen und unausgewertet zurückgegeben.

Ein Token ist die kleinste Einheit, in die ein Ausdruck zerlegt werden kann. Z.B. besteht a := foo aus den drei Token a, := und foo.
Beispiele:
In> FromString("a := Sin(x)") \
In>    While((tok := ReadToken()) != EndOfFile) Echo(tok);
a
:=
Sin
(
x
)
Out> True;
siehe auch:
FromFile , FromString , Read , LispRead .


Load -- alle in einer Datei enthaltenen Ausdrücke auswerten

interne Funktion
Funktionsaufruf:
Load(name)
Parameter:
name - ein Dateiname
Beschreibung:
Die Datei "name" wird geöffnet. Danach werden alle in der Datei stehenden Anweisungen eingelesen und ausgewertet. Das Ergebnis von Load ist immer true.
siehe auch:
Use , DefLoad , DefaultDirectory , FindFile .


Use -- eine Datei einmalig einlesen

interne Funktion
Funktionsaufruf:
Use(name)
Parameter:
name - ein Dateiname
Beschreibung:
Wurde die Datei bereits geladen, z.B. durch einen der Befehle Use oder DefLoad, dann passiert gar nichts. In allen anderen Fällen werden die in der Datei enthaltenen Anweisungen eingelesen und ausgewertet. Das Ergebnis von Use ist immer true.

Diese Funktion stellt sicher, dass eine Datei geladen ist, jedoch nicht ein zweites Mal eingelesen wird.
siehe auch:
Load , DefLoad , DefaultDirectory .


DefLoad -- eine .def-Datei einlesen

interne Funktion
Funktionsaufruf:
DefLoad(name)
Parameter:
name - ein Dateiname (ohne die Endung .def)
Beschreibung:
Die Dateiendung .def wird an den Dateinamen angehängt und die Datei mit dem daraus resultierenden Namen wird geladen. Die Datei sollte eine Liste von Anweisungen enthalten, die mit einer geschweiften Klammer } abgeschlossen wird. Die Datei wird erst dann vollständig geladen, wenn eine der aufgelisteten Funktionen aufgerufen wird. Die Startzeit kann so deutlich verkürzt werden, da zunächst nur die Liste geladen wird.
siehe auch:
Load , Use , DefaultDirectory .


FindFile -- eine Datei suchen

interne Funktion
Funktionsaufruf:
FindFile(name)
Parameter:
name - ein Dateiname
Beschreibung:
Das Ergebnis dieser Funktion ist der vollständige Pfad zur Datei "name". Wird die Datei nicht gefunden, wird ein leerer String zurückgegeben.
siehe auch:
Load , DefaultDirectory .


PatchLoad -- alle Befehle zwischen einer Datei ausführen

interne Funktion
Funktionsaufruf:
PatchLoad(name)
Parameter:
name - Dateiname
Beschreibung:
Diese Funktion lädt die Datei "name" und gibt den Inhalt auf dem "current output" aus. Enthält die Datei durch die Zeichen <? und ?> begrenzte Blöcke, dann wird der Text innerhalb dieser Blöcke als Folge von Yacas-Anweisungen interpretiert. Die Anweisungen werden ausgewertet, eventuelle Ausgaben erfolgen auf dem "current output".

In eine ansonsten statische Textdatei lassen sich somit dynamische Anteile einbetten.
siehe auch:
PatchString , Load .


Nl -- Zeilenvorschubzeichen

mathematische Standardbibliothek
Funktionsaufruf:
Nl()
Beschreibung:
Das Funktionsergebnis ist ein String, der einen Zeilenvorschub enthält.
Beispiele:
In> WriteString("First line" : Nl() : "Second line" : Nl());
First line
Second line
Out> True;
siehe auch:
NewLine .


SetStringMid , StringMid , String, Atom , ConcatStrings , LocalSymbols , PatchString .

Das Arbeiten mit Strings

SetStringMid einen Teilstring verändern
StringMid einen Teilstring kopieren
String, Atom ein Atom in einen String umwandeln und umgekehrt
ConcatStrings Strings zusammenfügen
LocalSymbols einzigartige lokale Variablen erzeugen
PatchString in einem String enthaltene Anweisungen ausführen


SetStringMid -- einen Teilstring verändern

interne Funktion
Funktionsaufruf:
SetStringMid(index,substring,string)
Parameter:
index - ein Index
substring - ein Teilstring
string - ein String
Beschreibung:
Der Teilstring "substring" überschreibt ab der Position "index" den String "string". Das Original bleibt erhalten, der neue String wird als Ergebnis zurückgegeben.
Beispiele:
In> SetStringMid(3,"XY","abcdef")
Out> "abXYef";
siehe auch:
StringMid , Length .


StringMid -- einen Teilstring kopieren

interne Funktion
Funktionsaufruf:
StringMid(index,length,string)
Parameter:
index - ein Index
length - die Länge des Teilstrings
string - ein String
Beschreibung:
Als Ergebnis wird ein Teilstring der Länge "length" ab der Position "index" zurückgegeben. Teilstrings können auch mit dem []-Operator herauskopiert werden.
Beispiele:
In> StringMid(3,2,"abcdef")
Out> "cd";

In> "abcdefg"[2 .. 4]
Out> "bcd";
siehe auch:
SetStringMid , Length .


String, Atom -- ein Atom in einen String umwandeln und umgekehrt

interne Funktion
Funktionsaufruf:
Atom(string)
String(atom)
Parameter:
atom - ein Atom
string - ein String
Beschreibung:
Das Ergebnis von Atom(string) ist ein mit dem Inhalt des Strings bezeichnetes Atom.
String ist die Umkehrfunktion zu Atom.
Beispiele:
In> String(a)
Out> "a";

In> Atom("a")
Out> a;


ConcatStrings -- Strings zusammenfügen

interne Funktion
Funktionsaufruf:
ConcatStrings(strings)
Parameter:
strings - ein oder mehrere Strings
Beschreibung:
Die als Argumente übergebenen Strings werden aneinandergehängt und als neuer String zurückgegeben.
Beispiele:
In> ConcatStrings("a","b","c")
Out> "abc";
siehe auch:
: .


LocalSymbols -- einzigartige lokale Variablen erzeugen

Standard math library
Funktionsaufruf:
LocalSymbols(...)body
Parameter:
... - eine List von Symbolen
body - ein Ausdruck
Beschreibung:
Mit Hilfe der als Argument übergebenen Symbole werden lokale Variablen erzeugt, deren Namen die Form $ haben. Der Index wird so gewählt, dass eine einzigartige Variable entsteht.

Die Funktion erzeugt freie Variablen, die garantiert unbenutzt sind.

Beispiele:
In> LocalSymbols(a,b)a+b
Out> $a6+ $b6;
siehe auch:
UniqueConstant .


PatchString -- in einem String enthaltene Anweisungen ausführen

interne Funktion
Funktionsaufruf:
PatchString(string)
Parameter:
string - ein String
Beschreibung:
Enthält der String "string" einen durch die Zeichen <? und ?> markierten Teilstring, dann wird der Teilstring als Folge von Yacas-Anweisungen interpretiert, die der Reihe nach ausgeführt werden.
Beispiele:
In> PatchString("Two plus three is <? Write(2+3); ?> ");
Out> "Two plus three is 5 ";
siehe auch:
PatchLoad .


Prog , Check , Prefix , Postfix , Bodied , Infix , IsInfix , IsPrefix , IsPostfix , OpPrecedence , RightAssociative , LeftPrecedence , RightPrecedence , RuleBase , Rule , HoldArg , Retract , UnFence , MacroSet , MacroClear , MacroLocal , MacroRuleBase , MacroRule , Secure .

Programmierung


/* comment */

Ein Kommentar in einem Quelltext.


Prog(...)

Die Funktion wertet die Argumente der Reihe nach aus. Das letzte Ergebnis wird zurückgegeben. Alternativ können die Argumente auch einfach in eckige Klammern gesetzt werden:
"Prog(a,b);" ist äquivalent zu "[a;b;];".


Check(predicate,"error")

Die boolsche Funktion "predicate" wird ausgewertet. Ist das Ergebnis False, wird das Programm an dieser Stelle abgebrochen und auf der Kommandozeile "error" ausgegeben.


Prefix("operator")

Mit dieser Funktion wird ein neuer "prefix"-Operator definiert. "prefix"-Operatoren stehen links vom Argument. Die Funktion kann auch mit einem zusätzlichen Argument für den Rang des Operators aufgerufen werden.


Postfix("operator")

Mit dieser Funktion wird ein neuer "postfix"-Operator definiert. "postfix"-Operatoren stehen rechts vom Argument.


Bodied("operator", precedence)

Mit dieser Funktion wird ein neuer "bodied"-Operator definiert.


Infix("operator", precedence)

Mit dieser Funktion wird ein neuer "infix"-Operator definiert. "infix"-Operatoren stehen zwischen zwei Argumenten. Der Rang des Operators wird mit "precedence" festgelegt.


IsInfix("str"), IsPrefix("str"), IsPostfix("str")

Die Funktionen testen, ob "str" ein "infix"-, "prefix"-, oder "postfix"-Operator ist. Das Ergebnis von z.B. IsInfix("+") ist True.


OpPrecedence("str")

Als Ergebnis wird der Rang des "infix"-Operators "str" zurückgegeben.


RightAssociative("operator")

Die Funktion macht den Operator "operator" rechts-assoziativ. Beispielsweise wird die Multiplikation durch RightAssociative("*") rechts-assoziativ.
Die Funktion sollte überlegt eingesetzt werden, da es eine entsprechende Funktion für links-Assoziativität nicht gibt.


LeftPrecedence("operator", precedence), RightPrecedence("operator", precedence)

Mit dieser Funktion wird der Parser angewiesen, den links bzw. rechts vom "infix"-Operator "operator" stehenden Ausdruck in Klammern zu setzen, wenn der Rang größer als "precedence" ist.
Diese Funktion ist z.B. notwendig, um a-(b-c) richtig auszuwerten. Die Ausdrücke a+b+c und a+(b+c) sind äquivalent, nicht jedoch a-b-c und a-(b-c).


RuleBase("operator", {params})

Mit dieser Funktion wird ein neuer Eintrag in der Regeltabelle erzeugt.


Rule("operator", arity, precedence, predicate) body

Mit dieser Funktion wird eine Regel für die Funktion "operator" definiert. Der Rang wird mit "precedence" festgelegt, "arity" ist die Anzahl der Argumente. Für Funktionen gleichen Namens lassen sich verschiedene Regeln definieren, wenn sich die Funktionen in der Anzahl der Parameter unterscheiden. Regeln mit niedrigem Rang werden vor Regeln mit hohem Rang angewendet.


HoldArg("operator", parameter)

Diese Funktion verhindert sofortige die Berechnung des Parameters "parameter" in dem Ausdruck "operator". Der Parameter wird erst berechnet, wenn er tatsächlich gebraucht wird.


Retract("operator", arity)

Diese Funktion entfernt die spezifizierte Regel.


UnFence("operator", arity)

Diese Funktion wird auf eine benutzerdefinierte Funktion "operator" angewendet. Sie ermöglicht den Zugriff auf die lokalen Variablen der aufrufenden Funktion. Die Funktionen For und ForEach nutzen diese Eigenschaft.


MacroSet, MacroClear, MacroLocal, MacroRuleBase, MacroRule

Diese Funktionen entsprechen den oben beschriebenen nicht-Makro-Funktionen, mit der Ausnahme, dass die Argumente vor der Ausführung berechnet werden.


Secure(body)

Die Anweisung "body" wird in einer sicheren Umgebung ausgeführt, in der Dateizugriffe und Aufrufe von Systemfunktionen nicht erlaubt sind. Unbekannte Skripte (z.B. aus dem Internet) können so sicher ausgeführt werden.


MathNot , MathAnd , MathOr , BitAnd , BitOr , BitXor , Equals , LessThan , GreaterThan , ShiftLeft , ShiftRight .

interne Funktionen


MathNot(expression)

Das Ergebnis der Funktion ist False, falls das Ergebnis von "expression" True ist und umgekehrt.


MathAnd(...)

Das Ergebnis der Funktion ist True, falls alle Argumente das Ergebnis True haben. Die Argumente werden der Reihe nach ausgewertet. Liefert ein Argument False, wird die Funktion mit dem Ergebnis False beendet. Die übrigen Argumente werden nicht mehr berechnet.


MathOr(...)

Das Ergebnis der Funktion ist True, falls mindestens ein Argument das Ergebnis True hat. Die Argumente werden der Reihe nach ausgewertet. Liefert ein Argument True, wird die Funktion mit dem Ergebnis True beendet. Die übrigen Argumente werden nicht mehr berechnet.


BitAnd(n, m), BitOr(n, m), BitXor(n, m)

Diese Funktionen verknüpfen die zwei Zahlen "n" und "m" bitweise.


Equals(a, b)

Die Ausdrücke "a" und "b" werden zunächst berechnet und danach verglichen. Das Ergebnis ist True, wenn die Ergebnisse identisch sind, sonst False.


LessThan(a, b), GreaterThan(a, b)

Die Zahlen "a" und "b" werden verglichen.


Math...

MathGcd(n, m) (Greatest Common Divisor), MathAdd(x, y), MathSubtract(x, y), MathMultiply(x, y), MathDivide(x, y), MathSqrt(x) (Square root), MathFloor(x), MathCeil(x), MathAbs(x), MathMod(x, y), MathExp(x), MathLog(x) (Natural logarithm), MathPower(x, y), MathSin(x), MathCos(x), MathTan(x), MathArcSin(x), MathArcCos(x), MathArcTan(x), MathDiv(x,y), MathMod(x, y)

Alle "Math"-Funktionen erwarten als Argument eine Zahl.


Fast...

FastExp(x), FastLog(x) (Natural logarithm), FastPower(x, y), FastSin(x), FastCos(x), FastTan(x), FastArcSin(x), FastArcCos(x), FastArcTan(x)

Die "Fast"-Funktionen verwenden die entspr. Funktionen der C-Bibliothek. Diese sind schneller als die Yacas-Funktionen mit beliebiger Genauigkeit.


ShiftLeft(number, bits), ShiftRight(number, bits)

Die Zahl "number" wird um "bits" Stellen bitweise nach links bzw. rechts verschoben.


DllLoad , StubApiCStart , StubApiCShortIntegerConstant , StubApiCInclude , StubApiCFunction , StubApiCRemark , StubApiCSetEnv , StubApiCFile , StubApiCStruct .

Die Plugin-Technik von Yacas

Yacas unterstützt dynamisch ladbare Bibliotheken, mit denen die Funktionalität zur Laufzeit vergrößert werden kann. Mit einem entsprechenden Plugin wäre es z.B. möglich, spezielle Funktionen für numerische Berechnungen einzubinden.

Die Plugin-Schnittstelle ist zurzeit noch im experimentellen Stadium. Einige Beispiele für Plugins befinden sich im plugins/ Verzeichnis. Die Plugins müssen nach der Installation von Yacas gesondert compiliert werden. Das plugins/ Verzeichnis enthält eine README-Datei mit weiteren Hinweisen.

Neben dem Plugin-Mechanismus gibt es das ebenfalls noch in der Entwicklung befindliche Modul 'cstubgen', mit dem Plugins ohne größeren Aufwand erstellt werden können. Das 'cstubgen' Modul erzeugt eine c++ Datei, die sich compilieren und mit der Standardbibliothek linken lässt. Funktionen aus dem Plugin lassen sich dann so wie die eingebauten Yacas Funktionen aufrufen. Das plugins/ Verzeichnis enthält auch hierfür Beispiele (Dateien mit der Endung api.stub).

Zusätzlich zur c++ Datei generiert 'cstubgen' automatisch eine Dokumentationsdatei mit der Endung 'Beschreibung'.

Zurzeit arbeitet der Plugin-Mechanismus nur auf Betriebssystemen, die das ELF-Binärformat unterstützen, wie z.B. Linux.

Der folgende Abschnitt erfordert Kenntnisse in der C++ Programmierung.


DllLoad

interne Funktion
Funktionsaufruf:
DllLoad(file)
Parameter:
file - Dateiname des Plugins
Beschreibung:
Die Funktion lädt eine dynamische Bibliothek (unter Linux eine Datei mit der Endung .so). Der Dateiname ist mit vollständigem Pfad anzugeben.
Beispiele:
In> DllLoad("./libopengl.so");
Out> True;
siehe auch:


StubApiCStart

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCStart()
Parameter:
Beschreibung:
Der Quellcode zum Erzeugen einer c "stub"-Datei muss mit dieser Funktion beginnen.
siehe auch:
StubApiCShortIntegerConstant , StubApiCInclude , StubApiCFunction , StubApiCFile , StubApiCSetEnv .


StubApiCShortIntegerConstant

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCShortIntegerConstant(const, value)
Parameter:
const - ein String, der eine globale Variable repräsentiert
value - eine pos. ganze Zahl
Beschreibung:
Mit dieser Funktion wird die Zahl "value" der Variablen "const" zugewiesen. Die Zahl sollte den Typ "short integer" haben. Damit lassen sich mit #define definierte Konstanten in Yacas einbinden. Enthält die Bibliothek z.B. die Anweisung
#define FOO 10
Dann wird dieser Wert aus der Quelldatei mit
StubApiCShortIntegerConstant("FOO", "FOO")
der globalen Yacas Variablen "FOO" zugewiesen.
siehe auch:
StubApiCStart , StubApiCInclude , StubApiCFunction , StubApiCFile , StubApiCSetEnv .


StubApiCInclude

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCInclude(file)
Parameter:
file - Dateiname
Beschreibung:
Mit dieser Funktion kann eine "include"-Datei spezifiziert werden (z.B. eine "header"-Datei der Bibliothek). Die Begrenzer müssen mit angegeben werden. So wird z.B. die "header"-Datei der opengl-Bibliothek mit
StubApiCInclude("<GL/gl.h>")
eingebunden. Liegt die Datei im aktuellen user-Verzeichnis, dann lautet der Funktionsaufruf:
StubApiCInclude("\"GL/gl.h"\")
siehe auch:
StubApiCStart , StubApiCShortIntegerConstant , StubApiCFunction , StubApiCFile , StubApiCSetEnv .


StubApiCFunction

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCFunction(returntype, fname, args)
StubApiCFunction(returntype, fname, fname2, args)
Parameter:
returntype - Type der Bibliotheksfunktion
fname - interner Funktionsname
fname2 - (optional) Yacas-Funktionsname
args - Liste von Argumenten der Funktion
Beschreibung:
Mit dieser Funktion wird eine Bibliotheksfunktion deklariert. Der c++ Code wird dann durch 'cstubgen' generiert.

Alle Argumente sind als Strings (eingeschlossen in Anführungszeichen) anzugeben.

Wird "fname2" nicht angegeben, dann wird hierfür "fname" angenommen.

Zurzeit werden die Funktionstypen "int", "double" und "void" unterstützt.
Die unterstützten Argumenttypen sind "int", "double" und "input_string".
Argumenttypen werden als String wie z.B. "int" angegeben oder als Liste mit einem zusätzlichen Element für den Namen der Variablen, z.B. {"int", "n"}. Die Variable wird dann in die automatisch erzeugte Dokumentationsdatei übernommen.
Beispiele:
Im folgenden wird die opengl-Funktion glVertex3d definiert. Die Funktion vom Typ "void" hat drei Argumente vom Typ "double".

StubApiCFunction("void", "glVertex3d", {"double","double","double"});
siehe auch:
StubApiCStart , StubApiCShortIntegerConstant , StubApiCInclude , StubApiCFile , StubApiCSetEnv .


StubApiCRemark

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCRemark(string)
Parameter:
string - ein String
Beschreibung:
Die Funktion fügt den String "string" zur automatisch erzeugten Dokumentationsdatei .description hinzu. Wird die Funktion unmittelbar nach einer Funktionsdeklaration aufgerufen, dann kann mit dem String ein Kommentar zur Beschreibung dieser Funktion eingefügt werden.
siehe auch:
StubApiCShortIntegerConstant , StubApiCInclude , StubApiCFunction , StubApiCSetEnv , StubApiCFile .


StubApiCSetEnv

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCSetEnv(func)
Parameter:
func - ein String
Beschreibung:
Dieser Befehl lässt das Plugin die Funktion "func" aufrufen. Als Argument von "func" wird LispEnvironment& aEnvironment angenommen. Damit wird die Umgebungsklasse, die für fast alles innerhalb von Yacas notwendig ist, einer globalen Variablen zugewiesen.

Das Plugin muss eine Funktion der Form

static LispEnvironment* env = NULL;
void GlutSetEnv(LispEnvironment& aEnv)
{
    env = &aEnv;
}

enthalten.
Der Aufruf von

StubApiCSetEnv("GlutSetEnv");

ruft die Funktion GlutSetEnv beim Laden des Plugins auf. Alle Funktionen des Plugins haben damit Zugriff auf die Yacas Umgebungsklasse.
siehe auch:
StubApiCStart , StubApiCShortIntegerConstant , StubApiCInclude , StubApiCFunction , StubApiCFile .


StubApiCFile

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCFile(basename)
Parameter:
basename - ein String
Beschreibung:
Die Funktion generiert die c++ "stub" Datei "basename.cc" sowie die Dokumentationsdatei "basename.description".
siehe auch:
StubApiCStart , StubApiCShortIntegerConstant , StubApiCInclude , StubApiCFunction , StubApiCSetEnv .


StubApiCStruct

mathematische Standardbibliothek
Funktionsaufruf:
StubApiCStruct(name)
StubApiCStruct(name, freefunction)
Parameter:
name - ein String
freefunction - ein String
Beschreibung:
Die Funktion deklariert eine Struktur "name". Der Name sollte mit einem "*" abschließen, um zu verdeutlichen, dass es sich um einen Zeiger handelt. Die Struktur kann als Argument oder Ergebnis von Plugin-Funktionen verwendet werden.

Fehlt das zweite Argument "freefunction", dann wird die Struktur mit einem Aufruf von free(...) aus dem Speicher entfernt, ansonsten wird die Funktion "freefunction" aufgerufen. Damit lassen sich evtl. erforderlich Operationen vor dem Entfernen der Struktur aus dem Speicher ausführen.
Beispiele:
Eine Struktur wird in der "header"-Datei definiert:

typedef struct SomeStruct
{
  int a;
  int b;
} SomeStruct;

In der "stub"-Datei erfolt die Deklaration durch Aufruf von:

StubApiCStruct("SomeStruct*")


IsGeneric , GenericTypeName , ArrayCreate , ArraySize , ArrayGet , ArraySet , ArrayCreateFromList , ListFromArray .

generische Objekte

Generische Objekte sind in c++ implementierte Objekte, auf die der Yacas-Interpreter zugreifen kann.


IsGeneric(object)

Eine boolsche Funktion, die testet, ob das Argument eine generisches Objekt ist.


GenericTypeName(object)

Das Ergebnis ist ein String mit dem Namen des generischen Objekts.
Beispielsweise ist das Ergebnis von GenericTypeName(ArrayCreate(10,1)) "Array".


ArrayCreate(size, init)

Die Funktion erzeugt ein Array mit "size" Elementen, die alle mit dem Wert "init" initialisiert werden.


ArraySize(array)

Das Ergebnis ist die Größe (Anzahl der Elemente) eines Arrays.


ArrayGet(array, index)

Das Ergebnis ist das Element an der Stelle "index" im Array "array". Das erste Element hat den Index 1!
Auf die Elemente eines Arrays kann auch mit dem []-Operator zugegriffen werden. Die Aufrufe array[index] und ArrayGet(array, index) sind äquivalent.


ArraySet(array, index, element)

Diese Funktion weist dem Element an der Stelle "index" des Arrays "array" den Wert "element" zu. Das erste Element hat den Index 1!
Die Wertzuweisung ist ebenfalls mit dem []-Operator möglich. Die Aufrufe array[index]:=element und ArraySet(array, index, element) sind äquivalent.


ArrayCreateFromList(list)

Die Funktion erzeugt aus der Liste "list" ein Array.


ListFromArray(array)

Die Funktion erzeugt aus dem Array "array" eine Liste.