[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Funktion abs
ist die Betragsfunktion und für numerische und
symbolische Rechnungen geeignet. Ist das Argument expr 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. Siehe auch diff
,
integrate
und limit
.
Das Paket abs_integrate
erweitert
Maximas Möglichkeiten, Integrale mit der Betragsfunktion zu berechnen.
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 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 werden.
(%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.
(%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 expr 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.
Wenn möglich werden andere Ausdrücke von Maxima vereinfacht. Maxima kennt
insbesondere Vereinfachungen für den Fall, dass das Argument expr ein
Ausdruck mit den Funktionen floor
oder round
ist. Weiterhin
werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte
herangezogen. Siehe das Kapitel Funktionen und Variablen für Fakten.
Ist das Argument expr der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.
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 expr 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.
Wenn möglich werden andere Ausdrücke von Maxima vereinfacht. Maxima kennt
insbesondere Vereinfachungen für den Fall, dass das Argument expr ein
Ausdruck mit den Funktionen ceiling
oder round
ist. Weiterhin
werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte
herangezogen. Siehe das Kapitel Funktionen und Variablen für Fakten.
Ist das Argument expr der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.
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, wird ein Maxima-Fehler signalisiert.
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, wird ein Maxima-Fehler signalisiert.
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. Treten symbolische Argumente oder
Ausdrücke auf, gibt Maxima einen vereinfachten Ausdruck zurück.
Die unendliche Größen inf
und minf
können als Argument
auftreten und werden von max
korrekt behandelt.
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 eleminieren, 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
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. Treten symbolische Argumente oder
Ausdrücke auf, gibt Maxima einen vereinfachten Ausdruck zurück.
Die unendliche Größen inf
und minf
können als Argument
auftreten und werden von min
korrekt behandelt.
Die Vereinfachung der Funktion mmin
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 eleminieren, 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
Die Funktion round
ist für das numerische und symbolische Rechnen
geeignet.
Ist das Argument expr 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.
Wenn möglich werden andere Ausdrücke von Maxima vereinfacht. Maxima kennt
insbesondere Vereinfachungen für den Fall, dass das Argument expr ein
Ausdruck mit den Funktionen ceiling
oder floor
ist. Weiterhin
werden für die Vereinfachung die Aussagen und Fakten der aktiven Kontexte
herangezogen. Siehe das Kapitel Funktionen und Variablen für Fakten.
Ist das Argument expr der Funktion ein komplexer Ausdruck, wird eine Substantivform zurückgegeben.
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 expr 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
expr eine komplexe Zahl, vereinfacht die Funktion signum(expr)
zu
expr/abs(expr)
.
Ist das Argument expr 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 muss die Betragsfunktion abs
verwendet werden.
Das Ergebnis der Funktion cabs
kann die Betragsfunktion abs
und
die Arcustangensfunktion atan2
enthalten.
cabs
wird automatisch auf die Elemente von Listen und Matrizen sowie auf
die beiden Seiten von Gleichungen angewendet. Siehe distribute_over
.
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 angwendet 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 Ausrucks 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 liefert, 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 Binomialkoeffizient, 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
Binomialkoeffizient numerisch berechnet. Sind die Argumente x und
y reelle oder komplexe Gleitkommazahlen, wird der Binomialkoeffizient
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 Binomialkoeffizient zu einem Polynom vereinfacht.
Mit den Funkionen makefact
oder makegamma
wird der
Binomialkoeffizient in einen äquivalenten Ausdruck mit der Fakultät oder
der Gammafunktion transformiert.
Maxima kennt die Ableitung des Binomialkoeffizienten.
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(n %pi)) n/2 n (---) 2 gamma(- + 1) %pi 2
Die Funktion double_factorial
ist für das numerische und symbolische
Rechnen geeignet. Ist das Argument expr 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 und 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 x
, vereinfacht x!
zum Produkt der ganzen
Zahlen von 1 bis einschließlich x
. 0!
vereinfacht zu 1.
Für reelle und komplexe Gleitkommazahlen wird x!
mit der
Verallgemeinerung gamma(x+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:
%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 Funktion
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:
logexpand
log(a^b)
wird 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. Das ist der Standardwert.
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
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
.
log(a^b)
wird 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.
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) rectform(sqrt(x+%i*y)); 2 2 1/4 atan2(y, x) (%o6) %i (y + x ) sin(-----------) 2 2 2 1/4 atan2(y, x) + (y + x ) cos(-----------) 2 (%i7) integrate(sqrt(t)*(t+1)^-2,t,0,1); %pi - 2 (%o7) ------- 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 trigonometrischen Funktionen: Arkussinus, Arkuskosinus, Arkustangens, Arkuskotanges, Arkuskosekans und Arkussekans.
- Gibt den Wert von atan(y/x)
im Intervall -%pi
bis %pi
zurück.
Die Winkelfunktionen: Sinus, Kosinus, Tangens, Kotangens, Kosekans und Sekans.
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 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_over
Hat 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
.
%piargs
Hat 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
.
%iargs
Hat 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
.
trigsign
Hat die Optionsvariable trigsign
den Wert true
, werden die gerade
oder ungerade Symmetrie der Winkelfunktionen bei der Vereinfachung angewendet.
Der Standardwert ist true
.
triginverses
Hat 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
.
trigexpand
Hat 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
.
exponentialize
Hat die Optionsvariable exponentialize
den Wert true
, dann werden
die Winkelfunktionen in eine Exponentialform transformiert. Der Standardwert
ist false
.
halfangles
Hat 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
:
trigexpand
Wenn true
, werden Sinus- und Kosinusfunktionen expandiert.
halfangles
Wenn true
, werden Vereinfachungen für halbzahlige Argumente angewendet.
trigexpandplus
Wenn true
, werden Winkelfunktionen, die eine Summe als Argument haben,
wie zum Beispiel sin(x+y)
, vereinfacht.
trigexpandtimes
Wenn 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] | [ ? ] |
- Areakosinus Hyperbolicus.
- Areakotangens Hyperbolicus.
- Areakosekans Hyperbolicus.
- Areasekans Hyperbolicus.
- Areasinus Hyperbolicus.
- Areatangens Hyperbolicus.
- Kosinus Hyperbolicus.
- Kotangens Hyperbolicus.
- Kosekans Hyperbolicus.
- Sekans Hyperbolicus.
- Sinus Hyperbolicus.
- Tangens 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 Robert Dodier on April, 4 2011 using texi2html 1.76.