10.1 Funktionen für Zahlen

Funktion: abs (z) ¶

Die Funktion abs ist die Betragsfunktion und für das numerische und symbolische Rechnen geeignet. Ist das Argument z eine reelle oder komplexe Zahl wird der Betrag berechnet. Wenn möglich werden allgemeine Ausdrücke mit der Betragsfunktion vereinfacht. Maxima kann Ausdrücke mit der Betragsfunktion integrieren und ableiten sowie Grenzwerte von Ausdrücken mit der Betragsfunktion ermitteln. Das Paket abs_integrate erweitert Maximas Möglichkeiten, Integrale mit der Betragsfunktion zu lösen.

Die Betragsfunktion wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Siehe die Funktion cabs, um den Betrag eines komplexen Ausdrucks oder einer Funktion zu berechnen.

Beispiele:

Berechnung des Betrages für reelle und komplexen Zahlen sowie numerische Konstanten und unendliche Größen. Das erste Beispiel zeigt, wie die Betragsfunktion von Maxima auf die Elemente einer Liste angewendet wird.

(%i1) abs([-4, 0, 1, 1+%i]);
(%o1)                  [4, 0, 1, sqrt(2)]

(%i2) abs((1+%i)*(1-%i));
(%o2)                           2
(%i3) abs(%e+%i);
                                2
(%o3)                    sqrt(%e  + 1)
(%i4) abs([inf, infinity, minf]);
(%o4)                   [inf, inf, inf]

Vereinfachung von Ausdrücken mit der Betragsfunktion.

(%i5) abs(x^2);
                                2
(%o5)                          x
(%i6) abs(x^3);
                             2
(%o6)                       x  abs(x)

(%i7) abs(abs(x));
(%o7)                       abs(x)
(%i8) abs(conjugate(x));
(%o8)                       abs(x)

Ableitung und Integrale mit der Betragsfunktion. Wird das Paket abs_integrate geladen, können weitere Integrale mit der Betragsfunktion gelöst werden. Das letzte Beispiel zeigt die Laplacetransformation der Betragsfunktion. Siehe laplace.

(%i9) diff(x*abs(x),x),expand;
(%o9)                       2 abs(x)

(%i10) integrate(abs(x),x);
                             x abs(x)
(%o10)                       --------
                                2

(%i11) integrate(x*abs(x),x);
                           /
                           [
(%o11)                     I x abs(x) dx
                           ]
                           /

(%i12) load("abs_integrate")$
(%i13) integrate(x*abs(x),x);
                      2           3
                     x  abs(x)   x  signum(x)
(%o13)               --------- - ------------
                         2            6

(%i14) integrate(abs(x),x,-2,%pi);
                               2
                            %pi
(%o14)                      ---- + 2
                             2

(%i15) laplace(abs(x),x,s);
                               1
(%o15)                         --
                                2
                               s

Funktion: ceiling (x) ¶

Die Funktion ceiling ist für das numerische und symbolische Rechnen geeignet.

Ist das Argument x eine reelle Zahl, gibt ceiling die kleinste ganze Zahl zurück, die größer oder gleich x ist.

Die Funktion ceiling gibt auch dann einen numerischen Wert zurück, wenn das Argument ein konstanter Ausdruck ist, wie zum Beispiel 1+%e, der zu einer reellen Zahl ausgewertet werden kann. In diesem Fall wird der konstante Ausdruck in eine große Gleitkommazahl umgewandelt, auf die die Funktion ceiling angewendet wird. Aufgrund von Rundungsfehlern bei der Umwandlung in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von ceiling kommen. Um diese zu minimieren, wird die Anzahl der Stellen fpprec für die Berechnung von ceiling um drei Stellen erhöht.

Ist das Argument expr der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.

Wenn möglich werden Ausdrücke mit der Funktion ceiling von Maxima vereinfacht. Maxima kennt insbesondere Vereinfachungen für den Fall, dass das Argument der Funktion ceiling ein Ausdruck mit den Funktionen floor oder round ist. Weiterhin werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte herangezogen. Siehe Funktionen und Variablen für Fakten.

ceiling wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Siehe auch die Funktionen floor und round.

Beispiele:

(%i1) ceiling(ceiling(x));
(%o1)                      ceiling(x)
(%i2) ceiling(floor(x));
(%o2)                       floor(x)
(%i3) declare (n, integer)$
(%i4) ceiling([n, abs(n), max (n, 6)]);
(%o4)               [n, abs(n), max(6, n)]
(%i5) assume (x > 0, x < 1)$
(%i6) ceiling (x);
(%o6)                           1

Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als integervalued deklariert werden. Die Funktionen ceiling und floor können diese Information nutzen, um Ausdrücke zu vereinfachen.

(%i1) declare (f, integervalued)$
(%i2) floor (f(x));
(%o2)                         f(x)
(%i3) ceiling (f(x) - 1);
(%o3)                       f(x) - 1

Maxima kennt das Integral der Funktion ceiling.

(%i1) integrate(ceiling(x),x);
               (- ceiling(x) + 2 x + 1) ceiling(x)
(%o1)          -----------------------------------
                                2

Funktion: entier (x) ¶

entier ist eine andere Bezeichnung für die Funktion floor. Siehe floor.

Funktion: floor (x) ¶

Die Funktion floor ist für das numerische und symbolische Rechnen geeignet.

Ist das Argument x eine reelle Zahl, gibt floor die größte ganze Zahl zurück, die kleiner oder gleich x ist.

Die Funktion floor gibt auch dann einen numerischen Wert zurück, wenn das Argument ein konstanter Ausdruck ist, wie zum Beispiel 1+%e, der zu einer reellen Zahl ausgewertet werden kann. In diesem Fall wird der konstante Ausdruck in eine große Gleitkommazahl umgewandelt, auf die die Funktion floor angewendet wird. Aufgrund von Rundungsfehlern bei der Umwandlung in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von floor kommen. Um diese zu minimieren, wird die Anzahl der Stellen fpprec für die Berechnung von floor um drei Stellen erhöht.

Ist das Argument x der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.

Wenn möglich werden Ausdrücke mit der Funktion floor von Maxima vereinfacht. Maxima kennt insbesondere Vereinfachungen für den Fall, dass das Argument der Funktion floor ein Ausdruck mit den Funktionen ceiling oder round ist. Weiterhin werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte herangezogen. Siehe Funktionen und Variablen für Fakten.

floor wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Siehe auch die Funktionen ceiling und round.

Beispiele:

(%i1) floor(ceiling(x));
(%o1)                      ceiling(x)
(%i2) floor(floor(x));
(%o2)                       floor(x)
(%i3) declare(n, integer);
(%o3)                         done
(%i4) floor([n, abs(n), min (n, 6)]);
(%o4)                [n, abs(n), min(6, n)]
(%i5) assume(x>0, x<1)$
(%i6) floor(x);
(%o6)                           0

Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als integervalued deklariert werden. Die Funktionen ceiling und floor können diese Information nutzen, um Ausdrücke zu vereinfachen.

(%i1) declare (f, integervalued)$
(%i2) floor(f(x));
(%o2)                         f(x)
(%i3) ceiling(f(x) - 1);
(%o3)                       f(x) - 1

Maxima kennt das Integral der Funktion floor.

(%i6) integrate(floor(x),x);
                 (- floor(x) + 2 x - 1) floor(x)
(%o6)            -------------------------------
                                2

Funktion: fix (x) ¶

fix ist eine andere Bezeichnung für die Funktion floor. Siehe floor.

Funktion: lmax (L) ¶

Ist das Argument L eine Liste oder Menge, wird die Funktion max auf die Elemente der Liste oder Menge angewendet und das Ergebnis zurückgegeben. Ist L keine Liste oder Menge, signalisiert Maxima einen Fehler.

Beispiel:

(%i1) L:[1+%e, %pi, 3];
(%o1)                   [%e + 1, %pi, 3]
(%i1) lmax(L);
(%o1)                        %e + 1

Funktion: lmin (L) ¶

Ist das Argument L eine Liste oder Menge, wird die Funktion min auf die Elemente der Liste oder Menge angewendet und das Ergebnis zurückgegeben. Ist L keine Liste oder Menge, signalisiert Maxima einen Fehler.

Beispiel:

(%i1) L:[1+%e, %pi, 3];
(%o1)                   [%e + 1, %pi, 3]
(%i2) lmin(L);
(%o2)                           3

Funktion: max (x_1, …, x_n) ¶

Sind alle Argumente x_1, …, x_n Zahlen oder konstante Ausdrücke wie zum Beispiel 1+%e oder sin(1), dann wird der größte Zahlenwert zurückgegeben. Sind symbolische Variablen oder allgemeine Ausdrücke unter den Argumenten, gibt Maxima einen vereinfachten Ausdruck zurück. Die unendliche Größen inf und minf können als Argument auftreten.

Die Vereinfachung der Funktion max kann kontrolliert werden, in dem mit der Funktion put dem Symbol trylevel zu der Eigenschaft maxmin ein Wert zwischen 1 bis 3 gegeben wird. Folgende Werte können mit der Funktion put gesetzt werden:

put(trylevel, 1, maxmin)

trylevel hat den Wert 1. Das ist der Standardwert. Maxima führt keine besonderen Vereinfachungen aus.

put(trylevel, 2, maxmin)

Maxima wendet die Vereinfachung max(e,-e) --> |e| an.

put(trylevel, 3, maxima)

Maxima wendet die Vereinfachung max(e,-e) --> |e| an und versucht Ausdrücke zu eliminieren, die zwischen zwei anderen Argumenten liegen. So wird zum Beispiel max(x, 2*x, 3*x) zu max(x, 3*x) vereinfacht.

Mit dem Kommando get(trylevel, maxmin) wird der aktuelle Wert für das Symbol trylevel angezeigt. Siehe die Funktion get.

max berücksichtigt bei der Vereinfachung von Ausdrücken die Aussagen und Fakten der aktiven Kontexte. Siehe das Kapitel Funktionen und Variablen für Fakten.

Beispiele:

(%i1) max(1.6, 3/2, 1);
(%o1)                          1.6
(%i2) max(1.5b0,1.5,3/2);

                                3
(%o2)                           -
                                2

(%i3) max(%e,%pi,1,2,3);
(%o3)                          %pi
(%i4) max(1+%e,%pi,1,2,3);
(%o4)                        %e + 1
(%i5) max(minf,inf);
(%o5)                          inf
(%i6) assume(a>b);
(%o6)                        [a > b]
(%i7) max(a,b);
(%o7)                           a

Funktion: min (x_1, …, x_n) ¶

Sind alle Argumente x_1, …, x_n Zahlen oder konstante Ausdrücke wie zum Beispiel 1+%e oder sin(1), dann wird der kleinste Zahlenwert zurückgegeben. Sind symbolische Variablen oder allgemeine Ausdrücke unter den Argumenten, gibt Maxima einen vereinfachten Ausdruck zurück. Die unendliche Größen inf und minf können als Argument auftreten.

Die Vereinfachung der Funktion min kann kontrolliert werden, in dem mit der Funktion put dem Symbol trylevel zu der Eigenschaft maxmin ein Wert zwischen 1 bis 3 gegeben wird. Folgende Werte können mit der Funktion put gesetzt werden:

put(trylevel, 1, maxmin)

trylevel hat den Wert 1. Das ist der Standardwert. Maxima führt keine besonderen Vereinfachungen aus.

put(trylevel, 2, maxmin)

Maxima wendet die Vereinfachung min(e,-e) --> |e| an.

put(trylevel, 3, maxima)

Maxima wendet die Vereinfachung min(e,-e) --> |e| an und versucht Ausdrücke zu eliminieren, die zwischen zwei anderen Argumenten liegen. So wird zum Beispiel min(x, 2*x, 3*x) zu min(x, 3*x) vereinfacht.

Mit dem Kommando get(trylevel, maxmin) wird der aktuelle Wert für das Symbol trylevel angezeigt. Siehe die Funktion get.

min berücksichtigt bei der Vereinfachung von Ausdrücken die Aussagen und Fakten der aktiven Kontexte. Siehe das Kapitel Funktionen und Variablen für Fakten.

Beispiele:

(%i1) min(1.6, 3/2, 1);
(%o1)                           1
(%i2) min(1.5b0,1.5,3/2);
                                3
(%o2)                           -
                                2
(%i3) min(%e,%pi,3);
(%o3)                          %e
(%i4) min(1+%e,%pi,3);
(%o4)                           3
(%i5) min(minf,inf);
(%o5)                         minf
(%i6) assume(a>b);
(%o6)                        [a > b]
(%i7) min(a,b);
(%o7)                           b

Funktion: round (x) ¶

Die Funktion round ist für das numerische und symbolische Rechnen geeignet.

Ist das Argument x eine reelle Zahl, gibt round die am nächsten liegende ganze Zahl zurück. Vielfache von 1/2 werden auf die nächste gerade ganze Zahl gerundet.

Die Funktion round gibt auch dann einen numerischen Wert zurück, wenn das Argument ein konstanter Ausdruck ist, wie zum Beispiel 1+%e, der zu einer reellen Zahl ausgewertet werden kann. In diesem Fall wird der konstante Ausdruck in eine große Gleitkommazahl umgewandelt, auf die die Funktion round angewendet wird. Aufgrund von Rundungsfehlern bei der Umwandlung in Gleitkommazahlen kann es zu Fehlern bei der Berechnung von round kommen. Um diese zu minimieren, wird die Anzahl der Stellen fpprec für die Berechnung von round um drei Stellen erhöht.

Ist das Argument x der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.

Wenn möglich werden Ausdrücke mit der Funktion round von Maxima vereinfacht. Maxima kennt insbesondere Vereinfachungen für den Fall, dass das Argument der Funktion round ein Ausdruck mit den Funktionen ceiling oder floor ist. Weiterhin werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte herangezogen. Siehe Funktionen und Variablen für Fakten.

round wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Siehe auch die Funktionen ceiling und floor.

Beispiele:

(%i1) round(floor(x));
(%o1)                       floor(x)
(%i2) round(round(x));
(%o2)                       round(x)
(%i3) declare(n, integer);
(%o3)                         done
(%i4) round([n, abs(n), min(n,6)]);
(%o4)                [n, abs(n), min(6, n)]

Sind die Werte einer Funktion eine Teilmenge der ganzen Zahlen, kann diese als integervalued deklariert werden. Die Funktion round kann diese Information nutzen, um Ausdrücke zu vereinfachen.

(%i1) declare(f, integervalued);
(%o1)                         done
(%i2) round(f(x));
(%o2)                         f(x)
(%i3) round(f(x) - 1);
(%o3)                       f(x) - 1

Funktion: signum (z) ¶

Die Signumfunktion signum ist für das numerische und symbolische Rechnen geeignet. Ist das Argument z eine Zahl, ist das Ergebnis 0, 1 oder -1, wenn die Zahl Null, positiv oder negativ ist. Das Argument kann auch ein konstanter Ausdruck wie %pi oder 1+%e sein. Ist das Argument z eine komplexe Zahl, vereinfacht die der Ausdruck signum(z) zu z/abs(z).

Ist das Argument z keine Zahl oder kein konstanter Ausdruck, versucht Maxima den Ausdruck zu vereinfachen. Maxima kann die Funktion signum differenzieren. Wird das Paket abs_integrate geladen, kann Maxima Integrale mit der Funktion signum lösen.

signum wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Beispiele:

Ergebnisse für verschiedene Zahlen und konstante Ausdrücke. Die Beispiele zeigen, dass das Ergebnis der Signumfunktion den Typ der Zahl erhält. Die unendlichen Größen minf und inf können als Argument auftreten.

(%i1) signum([-1.5, 0, 0.0, 1.5, 1.5b0, %e, sin(1), cos(4)]);
(%o1)        [- 1.0, 0, 0.0, 1.0, 1.0b0, 1, 1, - 1]
(%i2) signum(1+%i);
                          %i         1
(%o2)                   ------- + -------
                        sqrt(2)   sqrt(2)
(%i3) signum([minf,inf]);
(%o3)                      [- 1, 1]

Vereinfachungen der Signumfunktion.

(%i3) signum(x*y);
(%o3)                  signum(x) signum(y)
(%i4) signum(-x);
(%o4)                      - signum(x)

Wird das Paket abs_integrate geladen, kann Maxima Integrale mit der Signumfunktion lösen. Ausdrücke mit der Signumfunktion können differenziert werden.

(%i5) load("abs_integrate")$

(%i6) integrate(signum(x),x);
(%o6)                        abs(x)

(%i7) integrate(sin(x)*signum(x),x);
(%o7)               (1 - cos(x)) signum(x)

(%i7) diff(%,x);
(%o7)                  signum(x) sin(x)

10.2 Funktionen für komplexe Zahlen

Funktion: cabs (expr) ¶

Berechnet den Betrag eines komplexen Ausdrucks expr. Im Unterschied zu der Funktion abs, zerlegt die Funktion cabs einen komplexen Ausdruck immer in einen Realteil und Imaginärteil, um den komplexen Betrag zu berechnen. Sind x und y zwei reelle Variablen oder Ausdrücke, berechnet die Funktion cabs den Betrag des komplexen Ausdrucks x + %i*y als:

                           2    2
                     sqrt(y  + x )

Die Funktion cabs nutzt Symmetrieeigenschaften und implementierte Eigenschaften komplexer Funktionen, um den Betrag eines Ausdrucks zu berechnen. Sind solche Eigenschaften für eine Funktion vorhanden, können diese mit der Funktion properties angezeigt werden. Eigenschaften, die das Ergebnis der Funktion cabs bestimmen, sind: mirror symmetry, conjugate function und complex characteristic.

cabs ist eine Verbfunktion, die nicht für das symbolische Rechnen geeignet ist. Für das symbolische Rechnen wie der Integration oder der Ableitung von Ausdrücken mit der Betragsfunktion muss die Funktion abs verwendet werden.

Das Ergebnis der Funktion cabs kann die Betragsfunktion abs und den Arkustangens atan2 enthalten.

cabs wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet.

Siehe auch die Funktionen rectform, realpart, imagpart, carg, conjugate, und polarform für das Rechnen mit komplexen Zahlen.

Beispiele:

Zwei Beispiele mit der Wurzelfunktion sqrt und der Sinusfunktion sin.

(%i1) cabs(sqrt(1+%i*x));
                             2     1/4
(%o1)                      (x  + 1)
(%i2) cabs(sin(x+%i*y));
                    2        2         2        2
(%o2)       sqrt(cos (x) sinh (y) + sin (x) cosh (y))

Die Funktion erf hat Spiegelsymmetrie, die hier für die Berechnung des komplexen Betrages angewendet wird.

(%i3) cabs(erf(x+%i*y));

                                          2
           (erf(%i y + x) - erf(%i y - x))
(%o3) sqrt(--------------------------------
                          4
                                                               2
                                (erf(%i y + x) + erf(%i y - x))
                              - --------------------------------)
                                               4

Maxima kennt komplexe Eigenschaften der Besselfunktionen, um den komplexen Betrag zu vereinfachen. Dies ist ein Beispiel für die Besselfunktion bessel_j.

(%i4) cabs(bessel_j(1,%i));
(%o4)                 abs(bessel_j(1, %i))

Funktion: carg (expr) ¶

Gibt das komplexe Argument des Ausdrucks expr zurück. Das komplexe Argument ist ein Winkel theta im Intervall (-%pi, %pi) derart, dass expr = r exp (theta %i) gilt, wobei r den Betrag des komplexen Ausdrucks expr bezeichnet. Das ist die Polarform des Ausdrucks, wie sie auch von der Funktion polarform zurückgegeben wird. Der Betrag des komplexen Ausdrucks kann mit der Funktion cabs berechnet werden.

Das Ergebnis der Funktion carg kann die Funktion atan2 enthalten.

carg wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Die Funktion carg ist eine Verbfunktion, mit der nicht symbolisch gerechnet werden kann.

Siehe auch die Funktionen rectform, realpart und imagpart sowie die Funktionen cabs und conjugate.

Beispiele:

(%i1) carg (1);
(%o1)                           0
(%i2) carg (1 + %i);

                               %pi
(%o2)                          ---
                                4

(%i3) carg (exp (%i));
(%o3)                           1

(%i4) carg (exp (3/2 * %pi * %i));
                                %pi
(%o4)                         - ---
                                 2
(%i5) carg(exp(x+%i*y));
(%o5)                atan2(sin(y), cos(y))

(%i6) carg(sqrt(x+%i*y));
                          atan2(y, x)
(%o6)                     -----------
                               2
(%i7) carg(sqrt(1+%i*y));
                            atan(y)
(%o7)                       -------
                               2

Funktion: conjugate (expr) ¶

Gibt den konjugiert komplexen Wert des Ausdrucks expr zurück. Sind x und y reelle Variablen oder Ausdrücke, dann hat der Ausdruck x + %i*y das Ergebnis x - %i*y. Die Funktion conjugate ist für numerische und symbolische Rechnungen geeignet.

Maxima kennt Regeln, um den konjugierten Wert für Summen, Produkte und Quotienten von komplexen Ausdrücken zu vereinfachen. Weiterhin kennt Maxima Symmetrieeigenschaften und komplexe Eigenschaften von Funktionen, um den konjugierten Wert mit diesen Funktionen zu vereinfachen. Sind solche Eigenschaften für eine Funktion vorhanden, können diese mit der Funktion properties angezeigt werden. Eigenschaften, die das Ergebnis der Funktion conjugate bestimmen, sind: mirror symmetry, conjugate function und complex characteristic.

conjugate wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Für das Rechnen mit komplexen Ausdrücken siehe auch die Funktionen cabs und carg sowie rectform und polarform.

Beispiele:

Beispiele mit reellen, imaginären und komplexen Variablen.

(%i1) declare ([x, y], real, [z1, z2], complex, j, imaginary);
(%o1)                         done
(%i2) conjugate(x + %i*y);
(%o2)                       x - %i y
(%i3) conjugate(z1*z2);
(%o3)              conjugate(z1) conjugate(z2)
(%i4) conjugate(j/z2);
                                 j
(%o4)                    - -------------
                           conjugate(z2)

Im Folgenden nutzt Maxima Symmetrieeigenschaften, um den konjugiert komplexen Wert der Funktionen gamma und sin zu berechnen. Die Logarithmusfunktion log hat Spiegelsymmetrie, wenn das Argument einen positiven Realteil hat.

(%i5) conjugate(gamma(x+%i*y));
(%o5)                    gamma(x - %i y)
(%i6) conjugate(sin(x+%i*y));
(%o6)                    - sin(%i y - x)
(%i7) conjugate(log(x+%i*y));
(%o7)               conjugate(log(%i y + x))
(%i8) conjugate(log(1+%i*y));
(%o8)                     log(1 - %i y)

Funktion: imagpart (expr) ¶

Gibt den Imaginärteil des Ausrucks expr zurück. Intern berechnet Maxima den Imaginärteil mit der Funktion rectform, die einen Ausdruck in den Realteil und in den Imaginärteil zerlegt. Daher treffen die Ausführungen zu rectform auch auf die Funktion imagpart zu.

Wie die Funktion rectform ist auch die Funktion imagpart eine Verbfunktion, mit der nicht symbolisch gerechnet werden kann.

imagpart wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Mit der Funktion realpart wird der Realteil eines Ausdrucks berechnet.

Siehe auch die Funktionen cabs, carg und conjugate für das Rechnen mit komplexen Zahlen. Mit der Funktion polarform kann ein komplexer Ausdruck in die Polarform gebracht werden.

Beispiele:

Für weitere Erläuterungen dieser Beispiele siehe auch die Funktion rectform.

(%i1) imagpart((2-%i)/(1-%i));
                                1
(%o1)                           -
                                2
(%i2) imagpart(sin(x+%i*y));
(%o2)                    cos(x) sinh(y)
(%i3) imagpart(gamma(x+%i*y));
             %i (gamma(x - %i y) - gamma(%i y + x))
(%o3)        --------------------------------------
                               2
(%i4) imagpart(bessel_j(1,%i));
(%o4)                    bessel_j(1, %i)

Funktion: polarform (expr) ¶

Gibt den Ausdruck expr in der Polarform r %e^(%i theta) zurück. r ist der Betrag des komplexen Ausdrucks, wie er auch mit der Funktion cabs berechnet werden kann. theta ist das Argument des komplexen Ausdrucks, das mit der Funktion carg berechnet werden kann.

Maxima kennt komplexe Eigenschaften von Funktionen, die bei der Berechnung der Polarform angewendet werden. Siehe die Funktion cabs für weitere Erläuterungen.

Wenn mit komplexen Ausdrücken in der Polarform gerechnet werden soll, ist es hilfreich die Optionsvariable %emode auf den Wert false zu setzen. Damit wird verhindert, dass Maxima komplexe Ausdrücke mit der Exponentialfunktion exp automatisch in die Standardform vereinfacht.

polarform wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Die Funktion polarform ist eine Verbfunktion, mit der nicht symbolisch gerechnet werden kann.

Siehe auch die Funktionen cabs, carg und conjugate für das Rechnen mit komplexen Zahlen. Mit der Funktion rectform kann ein komplexer Ausdruck in die Standardform gebracht werden.

Beispiele:

Die allgemeine Polarform eines komplexen Ausdrucks. Die Variablen x und y werden von Maxima als reell angenommen.

(%i1) polarform(x+%i*y);

                       2    2    %i atan2(y, x)
(%o1)            sqrt(y  + x ) %e

Die Polarform einer komplexen Zahl und eines Ausdrucks mit einer reellen Variablen x.

(%i2) polarform(4/5+3*%i/5);
                           %i atan(3/4)
(%o2)                    %e
(%i3) polarform(sqrt(1+%i*x));
                                  %i atan(x)
                                  ----------
                      2     1/4       2
(%o3)               (x  + 1)    %e

Wenn in der Polarform gerechnet werden soll, ist es hilfreich die Optionsvariable %emode auf den Wert false zu setzen. Damit wird verhindert, dass Maxima komplexe Ausdrücke mit der Exponentialfunktion exp automatisch in eine Standardform vereinfacht.

(%i4) z:polarform(1+%i);
                                  %i %pi
                                  ------
                                    4
(%o4)                   sqrt(2) %e
(%i5) z^3;
                     3/2    %i         1
(%o5)               2    (------- - -------)
                          sqrt(2)   sqrt(2)
(%i6) %emode:false;
(%o6)                         false
(%i7) z^3;
                                3 %i %pi
                                --------
                          3/2      4
(%o7)                    2    %e

Funktion: realpart (expr) ¶

Gibt den Realteil des Ausdrucks expr zurück. Intern berechnet Maxima den Realteil mit der Funktion rectform, die einen Ausdruck in den Realteil und in den Imaginärteil zerlegt. Daher treffen die Ausführungen zu rectform auch auf die Funktion realpart zu.

Wie die Funktion rectform ist auch die Funktion realpart eine Verbfunktion, mit der nicht symbolisch gerechnet werden kann.

realpart wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Mit der Funktion imagpart wird der Imaginärteil eines Ausdrucks berechnet.

Siehe auch die Funktionen cabs, carg und conjugate für das Rechnen mit komplexen Zahlen. Mit der Funktion polarform kann ein komplexer Ausdruck in die Polarform gebracht werden.

Beispiele:

Für weitere Erläuterungen dieser Beispiele siehe auch die Funktion rectform.

(%i1) realpart((2-%i)/(1-%i));
                                3
(%o1)                           -
                                2
(%i2) realpart(sin(x+%i*y));
(%o2)                    sin(x) cosh(y)
(%i3) realpart(gamma(x+%i*y));
                gamma(%i y + x) + gamma(x - %i y)
(%o3)           ---------------------------------
                                2
(%i4) realpart(bessel_j(1,%i));
(%o4)                           0

Funktion: rectform (expr) ¶

Zerlegt den Ausdruck expr in den Realteil a und den Imaginärteil b und gibt den komplexen Ausdruck in der Standardform a + b %i zurück.

Die Funktion rectform nutzt Symmetrieeigenschaften und implementierte Eigenschaften komplexer Funktionen, um den Realteil und Imaginärteil eines komplexen Ausdrucks zu berechnen. Sind solche Eigenschaften für eine Funktion vorhanden, können diese mit der Funktion properties angezeigt werden. Eigenschaften, die das Ergebnis der Funktion rectform bestimmen, sind: mirror symmetry, conjugate function und complex characteristic.

rectform ist eine Verbfunktion, die nicht für das symbolische Rechnen geeignet ist.

rectform wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Die Funktionen realpart und imagpart geben jeweils allein den Realteil und den Imaginärteil eines Ausdrucks zurück. Um einen Ausdruck in die Polarform zu bringen, kann die Funktion polarform verwendet werden.

Siehe auch die Funktionen cabs, carg und conjugate für das Rechnen mit komplexen Zahlen.

Beispiele:

Zerlegung eines komplexen Ausdrucks und der Sinusfunktion sin in den Realteil und Imaginärteil. Maxima kennt komplexe Eigenschaften der trigonometrischen Funktionen, um den Realteil und den Imaginärteil zu bestimmen.

(%i1) rectform((2-%i)/(1-%i));

                             %i   3
(%o1)                        -- + -
                             2    2

(%i2) rectform(sin(x+%i*y));
(%o2)          %i cos(x) sinh(y) + sin(x) cosh(y)

Bei der Zerlegung in einen Realteil und einen Imaginärteil nutzt Maxima die Spiegelsymmetrie der Gammfunktion gamma. Die Eigenschaft der Spiegelsymmetrie wird mit der Funktion properties angezeigt, der Eintrag lautet mirror symmetry.

(%i3) properties(gamma);
(%o3)    [mirror symmetry, noun, rule, gradef, transfun]

(%i4) rectform(gamma(x+%i*y));
      gamma(%i y + x) + gamma(x - %i y)
(%o4) ---------------------------------
                      2
                                gamma(x - %i y) - gamma(%i y + x)
                              - ---------------------------------
                                                2

Maxima kennt komplexe Eigenschaften der Besselfunktionen. Die Besselfunktion bessel_j ist für eine ganzzahlige Ordnung und einem imaginären Argument rein imaginär.

(%i5) rectform(bessel_j(1,%i));
(%o5)                  %i bessel_j(1, %i)

10.3 Funktionen der Kombinatorik

Operator: !! ¶

Ist der Operator der doppelten Fakultät.

Für eine positive ganze Zahl n, wird n!! zu dem Produkt n (n-2) (n-4) (n-6) ... (n - 2 (k-1)) vereinfacht, wobei k gleich floor(n/2) ist und floor die größte ganze Zahl als Ergebnis hat, die kleiner oder gleich n/2 ist.

Für ein Argument n, das keine ganze positive Zahl ist, gibt n!! die Substantivform genfact(n, n/2,2) zurück. Siehe die Funktion genfact.

Die Verallgemeinerung der doppelten Fakultät für reelle und komplexe Zahlen ist als die Funktion double_factorial implementiert.

Beispiele:

(%i1) [0!!, 1!!, 2!!, 3!!, 4!!, 5!!, 6!!, 7!!, 8!!];
(%o1)           [1, 1, 2, 3, 8, 15, 48, 105, 384]
(%i2) 1.5!!;
(%o2)                  genfact(1.5, 0, 2)
(%i3) x!!;
                                   x
(%o3)                   genfact(x, -, 2)
                                   2

Funktion: binomial (x, y) ¶

Ist der Binominialkoeffizient, der definiert ist als

                                  x!
             binomial(x, y) = -----------
                              (x - y)! y!

Die Funktion binomial ist für das numerische und symbolische Rechnen geeignet.

Sind die Argumente x oder y ganze Zahlen, wird der Binominialkoeffizient zu einer ganzen Zahl vereinfacht. Sind die Argumente x und y reelle oder komplexe Gleitkommazahlen, wird der Binominialkoeffizient mit der entsprechenden verallgemeinerten Fakultät berechnet. Siehe auch factorial und gamma.

Ist das Argument y oder die Differenz x-y eine ganz Zahl, wird der Binominialkoeffizient zu einem Polynom vereinfacht.

Mit den Funktionen makefact oder makegamma werden Binominialkoeffizienten in einem Ausdruck durch äquivalente Ausdrücke mit der Fakultät oder der Gammafunktion ersetzt.

Maxima kennt die Ableitung des Binominialkoeffizienten nach den Argumenten x und y.

Beispiele:

(%i1) binomial(11, 7);
(%o1)                          330
(%i2) binomial(%i, 1.5);
(%o2)       .3693753994635863 %i - .7573400496142132
(%i3) binomial(x, 3);
                        (x - 2) (x - 1) x
(%o3)                   -----------------
                                6
(%i4) binomial(x+3, 3);
                     (x + 1) (x + 2) (x + 3)
(%o4)                -----------------------
                                6
(%i5) makefact(binomial(x,y));
                               x!
(%o5)                      -----------
                           (x - y)! y!

(%i6) diff(binomial(x,y), y);
(%o6)  - binomial(x, y) (psi (y + 1) - psi (- y + x + 1))
                            0             0

Funktion: double_factorial (z) ¶

Ist die doppelte Fakultät, die allgemein definiert ist als

               2  1/4 (1 - cos(z %pi))  z/2       z
             (---)                     2    gamma(- + 1)
              %pi                                 2

Die Funktion double_factorial ist für das numerische und symbolische Rechnen geeignet. Ist das Argument z eine ganze Zahl, eine Gleitkommazahl, eine große Gleitkommazahl oder eine komplexe Gleitkommazahl, dann wird ein numerisches Ergebnis berechnet. Für eine positive ganze Zahl ist das Ergebnis gleich dem Ergebnis des Operators der doppelten Fakultät !!. Für rationale Zahlen ist das Ergebnis eine Substantivform.

Für negative gerade ganze Zahlen ist die Funktion double_factorial nicht definiert.

Hat die Optionsvariable factorial_expand den Wert true, vereinfacht Maxima double_factorial für das Argument n-1 und für Argumente n+2*k, wobei k eine ganze Zahl ist.

Maxima kennt die Ableitung der Funktion double_factorial.

double_factorial wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Beispiele:

Numerische Ergebnisse für ganze Zahlen, Gleitkommazahlen und komplexen Gleitkommazahlen.

(%i1) double_factorial([-3, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o1) [- 1, 1, 1, 1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]

(%i2) double_factorial([1.5, 1.5b0, 0.5+%i, 0.5b0+%i]);
(%o2) [1.380662681753386, 1.380662681753387b0,
.4186422526242637 - .7218816624466643 %i, 
4.186422526242633b-1 - 7.218816624466641b-1 %i]

Vereinfachungen, wenn die Optionsvariable factorial_expand den Wert true hat.

(%i3) factorial_expand:true;
(%o3)                         true
(%i4) double_factorial(n-1);
                               n!
(%o4)                  -------------------
                       double_factorial(n)
(%i5) double_factorial(n+4);
(%o5)          (n + 2) (n + 4) double_factorial(n)
(%i6) double_factorial(n-4);

                       double_factorial(n)
(%o6)                  -------------------
                            (n - 2) n

Die Ableitung der Funktion double_factorial.

(%i7) diff(double_factorial(x), x);
                                     2
                            %pi log(---) sin(%pi x)
                                    %pi                    x
(%o7) (double_factorial(x) (----------------------- + psi (- + 1)
                                       2                 0 2
                                                     + log(2)))/2

Funktion: factcomb (expr) ¶

Fasst Faktoren mit Fakultäten im Ausdruck expr zusammen. Zum Beispiel wird (n+1)*n! zu (n+1)! zusammengefasst.

Hat die Optionsvariable sumsplitfact den Wert false, wird nach der Vereinfachung mit factcomb die Funktion minfactorial auf den Ausdruck expr angewendet.

Beispiele:

(%i1) expr: ((n+1)*n!)/(n+2)!;
                           (n + 1) n!
(%o1)                      ----------
                            (n + 2)!
(%i2) factcomb(expr);

                            (n + 1)!
(%o2)                       --------
                            (n + 2)!

(%i3) factcomb(expr), sumsplitfact:false;
                                1
(%o3)                         -----
                              n + 2

Funktion: factorial (z) ¶

Operator: ! ¶

Die Funktion factorial ist für das numerische und symbolische Rechnen der Fakultät geeignet. Der Operator der Fakultät !, ist identisch mit der Funktion factorial.

Für eine ganze Zahl n, vereinfacht n! zum Produkt der ganzen Zahlen von 1 bis einschließlich n. 0! vereinfacht zu 1. Für reelle und komplexe Gleitkommazahlen wird z! mit der Verallgemeinerung gamma(z+1) berechnet. Siehe die Funktion gamma. Für eine halbzahlige rationale Zahl n/2, vereinfacht (n/2)! zu einem rationalen Faktor multipliziert mit sqrt(%pi).

Die Optionsvariable factlim enthält die größte Zahl, für die die Fakultät einer ganzen Zahl numerisch berechnet wird. Ist das Argument der Fakultät eine rationale Zahl, wird von Maxima die Funktion gamma für die numerische Berechnung aufgerufen. In diesem Fall ist gammalim - 1 der größte Nenner, für den die Fakultät vereinfacht wird. Siehe gammalim.

Hat die Optionsvariable factorial_expand den Wert true, wird die Fakultät von Argumenten der Form (n+k)! oder (n-k)! vereinfacht, wobei k eine ganze Zahl ist.

Mit den Funktionen minfactorial und factcomb können Fakultäten in Ausdrücken vereinfacht werden.

Die Funktion makegamma ersetzt Fakultäten in einem Ausdruck durch die Gammafunktion gamma. Umgekehrt ersetzt die Funktion makefact Binomialkoeffizienten und die Gammafunktion in einem Ausdruck durch Fakultäten.

Maxima kennt die Ableitung der Fakultät und die Grenzwerte der Fakultät für spezielle Werte wie negative ganze Zahlen.

Siehe auch die Gammfunktion gamma und den Binomialkoeffizienten binomial.

Beispiele:

Die Fakultät einer ganzen Zahl wird zu einer exakten Zahl vereinfacht, wenn das Argument nicht größer als factlim ist. Die Fakultät für reelle und komplexe Zahlen wird als Gleitkommazahl berechnet.

(%i1) factlim:10;
(%o1)                          10
(%i2) [0!, (7/2)!, 8!, 20!];
                     105 sqrt(%pi)
(%o2)            [1, -------------, 40320, 20!]
                          16
(%i3) [4.77!, (1.0+%i)!];
(%o3) [81.44668037931197, .3430658398165451 %i
                                             + .6529654964201663]
(%i4) [2.86b0!, (1.0b0+%i)!];
(%o4) [5.046635586910012b0, 3.430658398165454b-1 %i
                                          + 6.529654964201667b-1]

Die Fakultät von numerischen Konstanten oder eines konstanten Ausdrucks wird numerisch berechnet, wenn die Konstante oder der Ausdruck zu einer Zahl ausgewertet werden kann.

(%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
(%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
(%i2) ev (%, numer, %enumer);
(%o2) [.3430658398165451 %i + .6529654964201663, 
         7.188082728976031, 4.260820476357003, 1.227580202486819]

Fakultäten werden vereinfacht und nicht ausgewertet. Daher wird die Fakultät auch dann berechnet, wenn die Auswertung mit dem Quote-Operator ' unterdrückt ist.

(%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
            105 sqrt(%pi)
(%o1)   [1, -------------, 81.44668037931197, 40320, 20!]
                 16

Maxima kennt die Ableitung der Fakultät.

(%i1) diff(x!, x);
(%o1)                    x! psi (x + 1)
                               0

Die Optionsvariable factorial_expand kontrolliert die Expansion und Vereinfachung von Ausdrücken, die die Fakultät enthalten.

(%i1) (n+1)!/n!,factorial_expand:true;
(%o1)                         n + 1

Optionsvariable: factlim ¶

Standardwert: 100000

Die Optionsvariable factlim spezifiziert die größte ganze Zahl, für die die Fakultät einer ganzen Zahl numerisch berechnet wird. Hat factlim den Wert -1, wird die Fakultät für jede ganze Zahl berechnet. Siehe die Funktion factorial.

Optionsvariable: factorial_expand ¶

Standardwert: false

Die Optionsvariable factorial_expand kontrolliert die Vereinfachung von Ausdrücken wie (n+k)! oder (n-k)!, wobei k eine ganze Zahl ist. Siehe factorial für ein Beispiel.

Siehe auch die Funktionen minfactorial und factcomb für die Vereinfachung von Ausdrücken mit der Fakultät.

Funktion: genfact (x, y, z) ¶

Gibt die verallgemeinerte Fakultät zurück, die als x (x-z) (x - 2 z) ... (x - (y - 1) z) definiert ist. Ist x eine ganze Zahl, dann entspricht genfact(x, x, 1) der Fakultät x! und genfact(x, x/2, 2) der doppelten Fakultät x!!. Siehe auch die Funktionen factorial und double_factorial sowie die Operatoren ! und !!.

Funktion: minfactorial (expr) ¶

Die Funktion minfactorial vereinfacht Fakultäten factorial in dem Ausdruck epxr, die sich um eine ganze Zahl voneinander unterscheiden. Siehe auch die Funktion factcomb, um Fakultäten zusammenzufassen, sowie die Optionsvariable factorial_expand.

(%i1) n!/(n+2)!;
                               n!
(%o1)                       --------
                            (n + 2)!
(%i2) minfactorial (%);
                                1
(%o2)                    ---------------
                         (n + 1) (n + 2)

Optionsvariable: sumsplitfact ¶

Standardwert: true

Hat die Optionsvariable sumsplitfact den Wert false, wird von der Funktion factcomb nach der Zusammenfassung von Fakultäten die Funktion minfactorial angewendet. Siehe die Funktion factcomb für ein Beispiel.

10.4 Wurzel-, Exponential- und Logarithmusfunktion

Optionsvariable: %e_to_numlog ¶

Standardwert: false

Hat die Optionsvariable %e_to_numlog den Wert true, wird ein Ausdruck mit der Exponentialfunktion exp der Form %e^(r*log(x)) zu x^r vereinfacht, wenn r eine rationale Zahl ist. Ist r eine ganze Zahl, wird die Vereinfachung von der Optionsvariablen logsimp kontrolliert.

Beispiel:

(%i1) exp(1/2*log(x));
                              log(x)
                              ------
                                2
(%o1)                       %e
(%i2) exp(1/2*log(x)), %e_to_numlog:true;
(%o2)                        sqrt(x)

Optionsvariable: %emode ¶

Standardwert: true

Die Optionsvariable %emode kontrolliert die Vereinfachung von Ausdrücken mit der Exponentialfunktion exp der Form %e^(%pi %i x).

Ist das Argument x eine ganze Zahl oder eine rationale Zahl, die ein Vielfaches von 1/2, 1/3, 1/4 oder 1/6 ist, dann wird der Ausdruck %e^(%pi %i x) zu einer reellen oder komplexen Zahl vereinfacht. Für Gleitkommazahlen wird diese Vereinfachung dann ausgeführt, wenn diese eine ganze Zahl oder halbzahlige rationale Zahl repräsentieren.

Eine Summe im Exponenten wie zum Beispiel %e^(%pi *%i (x+n)), wobei n eine der oben genannten Zahlen und x ein allgemeiner Ausdruck ist, wird vereinfacht, indem der Faktor %^(%pi %i n) entsprechend vereinfacht wird.

Hat %emode den Wert false, werden keine speziellen Vereinfachungen für den Ausdruck %e^(%pi %i x) vorgenommen.

Beispiele:

(%i1) exp([2*%pi*%i, 1/2*%pi*%i, 0.5*%pi*%i, 0.5b0*%pi*%i]);
(%o1)               [1, %i, 1.0 %i, 1.0b0 %i]

(%i2) exp([1/3*%pi*%i, 1/4*%pi*%i, 1/6*%pi*%i]);
         sqrt(3) %i   1    %i         1     %i   sqrt(3)
(%o2)   [---------- + -, ------- + -------, -- + -------]
             2        2  sqrt(2)   sqrt(2)  2       2

(%i3) exp((1/3+x)*%pi*%i);
                    sqrt(3) %i   1    %i %pi x
(%o3)              (---------- + -) %e
                        2        2

Optionsvariable: %enumer ¶

Standardwert: false

Hat %enumer den Wert true, wird die Konstante %e immer dann durch ihren nummerischen Wert ersetzt, wenn die Optionsvariable numer den Wert true hat.

Hat %enumer den Wert false, wird die Konstante %e nur dann durch ihren nummerischen Wert ersetzt, wenn der Exponent von %e^x zu einer Gleitkommazahl ausgewertet wird.

Siehe auch ev und numer.

Beispiel:

(%i1) %enumer:true;
(%o1)                         true
(%i2) exp(x);
                                 x
(%o2)                          %e
(%i3) exp(x),numer;
                                        x
(%o3)                  2.718281828459045

Funktion: exp (z) ¶

Ist die Exponentialfunktion. Die Exponentialfunktion exp wird von Maxima sofort zu %e^z vereinfacht und tritt in vereinfachten Ausdrücken nicht auf. Maxima vereinfacht die Exponentialfunktion daher wie die allgemeine Exponentiation ^. Darüberhinaus kennt Maxima spezielle Regeln für die Vereinfachung der Exponentialfunktion.

Ist das Argument z der Exponentialfunktion eine ganze oder rationale Zahl wird ein vereinfachter Ausdruck zurückgegeben. Ist das Argument z eine reelle oder komplexe Gleitkommazahl wird ein numerisches Ergebnis berechnet.

Folgende Optionsvariablen kontrollieren die Vereinfachung der Exponentialfunktion:

%enumer

Hat die Optionsvariable %enumer den Wert true, vereinfacht Maxima die Eulersche Zahl %e immer dann zu ihrem numerischen Wert, wenn die Optionsvariable numer auch den Wert true hat.

%emode

Hat die Optionsvariable %emode den Wert true, wendet Maxima Regeln an, um Ausdrücke der Form %e^(x*%i*%pi) zu vereinfachen. Der Standardwert von %emode ist true. Wenn mit komplexen Zahlen in der Polarform gerechnet wird, kann es hilfreich sein, die Optionsvariable %emode auf den Wert false zu setzen.

%e_to_numlog

Hat die Optionsvariable %e_to_numlog den Wert true, vereinfacht Maxima einen Ausdruck %e^(r*log(x) zu x^r, wobei r eine rationale Zahl ist. Ist r eine ganze Zahl wird diese Vereinfachung von der Optionsvariablen logsimp kontrolliert. Für reelle oder komplexe Gleitkommazahlen wird diese Vereinfachung nicht ausgeführt.

radexpand

Die Optionsvariable radexpand kontrolliert die Vereinfachung von Ausdrücken der Form (%e^a)^b. Ist a ein reelles Argument vereinfacht Maxima immer zu einem Ausdruck %e^(a*b). Ist a ein komplexes Argument, wird die Vereinfachung %e^(a*b) dann ausgeführt, wenn die Optionsvariable radexpand den Wert all hat.

logsimp

Die Optionsvariable logsimp kontrolliert die Vereinfachung der Exponentialfunktion für den Fall, dass im Argument expr die Logarithmusfunktion log auftritt. Hat die logsimp den Wert true, wird ein Ausdruck %e^(n*log(x) zu x^n vereinfacht, wenn n eine ganze Zahl ist. Mit der Optionsvariablen %e_to_numlog wird diese Vereinfachung für eine rationale Zahl n kontrolliert.

demoivre

Ist eine Optionsvariable und eine Funktion, die auch als Auswertungsschalter evflag definiert ist. Hat die Optionsvariable demoivre den Wert true, wird ein Ausdruck %e^(x + %i y) zu %e^x (cos(y) + %i sin(y)) vereinfacht. Siehe auch die Optionsvariable exponentialize.

Maxima kennt viele spezielle unbestimmte und bestimmte Integrale mit der Exponentialfunktion.

Funktion: log (z) ¶

Ist der natürliche Logarithmus zur Basis e. Die Logarithmusfunktion ist für das numerische und symbolische Rechnen geeignet.

Maxima hat keine vordefinierte Logarithmusfunktion zur Basis 10 oder anderen Basen. Eine einfache Definition ist zum Beispiel log10(x) := log(x)/log(10). Mit dem Kommando load("log10") kann ein Paket geladen werden, dass eine dekadische Logarithmusfunktion log10 definiert.

Ist das Argument z der Logarithmusfunktion eine ganze oder rationale Zahl wird ein vereinfachter Ausdruck zurückgegeben. Ist das Argument z eine reelle oder komplexe Gleitkommazahl wird ein numerisches Ergebnis berechnet.

Die folgenden Optionsvariablen kontrollieren die Vereinfachung und Auswertung der Logarithmusfunktion:

logexpand

Hat die Optionsvariable logexpand den Wert true, dann wird log(a^b) zu b*log(a) vereinfacht. Hat logexpand den Wert all, wird zusätzlich log(a*b) zu log(a)+log(b) vereinfacht. Mit den Wert super vereinfacht Maxima weiterhin log(a/b) zu log(a)-log(b), wobei a/b eine rationale Zahl ist. log(1/b wird für eine ganze Zahl b immer vereinfacht. Hat die Optionsvariable logexpand den Wert false werden alle obigen Vereinfachungen ausgeschaltet.

logsimp

Hat die Optionsvariable logsimp den Wert false, werden Exponentialfunktionen exp, die Logarithmusfunktionen im Exponenten enthalten, nicht vereinfacht.

lognegint

Hat die Optionsvariable lognegint den Wert true, wird log(-n) zu log(n)+%i*%pi für positive n vereinfacht.

%e_to_numlog

Hat die Optionsvariable %e_to_numlog den Wert true, wird ein Ausdruck %e^(r*log(x)) zu x^r vereinfacht. Dabei sind r eine rationale Zahl und x ein beliebiger Ausdruck. Die Funktion radcan führt diese Vereinfachung ebenfalls aus.

Die Logarithmusfunktion wird automatisch auf die Elemente von Listen und Matrizen sowie auf die beiden Seiten von Gleichungen angewendet. Siehe distribute_over.

Beispiele:

Verschiedene Beispiele mit der Logarithmusfunktion.

(%i1) log(%e);
(%o1)                           1
(%i2) log(100.0);
(%o2)                   4.605170185988092
(%i3) log(2.5+%i);
(%o3)       .3805063771123649 %i + .9905007344332917
(%i4) taylor(log(1+x),x,0,5);
                       2    3    4    5
                      x    x    x    x
(%o4)/T/          x - -- + -- - -- + -- + . . .
                      2    3    4    5
(%i5) rectform(log(x+%i*y));
                       2    2
                  log(y  + x )
(%o5)             ------------ + %i atan2(y, x)
                       2
(%i6) limit(log(x),x,0,plus);
(%o6)                         minf
(%i7) integrate(log(z)^n,z);

                                                    - n - 1
(%o7) - gamma_incomplete(n + 1, - log(z)) (- log(z))
                                                            n + 1
                                                      log(z)

(%i8) laplace(log(t),t,s);

                        - log(s) - %gamma
(%o8)                   -----------------
                                s

(%i9) depends(y,x);
(%o9)                        [y(x)]
(%i10) ode2(diff(y,x)+log(y)+1,y,x);
            - 1
(%o10)    %e    expintegral_e(1, - log(y) - 1) = x + %c

Optionsvariable: logabs ¶

Standardwert: false

Treten bei der unbestimmten Integration Logarithmusfunktionen im Ergebnis auf, so wird der Betrag der Argumente der Logarithmusfunktionen gebildet, wenn die Optionsvariable logabs den Wert true hat.

Beispiele:

(%i1) logabs:true;
(%o1)                         true
(%i2) integrate(1/x,x);
(%o2)                      log(abs(x))
(%i3) integrate(1/(1+x^3),x);
                                                   2 x - 1
            ! 2        !                      atan(-------)
        log(!x  - x + 1!)   log(abs(x + 1))        sqrt(3)
(%o3) - ----------------- + --------------- + -------------
                6                  3             sqrt(3)

Funktion: logarc (expr) ¶

Optionsvariable: logarc ¶

Hat die Optionsvariable logarc den Wert true, werden inverse Winkel- und Hyperbelfunktionen durch Logarithmusfunktionen ersetzt. Der Standardwert von logarc ist false.

Die Funktion logarc(expr) führt diese Ersetzung aus, ohne dass die Optionsvariable logarc gesetzt wird.

Beispiele:

(%i1) logarc(asin(x));
                                     2
(%o1)             - %i log(sqrt(1 - x ) + %i x)
(%i2) logarc:true;
(%o2)                         true
(%i3) asin(x);
                                     2
(%o3)             - %i log(sqrt(1 - x ) + %i x)

Optionsvariable: logconcoeffp ¶

Standardwert: false

Der Optionsvariablen logconcoeffp kann eine Aussagefunktion mit einem Argument zugewiesen werden, die kontrolliert, welche Koeffizienten von der Funktion logcontract zusammengezogen werden. Sollen zum Beispiel Wurzeln generiert werden, kann folgende Aussagefunktion definiert werden:

logconcoeffp:'logconfun$ 
logconfun(m) := featurep(m,integer) or ratnump(m)$

Das Kommando logcontract(1/2*log(x)) liefert nun das Ergebnis log(sqrt(x)).

Funktion: logcontract (expr) ¶

Der Ausdruck expr wird rekursiv nach Ausdrücken der Form a1*log(b1) + a2*log(b2) + c durchsucht. Diese werden zu log(ratsimp(b1^a1 * b2^a2)) + c transformiert.

(%i1) 2*(a*log(x) + 2*a*log(y))$
(%i2) logcontract(%);
                                 2  4
(%o2)                     a log(x  y )

Wird die Variable n mit dem Kommando declare(n, integer) als eine ganze Zahl deklariert, dann wird logcontract(2*a*n*log(x)) zu a*log(x^(2*n)) vereinfacht. Die Koeffizienten, die zusammengezogen werden, sind in diesem Fall die Zahl 2 und die Variable n, welche die folgende Aussage erfüllen featurep(coeff, integer). Der Nutzer kann kontrollieren, welche Koeffizienten zusammengezogen werden. Dazu wird der Optionsvariablen logconcoeffp eine Aussagefunktion mit einem Argument zugewiesen. Sollen zum Beispiel Wurzeln generiert werden, kann folgende Definition verwendet: logconcoeffp: 'logconfun$ logconfun(m) := featurep(m,integer) or ratnump(m)$. Dann hat das Kommando logcontract(1/2*log(x)) das Ergebnis log(sqrt(x)).

Optionsvariable: logexpand ¶

Standardwert: true

Die Optionsvariable logexpand kontrolliert die Vereinfachung der Logarithmusfunktion log.

Hat logexpand den Wert true, wird log(a^b) zu b*log(a) vereinfacht. Hat logexpand den Wert all, wird zusätzlich log(a*b) zu log(a)+log(b) vereinfacht. Mit dem Wert super vereinfacht Maxima weiterhin log(a/b) zu log(a)-log(b), wobei a/b eine rationale Zahl ist. log(1/b wird für eine ganze Zahl b immer vereinfacht. Hat die Optionsvariable logexpand den Wert false werden alle obigen Vereinfachungen ausgeschaltet.

Optionsvariable: lognegint ¶

Standardwert: false

Hat die Optionsvariable lognegint den Wert true, wird log(-n) zu log(n)+%i*%pi für positive n vereinfacht.

Optionsvariable: logsimp ¶

Standardwert: true

Hat die Optionsvariable logsimp den Wert false, werden Exponentialfunktionen exp, die Logarithmusfunktionen im Exponenten enthalten, nicht vereinfacht.

Funktion: plog (x) ¶

Gibt den Hauptwert des komplexen natürlichen Logarithmus im Intervall -%pi < carg(x) <= +%pi zurück.

Optionsvariable: rootsconmode ¶

Standardwert: true

rootsconmode kontrolliert das Verhalten der Funktion rootscontract. Siehe die Funktion rootscontract für Details.

Funktion: rootscontract (expr) ¶

Konvertiert Produkte von Wurzeln in Wurzeln von Produkten. Zum Beispiel hat rootscontract(sqrt(x)*y^(3/2)) das Ergebnis sqrt(x*y^3).

Hat die Optionsvariable radexpand den Wert true und die Optionsvariable domain den Wert real, das sind die Standardwerte, wird abs(x) zu sqrt(x^2) vereinfacht. Zum Beispiel hat rootscontract(abs(x) * sqrt(y)) das Ergebnis sqrt(x^2*y).

Die Optionsvariable rootsconmode kontrolliert das Ergebnis folgendermaßen:

Problem             Wert             Ergebnis 
                    rootsconmode     rootscontract
      
x^(1/2)*y^(3/2)     false            sqrt(x*y^3)
x^(1/2)*y^(1/4)     false            sqrt(x)*y^(1/4)
x^(1/2)*y^(1/4)     true             sqrt(x*sqrt(y))
x^(1/2)*y^(1/3)     true             sqrt(x)*y^(1/3)
x^(1/2)*y^(1/4)     all              (x^2*y)^(1/4)
x^(1/2)*y^(1/3)     all              (x^3*y^2)^(1/6)

Hat rootsconmode den Wert false, kontrahiert rootscontract nur Faktoren mit rationalen Exponenten, die den gleichen Nenner haben. Hat rootsconmode den Wert all, wird das kleinste gemeinsame Vielfache des Nenners der Faktoren verwendet, um die Faktoren zusammenzufassen.

Ähnlich wie bei der Funktion logcontract werden von rootscontract die Argumente unter der Wurzel mit der Funktion ratsimp vereinfacht.

Beispiele:

(%i1) rootsconmode: false$
(%i2) rootscontract (x^(1/2)*y^(3/2));
                                   3
(%o2)                      sqrt(x y )
(%i3) rootscontract (x^(1/2)*y^(1/4));
                                   1/4
(%o3)                     sqrt(x) y
(%i4) rootsconmode: true$
(%i5) rootscontract (x^(1/2)*y^(1/4));
(%o5)                    sqrt(x sqrt(y))

(%i6) rootscontract (x^(1/2)*y^(1/3));
                                   1/3
(%o6)                     sqrt(x) y

(%i7) rootsconmode: all$
(%i8) rootscontract (x^(1/2)*y^(1/4));
                              2   1/4
(%o8)                       (x  y)
(%i9) rootscontract (x^(1/2)*y^(1/3));
                             3  2 1/6
(%o9)                      (x  y )
(%i10) rootsconmode: false$
(%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
                    *sqrt(sqrt(1 + x) - sqrt(x)));
(%o11)                          1
(%i12) rootsconmode: true$
(%i13) rootscontract (sqrt(5+sqrt(5)) - 5^(1/4)*sqrt(1+sqrt(5)));
(%o13)                          0

Funktion: sqrt (z) ¶

Ist die Wurzelfunktion. Die Wurzelfunktion wird von Maxima sofort zu x^(1/2) vereinfacht und tritt in Ausdrücken nicht auf.

Die Wurzelfunktion ist für das numerische und symbolische Rechnen geeignet. Ist das Argument z der Wurzelfunktion eine Gleitkommazahl, wird ein numerisches Ergebnis zurückgegeben. Für ganze und rationale Zahlen wird die Wurzelfunktion vereinfacht. Die numerische Berechnung kann mit den Optionsvariablen und Auswertungsschaltern numer und float kontrolliert werden.

Hat die Optionsvariable radexpand den Wert true, werden die n-ten Wurzeln von Faktoren unter einer Wurzel aus der Wurzel herausgezogen. So wird zum Beispiel sqrt(16*x^2) nur dann zu 4*x vereinfacht, wenn radexpand den Wert true hat.

Siehe auch die Funktionen rootscontract und sqrtdenest für die Vereinfachung von Ausdrücken, die die Wurzelfunktion enthalten.

Beispiele:

Verschiedene Beispiele mit der Wurzelfunktion.

(%i1) sqrt(4);
(%o1)                           2
(%i2) sqrt(24);
(%o2)                       2 sqrt(6)
(%i3) sqrt(2.0);
(%o3)                   1.414213562373095
(%i4) taylor(sqrt(1+x),x,0,5);
                       2    3      4      5
                  x   x    x    5 x    7 x
(%o4)/T/      1 + - - -- + -- - ---- + ---- + . . .
                  2   8    16   128    256
(%i5) rectform(sqrt(x+%i*y));
           2    2 1/4     atan2(y, x)
(%o5) %i (y  + x )    sin(-----------)
                               2
                                      2    2 1/4     atan2(y, x)
                                  + (y  + x )    cos(-----------)
                                                          2
(%i6) integrate(sqrt(t)*(t+1)^-2,t,0,1);
                             %pi - 2
(%o6)                        -------
                                4

10.5 Winkelfunktionen

• Einführung in Winkelfunktionen
• Funktionen und Variablen für Winkelfunktionen

     sin       cos       tan
     sec       csc       cot
     asin      acos      atan
     asec      acsc      acot
     sinh      cosh      tanh
     sech      csch      coth
     asinh     acosh     atanh
     asech     acsch     acoth

10.6 Hyperbelfunktionen

• Einführung in Hyperbelfunktionen
• Funktionen und Variablen für Hyperbelfunktionen

10.7 Zufallszahlen

Funktion: make_random_state (n) ¶

Funktion: make_random_state (s) ¶

Funktion: make_random_state (true) ¶

Funktion: make_random_state (false) ¶

Ein Zufallszustand repräsentiert den Zustand des Zufallszahlengenerators. Der Zustand enthält 627 32-Bit Worte.

make_random_state(n) gibt einen neuen Zufallszustand zurück, der aus einer ganzen Zahl n modulo 2^32 erzeugt wird. n kann eine negative Zahl sein.

make_random_state(s) gibt eine Kopie des Zufallszutandes s zurück.

make_random_state(true) gibt einen neuen Zufallszustand zurück, der aus der aktuellen Systemzeit des Computers erzeugt wird.

make_random_state(false) gibt eine Kopie des aktuellen Zustands des Zufallszahlengenerators zurück.

Funktion: set_random_state (s) ¶

Kopiert s in den Zufallszustand des Zufallszahlengenerators.

set_random_state gibt immer done zurück.

Funktion: random (x) ¶

Erzeugt eine Pseudo-Zufallszahl. Ist x eine ganze Zahl, gibt random(x) eine ganze Zahl im Intervall 0 bis einschließlich x-1 zurück. Ist x eine Gleitkommazahl, gibt random(x) eine positive Gleitkommazahl zurück, die kleiner als x ist. random gibt eine Fehlermeldung, wenn x weder eine ganze Zahl noch eine Gleitkommazahl ist oder wenn x eine negative Zahl ist.

Die Funktionen make_random_state und set_random_state verwalten den Zustand des Zufallszahlengenerators.

Der Maxima-Zufallszahlengenerator ist eine Implementation des Mersenne twister MT 19937.

Beispiele:

(%i1) s1: make_random_state (654321)$
(%i2) set_random_state (s1);
(%o2)                         done
(%i3) random (1000);
(%o3)                          768
(%i4) random (9573684);
(%o4)                        7657880
(%i5) random (2^75);
(%o5)                11804491615036831636390
(%i6) s2: make_random_state (false)$
(%i7) random (1.0);
(%o7)                   .2310127244107132
(%i8) random (10.0);
(%o8)                   4.394553645870825
(%i9) random (100.0);
(%o9)                   32.28666704056853
(%i10) set_random_state (s2);
(%o10)                        done
(%i11) random (1.0);
(%o11)                  .2310127244107132
(%i12) random (10.0);
(%o12)                  4.394553645870825
(%i13) random (100.0);
(%o13)                  32.28666704056853