| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
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
entier ist eine andere Bezeichnung für die Funktion floor.
Siehe floor.
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
fix ist eine andere Bezeichnung für die Funktion floor. Siehe
floor.
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
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
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
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
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
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)
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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))
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
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)
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)
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
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
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)
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
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
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
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
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
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.
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.
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 !!.
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)
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.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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)
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
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.
Beispiel:
(%i1) %enumer:true;
(%o1) true
(%i2) exp(x);
x
(%o2) %e
(%i3) exp(x),numer;
x
(%o3) 2.718281828459045
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:
%enumerHat 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.
%emodeHat 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_numlogHat 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.
radexpandDie 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.
logsimpDie 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.
demoivreIst 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.
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:
logexpandHat 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.
logsimpHat die Optionsvariable logsimp den Wert false, werden
Exponentialfunktionen exp,
die Logarithmusfunktionen im Exponenten
enthalten, nicht vereinfacht.
lognegintHat die Optionsvariable lognegint den Wert true, wird
log(-n) zu log(n)+%i*%pi für positive n vereinfacht.
%e_to_numlogHat 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
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)
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)
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)).
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)).
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.
Standardwert: false
Hat die Optionsvariable lognegint den Wert true, wird
log(-n) zu log(n)+%i*%pi für positive n vereinfacht.
Standardwert: true
Hat die Optionsvariable logsimp den Wert false, werden
Exponentialfunktionen exp,
die Logarithmusfunktionen im Exponenten
enthalten, nicht vereinfacht.
Gibt den Hauptwert des komplexen natürlichen Logarithmus im Intervall
-%pi < carg(x) <= +%pi zurück.
Standardwert: true
rootsconmode kontrolliert das Verhalten der Funktion
rootscontract. Siehe die Funktion rootscontract
für Details.
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
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
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 10.5.1 Einführung in Winkelfunktionen | ||
| 10.5.2 Funktionen und Variablen für Winkelfunktionen |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Maxima kennt viele Winkel- und Hyperbelfunktionen. Nicht alle Identitäten für Winkel- und Hyperbelfunktionen sind programmiert, aber es ist möglich weitere Identitäten mit der Fähigkeit der Erkennung von Mustern hinzuzufügen.
Maxima kennt die folgenden Winkel- und Hyperbelfunktionen sowie deren Inverse:
sin cos tan
sec csc cot
asin acos atan
asec acsc acot
sinh cosh tanh
sech csch coth
asinh acosh atanh
asech acsch acoth
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die inversen Winkelfunktionen: Arkussinus, Arkuskosinus, Arkustangens, Arkuskotangens, Arkuskosekans und Arkussekans.
Die inversen Winkelfunktionen sind für das numerische und symbolische Rechnen
geeignet. Die inversen Winkelfunktionen können für reelle und komplexe
Gleitkommazahlen in doppelter und in beliebiger Genauigkeit berechnet werden.
Ist das Argument eine ganze oder rationale Zahl, werden die inversen
Winkelfunktionen nicht numerisch berechnet, sondern vereinfacht. Die numerische
Berechnung kann mit den Optionsvariablen und Auswertungsschaltern
numer
und float
erzwungen werden.
Die inversen Winkelfunktionen sind bis auf die Funktionen acos und
asec als ungerade definiert. Die Funktionen acos und asec
vereinfachen für ein negatives Argument -x zu %pi-acos(x) und
%pi-asec(x). Für die inversen Winkelfunktion asin, acos
und atan ist die Spiegelsymmetrie für den Fall implementiert, dass das
komplexe Argument x+%i*y einen Realteil abs(x)<1 hat.
Ist das Argument z eine Matrix, eine Liste oder eine Gleichung werden die
inversen Winkelfunktionen auf die Elemente der Matrix, der Liste oder auf die
beiden Seiten der Gleichung angewendet. Dieses Verhalten wird von der
Optionsvariablen distribute_over
kontrolliert.
Inverse Winkelfunktionen können für das symbolische Rechnen verwendet werden. Maxima kann Ausdrücke mit inversen Winkelfunktionen differenzieren und integrieren, Grenzwerte bestimmen sowie Gleichungen mit inversen Winkelfunktionen lösen.
Das Argument der inversen Winkelfunktionen kann eine Taylorreihe sein. In diesem Fall wird die Taylorreihenentwicklung für die inverse Winkelfunktion vollständig ausgeführt.
Die folgenden Optionsvariablen kontrollieren die Vereinfachung der inversen Winkelfunktionen:
distribute_overHat die Optionsvariable distribute_over
den Wert true und ist das
Argument der inversen Winkelfunktion eine Matrix, Liste oder Gleichung wird die
Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
Standardwert ist true.
%piargsHat die Optionsvariable %piargs
den Wert true, werden die
inversen Winkelfunktionen für spezielle Werte als Argument vereinfacht.
Der Standardwert ist true.
%iargsHat die Optionsvariable %iargs
den Wert true und ist das Argument
der inversen Winkelfunktion ein Vielfaches der imaginären Einheit %i
werden die inversen Winkelfunktionen zu inversen Hyperbelfunktionen vereinfacht.
Der Standardwert ist true.
triginversesHat die Optionsvariable triginverses
den Wert all und ist das
Argument die entsprechende Winkelfunktion vereinfachen die inversen
Winkelfunktionen, zum Beispiel vereinfacht asin(sin(x)) zu x.
Der Standardwert ist true und die Vereinfachung wird nicht vorgenommen.
logarcHat die Optionsvariable logarc
den Wert true, werden inverse
Winkelfunktionen durch Logarithmusfunktionen ersetzt. Der Standardwert von
logarc ist false.
Ist der Arkustangens mit zwei Argumenten, der in Maxima wie folgt definiert ist:
atan(y/x) x>0
atan(y/x) + %pi x<0 und y>=0
atan(y/x) - %pi x<0 und y<0
%pi / 2 x=0 und y>0
- %pi / 2 x=0 und y<0
nicht definiert x=0 und y=0
Mit der obigen Definition ist der Wertebereich des Arkustangens
-%pi < atan2(y,x) <= %pi. Alternativ kann der Arkustangens mit zwei
Argumenten definiert werden als
%i y + x
atan2(y, x) = - %i log(-------------)
2 2
sqrt(y + x )
Der Arkustangens ist für das symbolische und numerische Rechnen geeignet.
Für reelle Argumente x und y deren Vorzeichen bestimmt werden
kann, vereinfacht Maxima den Arkustangens wie oben in der Definition angegeben.
Sind beide Argumente Gleitkommazahlen wird ein numerisches Ergebnis berechnet.
Die numerische Berechnung für komplexe Gleitkommazahlen ist nicht
implementiert. Weiterhin kennt Maxima die speziellen Werte, wenn eines der
Argumente x oder y unendlich ist. atan2(x, x) und
atan2(x, -x) werden von Maxima vereinfacht, wenn Maxima das Vorzeichen
von x ermitteln kann.
Die Vereinfachung des Arkustangens wird weiterhin von den folgenden Optionsvariablen kontrolliert:
distribute_overHat die Optionsvariable distribute_over
den Wert true und ist das
Argument des Arkustangens eine Matrix, Liste oder Gleichung wird die Funktion
auf die Elemente oder beiden Seiten der Gleichung angewendet. Der Standardwert
ist true.
trigsignHat die Optionsvariable trigsign
den Wert true, vereinfacht
Maxima atan2(-y, x) zu - atan2(y, x). Der Standardwert ist
true.
logarcHat die Optionsvariable logarc
den Wert true, wird der
Arkustangens durch einen Ausdruck mit der Logarithmusfunktionen ersetzt.
Der Standardwert von logarc ist false.
Maxima kann Ausdrücke mit dem Arkustangens ableiten und integrieren sowie die Grenzwerte von Ausdrücken mit dem Arkustangens ermitteln.
Beispiele:
(%i1) atan2([-1, 1],[-1, 0, 1]);
3 %pi %pi %pi 3 %pi %pi %pi
(%o1) [[- -----, - ---, - ---], [-----, ---, ---]]
4 2 4 4 2 4
(%i2) atan2(1,[-0.5, 0.5]);
(%o2) [2.034443935795703, 1.10714871779409]
(%i3) assume(a>0)$
(%i4) atan2(2*a, -2*a);
3 %pi
(%o4) -----
4
(%i5) diff(atan2(y,x), x);
y
(%o5) - -------
2 2
y + x
(%i6) integrate(atan2(y,x), x);
2 2
y log(y + x ) y
(%o6) -------------- + x atan(-)
2 x
Die Winkelfunktionen: Sinus, Kosinus, Tangens, Kotangens, Kosekans und Sekans.
Die Winkelfunktionen sind für das numerische und symbolische Rechnen geeignet.
Die Winkelfunktionen können für reelle und komplexe Gleitkommazahlen in
doppelter und in beliebiger Genauigkeit berechnet werden. Ist das Argument
eine ganze oder rationale Zahl, werden die Winkelfunktionen nicht numerisch
berechnet, sondern vereinfacht. Die numerische Berechnung kann mit den
Optionsvariablen und Auswertungsschaltern numer
und float
erzwungen werden.
Die Winkelfunktionen sind gerade oder ungerade und haben Spiegelsymmetrie. Maxima wendet diese Symmetrieeigenschaften automatisch bei der Vereinfachung von Ausdrücken mit Winkelfunktionen an.
Ist das Argument z eine Matrix, eine Liste oder eine Gleichung werden die
Winkelfunktionen auf die Elemente der Matrix, der Liste oder auf die beiden
Seiten der Gleichung angewendet. Dieses Verhalten wird von der Optionsvariablen
distribute_over
kontrolliert.
Winkelfunktionen können für das symbolische Rechnen verwendet werden. Maxima kann Ausdrücke mit Winkelfunktionen differenzieren und integrieren, Grenzwerte bestimmen sowie Gleichungen und Differentialgleichungen mit Winkelfunktionen lösen.
Das Argument der Winkelfunktionen kann eine Taylorreihe sein. In diesem Fall wird die Taylorreihenentwicklung für die Winkelfunktion vollständig ausgeführt.
Die folgenden Optionsvariablen kontrollieren die Vereinfachung der Winkelfunktionen:
distribute_overHat die Optionsvariable distribute_over
den Wert true und ist das
Argument der Winkelfunktion eine Matrix, Liste oder Gleichung wird die Funktion
auf die Elemente oder beiden Seiten der Gleichung angewendet. Der Standardwert
ist true.
%piargsHat die Optionsvariable %piargs
den Wert true, werden die
Winkelfunktionen für ganzzahlige und halbzahlige Vielfache der Konstanten
%pi zu speziellen Werten vereinfacht. Der Standardwert ist true.
%iargsHat die Optionsvariable %iargs
den Wert true und ist das Argument
der Winkelfunktion ein Vielfaches der imaginären Einheit %i werden die
Winkelfunktionen zu Hyperbelfunktionen vereinfacht. Der Standardwert ist
true.
trigsignHat die Optionsvariable trigsign
den Wert true, werden die gerade
oder ungerade Symmetrie der Winkelfunktionen bei der Vereinfachung angewendet.
Der Standardwert ist true.
triginversesHat die Optionsvariable triginverses
den Wert true und ist das
Argument eine inverse Winkelfunktion vereinfachen die Winkelfunktionen zu einem
einfachen algebraischen Ausdruck, zum Beispiel vereinfacht sin(acos(x))
zu sqrt(1-x^2). Der Standardwert ist true.
trigexpandHat die Optionsvariable trigexpand
den Wert true, dann werden die
Winkelfunktionen für ein Argument expandiert, das eine Summe oder ein Produkt
mit einer ganzen Zahl ist. Der Standardwert ist false.
exponentializeHat die Optionsvariable exponentialize
den Wert true, dann werden
die Winkelfunktionen in eine Exponentialform transformiert. Der Standardwert
ist false.
halfanglesHat die Optionsvariable halfangles
den Wert true, dann werden die
Winkelfunktionen für halbzahlige Argumente zu einem äquivalenten Ausdruck
transformiert. Der Standardwert ist false.
Beispiele:
Im Folgenden werden Beispiele für die Sinusfunktion gezeigt. Numerische Berechnungen für Gleitkommazahlen:
(%i1) sin(1+%i); (%o1) sin(%i + 1) (%i2) sin(1.0+%i); (%o2) .6349639147847361 %i + 1.298457581415977 (%i3) sin(1.0b0+%i); (%o3) 6.349639147847361b-1 %i + 1.298457581415977b0 (%i4) sin(1.0b0),fpprec:45; (%o4) 8.41470984807896506652502321630298999622563061b-1
Einige Vereinfachungen der Sinusfunktionen:
(%i5) sin(%i*(x+y));
(%o5) %i sinh(y + x)
(%i6) sin(%pi/3);
sqrt(3)
(%o6) -------
2
(%i2) sin(x+y),trigexpand:true;
(%o2) cos(x) sin(y) + sin(x) cos(y)
(%i3) sin(2*x+y),trigexpand:true;
2 2
(%o3) (cos (x) - sin (x)) sin(y) + 2 cos(x) sin(x) cos(y)
Grenzwerte, Ableitungen und Integrale mit der Sinusfunktion:
(%i4) limit(sin(x)/x,x,0);
(%o4) 1
(%i5) diff(sin(sqrt(x))/x,x);
cos(sqrt(x)) sin(sqrt(x))
(%o5) ------------ - ------------
3/2 2
2 x x
(%i6) integrate(sin(x^3),x);
(%o6)
1 3 1 3
gamma_incomplete(-, %i x ) + gamma_incomplete(-, - %i x )
3 3
- ---------------------------------------------------------
12
Reihenentwicklung der Sinusfunktion:
(%i7) taylor(sin(x),x,0,3);
3
x
(%o7)/T/ x - -- + . . .
6
Standardwert: true
Hat %piargs den Wert true, werden Winkel- und Hyperbelfunktionen
sowie deren Inverse zu algebraischen Konstanten vereinfacht, wenn das Argument
ein ganzzahliges Vielfaches der folgenden Konstanten ist:
%pi, %pi/2, %pi/3, %pi/4 oder %pi/6.
Maxima kennt weiterhin einige Identitäten, wenn die Konstante
%pi
mit einer Variablen multipliziert wird, die als ganzzahlig deklariert wurde.
Beispiele:
(%i1) %piargs : false$
(%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)];
%pi %pi
(%o2) [sin(%pi), sin(---), sin(---)]
2 3
(%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
%pi %pi %pi
(%o3) [sin(---), sin(---), sin(---)]
4 5 6
(%i4) %piargs : true$
(%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)];
sqrt(3)
(%o5) [0, 1, -------]
2
(%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
1 %pi 1
(%o6) [-------, sin(---), -]
sqrt(2) 5 2
(%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3),
cos (sqrt(2)*%pi/3)];
1 1 sqrt(2) %pi
(%o7) [-, - -, sqrt(3), cos(-----------)]
2 2 3
Weitere Identitäten werden angewendet, wenn
%pi und %pi/2
mit einer ganzzahligen Variable multipliziert werden.
(%i1) declare (n, integer, m, even)$
(%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
cos (%pi/2 * m)];
m/2
(%o2) [0, 1, 0, (- 1) ]
Standardwert: true
Hat %iargs den Wert true, werden Winkelfunktionen zu
Hyperbelfunktionen vereinfacht, wenn das Argument ein Vielfaches der
imaginären Einheit
%i
ist.
Die Vereinfachung zu Hyperbelfunktionen wird auch dann ausgeführt, wenn das Argument offensichtlich reell ist.
Beispiele:
(%i1) %iargs : false$ (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o2) [sin(%i x), cos(%i x), tan(%i x)] (%i3) %iargs : true$ (%i4) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o4) [%i sinh(x), cosh(x), %i tanh(x)]
Auch wenn das Argument offensichtlich reell ist, wird zu einer Hyperbelfunktion vereinfacht.
(%i1) declare (x, imaginary)$ (%i2) [featurep (x, imaginary), featurep (x, real)]; (%o2) [true, false] (%i3) sin (%i * x); (%o3) %i sinh(x)
Standardwert: false
Hat halfangles den Wert true, werden Winkel- und
Hyperbelfunktionen mit halbzahligen Argumenten expr/2 vereinfacht.
Für ein reelles Argument x im Intervall 0 < x < 2*%pi vereinfacht
der Sinus für ein halbzahliges Argument zu einer einfachen Formel:
sqrt(1 - cos(x))
----------------
sqrt(2)
Ein komplizierter Faktor wird gebraucht, damit die Formel korrekt ist für ein komplexes Argument z:
realpart(z)
floor(-----------)
2 %pi
(- 1) (1 - unit_step(- imagpart(z))
realpart(z) realpart(z)
floor(-----------) - ceiling(-----------)
2 %pi 2 %pi
((- 1) + 1))
Maxima kennt diesen Faktor und ähnliche Faktoren für die Sinus, Kosinus, Sinus Hyperbolicus und Kosinus Hyperbolicus Funktionen. Für spezielle Argumente z dieser Funktionen vereinfachen diese Funktionen entsprechend.
Beispiele:
(%i1) halfangles:false;
(%o1) false
(%i2) sin(x/2);
x
(%o2) sin(-)
2
(%i3) halfangles:true;
(%o3) true
(%i4) sin(x/2);
x
floor(-----)
2 %pi
sqrt(1 - cos(x)) (- 1)
(%o4) ----------------------------------
sqrt(2)
(%i5) assume(x>0, x<2*%pi)$
(%i6) sin(x/2);
sqrt(1 - cos(x))
(%o6) ----------------
sqrt(2)
Das Paket ntrig enthält Regeln, um Winkelfunktionen zu vereinfachen,
die Argumente der Form f(n %pi/10) haben. f ist eine
der Funktionen sin, cos, tan, csc, sec oder
cot.
Das Kommando load(ntrig) lädt das Paket. Die Vereinfachungen werden
dann von Maxima automatisch ausgeführt.
Die Funktion trigexpand expandiert Winkel- und Hyperbelfunktionen im
Ausdruck expr, die Summen und Vielfache von Winkeln als Argument haben.
Die besten Ergebnisse werden erzielt, wenn der Ausdruck expr zunächst
expandiert wird.
Folgende Schalter kontrollieren trigexpand:
trigexpandWenn true, werden Sinus- und Kosinusfunktionen expandiert.
halfanglesWenn true, werden Vereinfachungen für halbzahlige Argumente angewendet.
trigexpandplusWenn true, werden Winkelfunktionen, die eine Summe als Argument haben,
wie zum Beispiel sin(x+y), vereinfacht.
trigexpandtimesWenn true, werden Winkelfunktionen, die ein Produkt als Argument haben,
wie zum Beispiel sin(2 x), vereinfacht.
Beispiele:
(%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;
2 2
(%o1) - sin (x) + 3 cos (x) + x
(%i2) trigexpand(sin(10*x+y));
(%o2) cos(10 x) sin(y) + sin(10 x) cos(y)
Standardwert: true
trigexpandplus kontrolliert die Vereinfachung von Winkelfunktionen mit
der Funktion trigexpand
für den Fall, dass Winkelfunktionen mit Summen
als Argumente auftreten. Hat trigexpandplus den Wert true,
werden zum Beispiel Winkelfunktionen wie sin(x+y) vereinfacht.
Standardwert: true
trigexpandtimes kontrolliert die Vereinfachung von Winkelfunktionen mit
der Funktion trigexpand
für den Fall, dass Winkelfunktionen mit
Produkten als Argumente auftreten. Hat trigexpandtimes den Wert
true, werden zum Beispiel Winkelfunktionen wie sin(2 x)
vereinfacht.
Standardwert: true
Kontrolliert die Vereinfachung, wenn das Argument einer Winkelfunktion oder Hyperbelfunktion eine der inversen Funktion ist.
Hat triginverses den Wert all, vereinfachen beide Ausdrücke
atan(tan(x)) und tan(atan(x)) zum Wert x.
Hat triginverses den Wert all, wird
arcfun(fun(x)) nicht vereinfacht.
Hat triginverses den Wert false, werden
arcfun(fun(x)) und
fun(arcfun(x)) nicht vereinfacht.
Produkte und Potenzen von Winkelfunktionen und den Hyperbelfunktionen mit dem
Argument x werden zu Funktionen vereinfacht, die Vielfache von x
enthalten. trigreduce versucht auch, Sinus- und Kosinusfunktionen in
einem Nenner zu eliminieren. Wird keine Variable x angegeben, werden alle
Variablen im Ausdruck expr betrachtet.
Siehe auch poissimp.
(%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);
cos(2 x) cos(2 x) 1 1
(%o1) -------- + 3 (-------- + -) + x - -
2 2 2 2
Standardwert: true
Hat trigsign den Wert true, werden Winkelfunktionen mit einem
negativem Argument vereinfacht. Zum Beispiel vereinfacht in diesem Fall
sin(-x) zu -sin(x).
Wendet die Identitäten
sin(x)^2 + cos(x)^2 = 1
und
cosh(x)^2 - sinh(x)^2 = 1
an, um Ausdrücke, die Funktionen wie tan, sec, usw. enthalten,
zu Ausdrücken mit den Funktionen sin, cos, sinh,
cosh zu vereinfachen.
Die Anwendung von Funktionen wie trigreduce,
ratsimp
und
radcan
kann den Ausdruck weiter vereinfachen.
Das Kommando demo(trgsmp) zeigt einige Beispiele.
Gives a canonical simplifyed quasilinear form of a trigonometrical expression;
expr is a rational fraction of several sin, cos or
tan, the arguments of them are linear forms in some variables (or
kernels) and %pi/n (n integer) with integer coefficients.
The result is a simplified fraction with numerator and denominator linear in
sin and cos. Thus trigrat linearize always when it is
possible.
(%i1) trigrat(sin(3*a)/sin(a+%pi/3)); (%o1) sqrt(3) sin(2 a) + cos(2 a) - 1
The following example is taken from Davenport, Siret, and Tournier, Calcul Formel, Masson (or in English, Addison-Wesley), section 1.5.5, Morley theorem.
(%i1) c : %pi/3 - a - b$
(%i2) bc : sin(a)*sin(3*c)/sin(a+b);
%pi
sin(a) sin(3 (- b - a + ---))
3
(%o2) -----------------------------
sin(b + a)
(%i3) ba : bc, c=a, a=c;
%pi
sin(3 a) sin(b + a - ---)
3
(%o3) -------------------------
%pi
sin(a - ---)
3
(%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b);
2 2 %pi
sin (3 a) sin (b + a - ---)
3
(%o4) ---------------------------
2 %pi
sin (a - ---)
3
%pi
- (2 sin(a) sin(3 a) sin(3 (- b - a + ---)) cos(b)
3
%pi %pi
sin(b + a - ---))/(sin(a - ---) sin(b + a))
3 3
2 2 %pi
sin (a) sin (3 (- b - a + ---))
3
+ -------------------------------
2
sin (b + a)
(%i5) trigrat (ac2);
(%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)
- 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)
- 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)
+ 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)
+ sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)
+ sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)
- 9)/4
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 10.6.1 Einführung in Hyperbelfunktionen | ||
| 10.6.2 Funktionen und Variablen für Hyperbelfunktionen |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die inversen Hyperbelfunktionen: Areasinus Hyperbolicus, Areakosinus Hyperbolicus, Areatangens Hyperbolicus, Areakotangens Hyperbolicus, Areakosekans Hyperbolicus, Areasekans Hyperbolicus.
Die Hyperbelfunktionen: Sinus Hyperbolicus, Kosinus Hyperbolicus, Tangens Hyperbolicus, Kotangens Hyperbolicus, Kosekans Hyperbolicus, Sekans Hyperbolicus.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
Kopiert s in den Zufallszustand des Zufallszahlengenerators.
set_random_state gibt immer done zurück.
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
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Crategus on Dezember, 12 2012 using texi2html 1.76.