| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Spezielle Funktionen haben die folgenden Notationen:
bessel_j (v, z) Bessel-Funktion der 1. Art bessel_y (v, z) Bessel-Funktion der 2. Art bessel_i (v, z) Modifizierte Bessel-Funktion der 1. Art bessel_k (v, z) Modifizierte Bessel-Funktion der 2. Art hankel_1 (v, z) Hankel-Funktion der 1. Art hankel_2 (v, z) Hankel-Funktion der 2. Art airy_ai (z) Airy-Funktion Ai(z) airy_bi (z) Airy-Funktion Bi(z) airy_dai (z) Ableitung der Airy-Funktion Ai(z) airy_dbi (z) Ableitung der Airy-Funktion Bi(z) struve_h (v, z) Struve-Funktion H[v](z) struve_l (v, z) Struve-Funktion L[v](z) %f[p,q] ([], [], z) Hypergeometrische Funktion gamma() Gammafunktion gammagreek(a, z) unvollständige Gamma-Funktion gammaincomplete(a,z) unvollständige Gamma-Funktion hypergeometric(l1, l2, z) Hypergeometrische Funktion %m[u,k] (z) Whittaker-Funktion der 1. Art %w[u,k] (z) Whittaker-Funktion der 2. Art erf (z) Fehlerfunktion erfc (z) Komplementäre Fehlerfunktion erfi (z) imaginäre Fehlerfunktion expintegral_e (v,z) Exponentielles Integral E expintegral_e1 (z) Exponentielles Integral E1 expintegral_ei (z) Exponentielles integral Ei expintegral_li (z) Logarithmisches Integral Li expintegral_si (z) Exponentielles Integral Si expintegral_ci (z) Exponentielles Integral Ci expintegral_shi (z) Exponentielles Integral Shi expintegral_chi (z) Exponentielles Integral Chi parabolic_cylinder_d (v,z) Parabolische Zylinderfunktion D
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 22.2.1 Bessel-Funktionen | ||
| 22.2.2 Hankel-Funktionen | ||
| 22.2.3 Airy-Funktionen | ||
| 22.2.4 Struve-Funktionen |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Bessel-Funktion der ersten Art der Ordnung v mit dem Argument
z. bessel_j ist definiert als
inf
==== k
\ (- 1) z 2 k + v
J (z) = > ------------------- (-)
v / k! gamma(v + k + 1) 2
====
k = 0
Die Reihenentwicklung wird nicht für die numerische Berechnung genutzt.
Die Bessel-Funktion bessel_j ist für das numerische und symbolische
Rechnen geeignet.
Maxima berechnet bessel_j numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht
implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.
bessel_j hat die folgenden Eigenschaften, die mit mit der Funktion
properties
angezeigt werden und auf das symbolische Rechnen Einfluss
haben:
conjugate functionbessel_j hat Spiegelsymmetrie, wenn das Argument z keine negative
reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
conjugate
für die Vereinfachung eines Ausdrucks genutzt.
complex characteristicMaxima kennt den Realteil und den Imaginärteil von bessel_j für
spezielle Argumente v und z.
limit functionMaxima kennt spezielle Grenzwerte der Funktion bessel_j.
integralMaxima kennt das Integral der Funktion bessel_j für die
Integrationsvariable z.
gradefMaxima kennt die Ableitungen der Funktion bessel_j nach den
Argumenten v und z.
Die Vereinfachung der Bessel-Funktion bessel_j wird von den folgenden
Optionsvariablen kontrolliert:
distribute_overHat die Optionsvariable distribute_over
den Wert true und sind
die Argumente von bessel_j eine Matrix, Liste oder Gleichung wird die
Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
Standardwert ist true.
besselexpandHat die Optionsvariable besselexpand
den Wert true, wird
bessel_j mit einer halbzahligen Ordnung v als Sinus- und
Kosinusfunktionen entwickelt.
bessel_reduceHat die Optionsvariable bessel_reduce
den Wert true, wird
bessel_j mit einer ganzzahligen Ordnung n nach Bessel-Funktionen
bessel_j mit der niedrigsten Ordnung 0 und 1 entwickelt.
hypergeometric_representationHat die Optionsvariable hypergeometric_representation
den Wert
true, dann wird bessel_j als hypergeometrische Funktion
dargestellt.
Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
bessel_j. Für eine ganze Zahl n vereinfacht daher
bessel_j(-n, z) zu (-1)^n bessel_j(n, z).
Maxima kennt noch die Funktion spherical_bessel_j,
die im Paket
orthopoly definiert ist. Siehe auch die anderen Bessel-Funktionen
bessel_y,
bessel_i
und bessel_k
sowie die
weiteren mit den Bessel-Funktionen verwandten Funktionen wie die
Hankel-Funktionen in Hankel-Funktionen, Airy-Funktionen in
Airy-Funktionen und Struve-Funktionen in Struve-Funktionen.
Beispiele:
Numerisches Rechnen mit der Bessel-Funktion. Für große Gleitkommazahlen ist die numerische Berechnung nicht implementiert.
(%i1) bessel_j(1,[0.5, 0.5+%i]);
(%o1) [.2422684576748739, .5124137767280905 %i
+ .3392601907198862]
(%i2) bessel_j(1,[0.5b0, 0.5b0+%i]);
(%o2) [bessel_j(1, 5.0b-1), bessel_j(1, %i + 5.0b-1)]
Vereinfachungen der Bessel-Funktion mit den Optionsvariablen besselexpand
und bessel_reduce.
(%i3) bessel_j(1/2,x), besselexpand:true;
sqrt(2) sin(x)
(%o3) -----------------
sqrt(%pi) sqrt(x)
(%i4) bessel_j(3,x), bessel_reduce:true;
2 bessel_j(1, x)
4 (---------------- - bessel_j(0, x))
x
(%o4) ------------------------------------- - bessel_j(1, x)
x
Ableitungen und Integrale der Bessel-Funktion. Das letzte Beispiel zeigt
die Laplace-Transformation der Bessel-Funktion mit der Funktion
laplace.
(%i5) diff(bessel_j(2,x), x);
bessel_j(1, x) - bessel_j(3, x)
(%o5) -------------------------------
2
(%i6) diff(bessel_j(v,x), x);
bessel_j(v - 1, x) - bessel_j(v + 1, x)
(%o6) ---------------------------------------
2
(%i7) integrate(bessel_j(v,x), x);
(%o7)
2
v 1 v 3 x - v - 1 v + 1
hypergeometric([- + -], [- + -, v + 1], - --) 2 x
2 2 2 2 4
-------------------------------------------------------------
v 1
(- + -) gamma(v + 1)
2 2
(%i8) laplace(bessel_j(2,t), t, s);
1 2
(1 - sqrt(-- + 1)) s
2
s
(%o8) ---------------------
1
sqrt(-- + 1)
2
s
Bessel-Funktionen als Lösung einer linearen Differentialgleichung zweiter Ordnung.
(%i1) depends(y, x);
(%o1) [y(x)]
(%i2) declare(n, integer);
(%o2) done
(%i3) 'diff(y, x, 2)*x^2 + 'diff(y, x)*x + y*(x^2-n^2) = 0;
2
2 2 d y 2 dy
(%o3) y (x - n ) + --- x + -- x = 0
2 dx
dx
(%i4) ode2(%, y, x);
(%o4) y = %k2 bessel_y(n, x) + %k1 bessel_j(n, x)
Die Bessel-Funktion der zweiten Art der Ordnung v mit dem Argument
z. bessel_y ist definiert als
cos(%pi v) J (z) - J (z)
v - v
Y (z) = --------------------------
v sin(%pi v)
für den Fall, dass v keine ganze Zahl ist. Ist v eine ganze
Zahl n, dann wird die Bessel-Funktion bessel_y wie folgt als
ein Grenzwert definiert
Y (z) = limit Y (z)
n v -> n v
Die Bessel-Funktion bessel_y ist für das numerische und symbolische
Rechnen geeignet.
Maxima berechnet bessel_y numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht
implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.
bessel_y hat die folgenden Eigenschaften, die mit mit der Funktion
properties
angezeigt werden und auf das symbolische Rechnen Einfluss
haben:
conjugate functionbessel_y hat Spiegelsymmetrie, wenn das Argument z keine negative
reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
conjugate
für die Vereinfachung eines Ausdrucks genutzt.
complex characteristicMaxima kennt den Realteil und den Imaginärteil von bessel_y für
spezielle Argumente v und z.
limit functionMaxima kennt spezielle Grenzwerte der Funktion bessel_y.
integralMaxima kennt das Integral der Funktion bessel_y für die
Integrationsvariable z.
gradefMaxima kennt die Ableitungen der Funktion bessel_y nach den
Argumenten v und z.
Die Vereinfachung der Bessel-Funktion bessel_y wird von den folgenden
Optionsvariablen kontrolliert:
distribute_overHat die Optionsvariable distribute_over
den Wert true und sind
die Argumente von bessel_y eine Matrix, Liste oder Gleichung wird die
Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
Standardwert ist true.
besselexpandHat die Optionsvariable besselexpand
den Wert true, wird
bessel_y mit einer halbzahligen Ordnung v als Sinus- und
Kosinusfunktionen entwickelt.
bessel_reduceHat die Optionsvariable bessel_reduce
den Wert true, wird
bessel_y mit einer ganzzahligen Ordnung n nach Bessel-Funktionen
bessel_y mit der niedrigsten Ordnung 0 und 1 entwickelt.
hypergeometric_representationHat die Optionsvariable hypergeometric_representation
den Wert
true, dann wird bessel_y als hypergeometrische Funktion
dargestellt. Es ist zu beachten, dass die hypergeometrische Funktion nur für
eine nicht ganzzahlige Ordnung v gültig ist.
Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
bessel_y. Für eine ganze Zahl n vereinfacht daher
bessel_y(-n, z) zu (-1)^n bessel_y(n, z).
Maxima kennt noch die Funktion spherical_bessel_y,
die im Paket
orthopoly definiert ist. Siehe auch die anderen Bessel-Funktionen
bessel_j,
bessel_i
und bessel_k
sowie die
weiteren mit den Bessel-Funktionen verwandten Funktionen wie die
Hankel-Funktionen in Hankel-Funktionen, Airy-Funktionen in
Airy-Funktionen und Struve-Funktionen in Struve-Funktionen.
Siehe die Funktion bessel_j
für Beispiele mit Bessel-Funktionen.
Die modifizierte Bessel-Funktion der ersten Art der Ordnung v mit dem
Argument v. bessel_i ist definiert als
inf
====
\ 1 z 2 k + v
I (z) = > ------------------- (-)
v / k! gamma(v + k + 1) 2
====
k = 0
Die Reihenentwicklung wird nicht für die numerische Berechnung genutzt.
Die Bessel-Funktion bessel_i ist für das numerische und symbolische
Rechnen geeignet.
Maxima berechnet bessel_i numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht
implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.
bessel_i hat die folgenden Eigenschaften, die mit mit der Funktion
properties
angezeigt werden und auf das symbolische Rechnen Einfluss
haben:
conjugate functionbessel_i hat Spiegelsymmetrie, wenn das Argument z keine negative
reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
conjugate
für die Vereinfachung eines Ausdrucks genutzt.
complex characteristicMaxima kennt den Realteil und den Imaginärteil von bessel_i für
spezielle Argumente v und z.
limit functionMaxima kennt spezielle Grenzwerte der Funktion bessel_i.
integralMaxima kennt das Integral der Funktion bessel_i für die
Integrationsvariable z.
gradefMaxima kennt die Ableitungen der Funktion bessel_i nach den
Argumenten v und z.
Die Vereinfachung der Bessel-Funktion bessel_i wird von den folgenden
Optionsvariablen kontrolliert:
distribute_overHat die Optionsvariable distribute_over
den Wert true und sind
die Argumente von bessel_i eine Matrix, Liste oder Gleichung wird die
Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
Standardwert ist true.
besselexpandHat die Optionsvariable besselexpand
den Wert true, wird
bessel_i mit einer halbzahligen Ordnung v als Hyperbelfunktionen
entwickelt.
bessel_reduceHat die Optionsvariable bessel_reduce
den Wert true, wird
bessel_i mit einer ganzzahligen Ordnung n nach Bessel-Funktionen
bessel_i mit der niedrigsten Ordnung 0 und 1 entwickelt.
hypergeometric_representationHat die Optionsvariable hypergeometric_representation
den Wert
true, dann wird bessel_i als hypergeometrische Funktion
dargestellt.
Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
bessel_i. Für eine ganze Zahl n vereinfacht daher
bessel_i(-n, z) zu bessel_i(n, z).
Siehe auch die anderen Bessel-Funktionen bessel_j,
bessel_y
und bessel_k
sowie die weiteren mit den Bessel-Funktionen
verwandten Funktionen wie die Hankel-Funktionen in Hankel-Funktionen,
Airy-Funktionen in Airy-Funktionen und Struve-Funktionen in
Struve-Funktionen.
Siehe die Funktion bessel_j
für Beispiele mit Bessel-Funktionen.
Die modifizierte Bessel-Funktion der zweiten Art der Ordnung v mit dem
Argument z. bessel_k ist definiert als
%pi csc(%pi u) (I (z) - I (z))
- v u
K (z) = --------------------------------
v 2
für den Fall, dass v keine ganze Zahl ist. Ist v eine ganze
Zahl n, dann wird die Bessel-Funktion bessel_k wie folgt als
Grenzwert definiert
(%o5) K (z) = limit K (z)
n v -> n v
Die Bessel-Funktion bessel_k ist für das numerische und symbolische
Rechnen geeignet.
Maxima berechnet bessel_k numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht
implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.
bessel_k hat die folgenden Eigenschaften, die mit mit der Funktion
properties
angezeigt werden und auf das symbolische Rechnen Einfluss
haben:
conjugate functionbessel_k hat Spiegelsymmetrie, wenn das Argument z keine negative
reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
conjugate
für die Vereinfachung eines Ausdrucks genutzt.
complex characteristicMaxima kennt den Realteil und den Imaginärteil von bessel_k für
spezielle Argumente v und z.
limit functionMaxima kennt spezielle Grenzwerte der Funktion bessel_k.
integralMaxima kennt das Integral der Funktion bessel_k für die
Integrationsvariable z.
gradefMaxima kennt die Ableitungen der Funktion bessel_k nach den
Argumenten v und z.
Die Vereinfachung der Bessel-Funktion bessel_k wird von den folgenden
Optionsvariablen kontrolliert:
distribute_overHat die Optionsvariable distribute_over
den Wert true und sind
die Argumente von bessel_k eine Matrix, Liste oder Gleichung wird die
Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
Standardwert ist true.
besselexpandHat die Optionsvariable besselexpand
den Wert true, wird
bessel_k mit einer halbzahligen Ordnung v als Exponentialfunktion
entwickelt.
bessel_reduceHat die Optionsvariable bessel_reduce
den Wert true, wird
bessel_k mit einer ganzzahligen Ordnung n nach Bessel-Funktionen
bessel_k mit der niedrigsten Ordnung 0 und 1 entwickelt.
hypergeometric_representationHat die Optionsvariable hypergeometric_representation
den Wert
true, dann wird bessel_k als hypergeometrische Funktion
dargestellt. Es ist zu beachten, dass die hypergeometrische Funktion nur für
eine nicht ganzzahlige Ordnung v gültig ist.
Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
bessel_k. Für eine ganze Zahl n vereinfacht daher
bessel_k(-n, z) zu bessel_y(n, z).
Siehe auch die anderen Bessel-Funktionen bessel_j,
bessel_y
und bessel_i
sowie die weiteren mit den Bessel-Funktionen verwandten
Funktionen wie die Hankel-Funktionen in Hankel-Funktionen, Airy-Funktionen
in Airy-Funktionen und Struve-Funktionen in Struve-Funktionen.
Siehe die Funktion bessel_j
für Beispiele mit Bessel-Funktionen.
Standardwert: false
Hat die Optionsvariable bessel_reduce den Wert true, werden
Bessel-Funktionen mit einer ganzzahligen Ordnung n nach Bessel-Funktionen
mit der niedrigsten Ordnung 0 und 1 entwickelt.
Standardwert: false
Hat die Optionsvariable besselexpand den Wert true, werden
Bessel-Funktion mit einer halbzahligen Ordnung v als Sinus-,
Kosinus-, Hyperbel- oder Exponentialfunktionen entwickelt. Die Optionsvariable
besselexpand kontrolliert auch die Entwicklung der Hankel-Funktionen
hankel_1
und hankel_2
sowie der Struve-Funktionen struve_h
und struve_l.
Beispiele:
(%i1) besselexpand: false$
(%i2) bessel_j(3/2, z);
3
(%o2) bessel_j(-, z)
2
(%i3) besselexpand: true$
(%i4) bessel_j(3/2, z);
sin(z) cos(z)
sqrt(2) sqrt(z) (------ - ------)
2 z
z
(%o4) ---------------------------------
sqrt(%pi)
Weitere Beispiele für die Entwicklungen der Funktionen bessel_k
und
struve_h.
(%i5) bessel_k(3/2, z);
1 - z
sqrt(%pi) (- + 1) %e
z
(%o5) -----------------------
sqrt(2) sqrt(z)
(%i6) struve_h(3/2, z);
2
2 z sin(z) + 2 cos(z) - z - 2
(%o6) - ------------------------------
3/2
sqrt(2) sqrt(%pi) z
Die skalierte modifizierte Bessel-Funktion der ersten Art der Ordnung v mit dem Argument z. Diese ist definiert als
- abs(z)
scaled_bessel_i(v, z) = bessel_i(v, z) %e
scaled_bessel_i liefert ein numerisches Ergebnis, wenn die Argumente
v und z Zahlen sind. Die Funktion kann geeignet sein, wenn
bessel_i für große Argumente z numerisch berechnet werden
soll. Ganze, rationale oder große Gleitkommazahlen werden in
Gleitkommazahlen mit doppelter Genauigkeit umgewandelt. Sind die Argumente
keine Zahlen, wird ein vereinfachter Ausdruck mit der Funktion
bessel_i
zurückgegeben.
scaled_bessel_i ist eine Verbfunktion, die nicht für das symbolische
Rechnen geeignet ist. Für das symbolische Rechnen ist die Funktion
bessel_i
zu verwenden.
Beispiele:
(%i1) scaled_bessel_i(1, 50);
(%o1) .05599312389289544
(%i2) scaled_bessel_i(1/2, 50);
(%o2) .05641895835477567
(%i3) scaled_bessel_i(v, x);
- abs(x)
(%o3) bessel_i(v, x) %e
Entspricht scaled_bessel_i(0,z). Siehe scaled_bessel_i.
Entspricht scaled_bessel_i(1,z). Siehe scaled_bessel_i.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Hankel-Funktion der ersten Art der Ordnung v mit dem Argument
z. Siehe A & S 9.1.3. hankel_1 ist definiert als
H1 (z) = J (z) + %i Y (z)
v v v
Die Hankel-Funktion hankel_1 ist für das numerische und symbolische
Rechnen geeignet.
Maxima berechnet hankel_1 numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem
Fall gibt Maxima eine Substantivform zurück.
Hat die Optionsvariable besselexpand
den Wert true, werden
Hankel-Funktionen hankel_1 mit einer halbzahligen Ordnung v als
Sinus- und Kosinusfunktionen entwickelt.
Maxima kennt die Ableitung der Hankel-Funktion hankel_1 nach dem zweiten
Argument z.
Siehe auch die Funktion hankel_2
sowie die Bessel-Funktionen in
Bessel-Funktionen.
Beispiele:
Numerische Berechnung.
(%i1) hankel_1(1, 0.5); (%o1) .2422684576748738 - 1.471472392670243 %i (%i2) hankel_1(1, 0.5+%i); (%o2) - .2558287994862166 %i - 0.239575601883016
Für eine komplex Ordnung kann Maxima keinen numerischen Wert berechnet. Das Ergebnis ist eine Substantivform.
(%i3) hankel_1(%i, 0.5+%i); (%o3) hankel_1(%i, %i + 0.5)
Entwicklung der Hankel-Funktion hankel_1, wenn die Optionsvariable
besselexpand den Wert true hat.
(%i4) hankel_1(1/2, z), besselexpand:true;
sqrt(2) sin(z) - sqrt(2) %i cos(z)
(%o4) ----------------------------------
sqrt(%pi) sqrt(z)
Ableitung der Hankel-Funktion hankel_1 nach dem Argument z. Die
Ableitung nach der Ordnung v ist nicht implementiert. Maxima gibt eine
Substantivform zurück.
(%i5) diff(hankel_1(v,z), z);
hankel_1(v - 1, z) - hankel_1(v + 1, z)
(%o5) ---------------------------------------
2
(%i6) diff(hankel_1(v,z), v);
d
(%o6) -- (hankel_1(v, z))
dv
Die Hankel-Funktion der zweiten Art der Ordnung v mit dem Argument
z. Siehe A & S 9.1.4. hankel_2 ist definiert als
H2 (z) = J (z) - %i Y (z)
v v v
Die Hankel-Funktion hankel_2 ist für das numerische und symbolische
Rechnen geeignet.
Maxima berechnet hankel_2 numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem
Fall gibt Maxima eine Substantivform zurück.
Hat die Optionsvariable besselexpand
den Wert true, werden
Hankel-Funktionen hankel_2 mit einer halbzahligen Ordnung v als
Sinus- und Kosinusfunktionen entwickelt.
Maxima kennt die Ableitung der Hankel-Funktion hankel_2 nach dem zweiten
Argument z.
Für Beispiele siehe hankel_1.
Siehe auch die Bessel-Funktionen in
Bessel-Funktionen.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Airy-Funktionen Ai(z) und Bi(z) sind definiert in Abramowitz
und Stegun, Handbook of Mathematical Functions, Kapitel 10.4. Die
Funktionen y = Ai(z) und y = Bi(z) sind zwei linear unabhängige
Lösungen der Airy-Differentialgleichung.
2
d y
--- - y z = 0
2
dz
Die Airy-Funktion Ai(z) (A & S 10.4.2).
Die Airy-Funktion airy_ai ist für das symbolische und numerische
Rechnen geeignet. Ist das Argument z eine reelle oder komplexe
Gleitkommazahl, wird airy_ai numerisch berechnet. Mit der
Optionsvariablen numer
oder der Funktion float
kann die
numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
rationale Zahl ist. Die numerische Berechnung für große Gleitkommazahlen
ist nicht implementiert.
Maxima kennt den speziellen Wert für das Argument 0.
Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
airy_ai auf die Elemente der Liste oder beide Seiten der Gleichung
angewendet. Siehe auch distribute_over.
Die Ableitung diff(airy_ai(z), z) ist als airy_dai(z)
implementiert. Siehe die Funktion airy_dai.
Weiterhin kennt Maxima das Integral der Airy-Funktion airy_ai.
Siehe auch die Funktionen airy_bi
und airy_dbi.
Beispiele:
Numerische Berechnung für Gleitkommazahlen. Für ganze und rationale Zahlen
wird eine Substantivform zurückgegeben. Maxima kennt den speziellen Wert
für das Argument 0.
(%i1) airy_ai([0.5, 1.0+%i]);
(%o1) [.2316936064808335, .06045830837183824
- .1518895658771814 %i]
(%i2) airy_ai([1, 1/2]);
1
(%o2) [airy_ai(1), airy_ai(-)]
2
(%i3) airy_ai(0);
1
(%o3) -------------
2/3 2
3 gamma(-)
3
Ableitungen und Integral der Airy-Funktion airy_ai.
(%i4) diff(airy_ai(z), z);
(%o4) airy_dai(z)
(%i5) diff(airy_ai(z), z, 2);
(%o5) z airy_ai(z)
(%i6) diff(airy_ai(z), z, 3);
(%o6) z airy_dai(z) + airy_ai(z)
(%i7) integrate(airy_ai(z), z);
3
1 2 4 z
hypergeometric([-], [-, -], --) z
3 3 3 9
(%o7) ---------------------------------
2/3 2
3 gamma(-)
3
3
1/6 2 2 4 5 z 2
3 gamma(-) hypergeometric([-], [-, -], --) z
3 3 3 3 9
- ------------------------------------------------
4 %pi
Die Ableitung der Airy-Funktion airy_ai.
Die Ableitung der Airy-Funktion airy_dai ist für das symbolische und
numerische Rechnen geeignet. Ist das Argument z eine reelle oder
komplexe Gleitkommazahl, wird airy_dai numerisch berechnet. Mit der
Optionsvariablen numer
oder der Funktion float
kann die
numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
rationale Zahl ist. Die numerische Berechnung für große Gleitkommazahlen
ist nicht implementiert.
Maxima kennt den speziellen Wert für das Argument 0.
Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
airy_dai auf die Elemente der Liste oder beide Seiten der Gleichung
angewendet. Siehe auch distribute_over.
Maxima kennt die Ableitung und das Integral der Funktion airy_dai.
Siehe auch die Airy-Funktionen airy_bi
und airy_dbi.
Für Beispiele siehe die Funktion airy_ai.
Die Airy-Funktion Bi(z) (A & S 10.4.3).
Die Airy-Funktion airy_bi ist für das symbolische und numerische
Rechnen geeignet. Ist das Argument z eine reelle oder komplexe
Gleitkommazahl, wird airy_bi numerisch berechnet. Mit der
Optionsvariablen numer
oder der Funktion float
kann die
numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
rationale Zahl ist. Die numerische Berechnung für große Gleitkommazahlen
ist nicht implementiert.
Maxima kennt den speziellen Wert für das Argument 0.
Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
airy_bi auf die Elemente der Liste oder beide Seiten der Gleichung
angewendet. Siehe auch distribute_over.
Die Ableitung diff(airy_bi(z), z) ist als airy_dbi(z)
implementiert. Siehe die Funktion airy_dbi.
Weiterhin kennt Maxima das Integral der Airy-Funktion airy_bi.
Siehe auch die Funktionen airy_ai
und airy_dai.
Für Beispiele siehe die Funktion airy_ai.
Die Ableitung der Airy-Funktion airy_bi.
Die Ableitung der Airy-Funktion airy_dbi ist für das symbolische und
numerische Rechnen geeignet. Ist das Argument z eine reelle oder
komplexe Gleitkommazahl, wird airy_dbi numerisch berechnet. Mit der
Optionsvariablen numer
oder der Funktion float
kann die
numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
rationale Zahl ist. Die numerische Berechnung für große Gleitkommazahlen
ist nicht implementiert.
Maxima kennt den speziellen Wert für das Argument 0.
Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
airy_dbi auf die Elemente der Liste oder beide Seiten der Gleichung
angewendet. Siehe auch distribute_over.
Maxima kennt die Ableitung und das Integral der Funktion airy_dbi.
Siehe auch die Airy-Funktionen airy_ai
und airy_dai.
Für Beispiele siehe die Funktion airy_ai.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Struve-Funktion H der Ordnung v mit dem Argument z. Siehe Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 12. Die Definition ist
inf
==== k 2 k
z v + 1 \ (- 1) z
H (z) = (-) > ----------------------------------
v 2 / 2 k 3 3
==== 2 gamma(k + -) gamma(v + k + -)
k = 0 2 2
Die Struve-Funktion struve_h ist für das numerische und symbolische
Rechnen geeignet. Im Unterschied zu den Bessel-Funktionen
ist jedoch
die Implementation der Funktion struve_h weniger vollständig.
Maxima berechnet struve_h numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem
Fall gibt Maxima eine Substantivform zurück.
Hat die Optionsvariable besselexpand
den Wert true, wird die
Struve-Funktion struve_h mit einer halbzahligen Ordnung v als
Sinus- und Kosinusfunktionen entwickelt.
Maxima kennt die Ableitung der Struve-Funktion struve_h nach dem
Argument z.
Siehe auch die Struve-Funktion struve_l.
Beispiele:
(%i1) struve_h(1, 0.5);
(%o1) .05217374424234107
(%i2) struve_h(1, 0.5+%i);
(%o2) 0.233696520211436 %i - .1522134290663428
(%i3) struve_h(3/2,x), besselexpand: true;
2
2 x sin(x) + 2 cos(x) - x - 2
(%o3) - ------------------------------
3/2
sqrt(2) sqrt(%pi) x
(%i4) diff(struve_h(v, x), x);
v
x
(%o4) (------------------------- - struve_h(v + 1, x)
v 3
sqrt(%pi) 2 gamma(v + -)
2
+ struve_h(v - 1, x))/2
Die modifizierte Struve-Funktion L der Ordnung v mit dem Argument z. Siehe Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 12. Die Definition ist
inf
==== 2 k
z v + 1 \ z
L (z) = (-) > ----------------------------------
v 2 / 2 k 3 3
==== 2 gamma(k + -) gamma(v + k + -)
k = 0 2 2
Die Struve-Funktion struve_l ist für das numerische und symbolische
Rechnen geeignet. Im Unterschied zu den Bessel-Funktionen
ist jedoch
die Implementation der Funktion struve_l weniger vollständig.
Maxima berechnet struve_l numerisch für reelle und komplexe
Gleitkommazahlen als Argumente für v und z. Mit der Funktion
float
oder der Optionsvariablen numer
kann die numerische
Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem
Fall gibt Maxima eine Substantivform zurück.
Hat die Optionsvariable besselexpand
den Wert true, wird die
Struve-Funktion struve_l mit einer halbzahligen Ordnung v als
Sinus- und Kosinusfunktionen entwickelt.
Maxima kennt die Ableitung der Struve-Funktion struve_l nach dem
Argument z.
Siehe auch die Struve-Funktion struve_h.
Beispiele:
(%i1) struve_l(1, 0.5);
(%o1) .05394218262352267
(%i2) struve_l(1, 0.5+%i);
(%o2) .1912720461247995 %i - .1646185598117401
(%i3) struve_l(3/2,x), besselexpand: true;
2
2 x sinh(x) - 2 cosh(x) - x + 2
(%o3) --------------------------------
3/2
sqrt(2) sqrt(%pi) x
(%i4) diff(struve_l(v, x), x);
v
x
(%o4) (------------------------- + struve_l(v + 1, x)
v 3
sqrt(%pi) 2 gamma(v + -)
2
+ struve_l(v - 1, x))/2
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Gammafunktion und die verwandten Funktionen wie die Beta-, Psi- und die unvollständige Gammafunktion sind definiert in Abramowitz and Stegun, Handbook of Mathematical Functions, Kapitel 6.
Berechnet die Fakultät für große Gleitkommazahlen. Das Argument x muss eine große Gleitkommazahl sein. Das zweite Argument fpprec ist die Anzahl der Stellen, für die die Fakultät berechnet wird. Das Ergebnis ist eine große Gleitkommazahl.
Für das symbolische Rechnen mit der Fakultät und der Gammafunktion siehe die
entsprechenden Funktionen factorial
und gamma.
Maxima ruft
intern die Funktion bffac auf, um die Fakultät factorial und
die Gammafunktion gamma für eine große Gleitkommazahl numerisch zu
berechnen.
Siehe auch die Funktion cbffac
für die Berechnung der Fakultät für
komplexe große Gleitkommazahlen.
Beispiel:
(%i1) bffac(10.5b0, 25); (%o1) 1.189942308396224845701304b7 (%i2) fpprec:25$ (%i3) 10.5b0!; (%o3) 1.189942308396224845701303b7
bfpsi ist die Polygammafunktion für ein reelles Argument x und
einer ganzzahligen Ordnung n. bfpsi0 ist die Digammafunktion.
bfpsi0(x, fpprec) ist äquivalent zu bfpsi(0, x,
fpprec).
Das Argument x der Funktionen bfpsi und bfpsi0 muss eine
große Gleitkommazahl sein. Das Argument fpprec gibt die Anzahl der
Stellen an, für die die Funktion berechnet wird. Das Ergebnis ist eine
große Gleitkommazahl.
Für das symbolische Rechnen mit der Polygammafunktion siehe die Funktion
psi.
Maxima ruft intern die Funktion bfpsi auf, um die
Polygammafunktion für große Gleitkommazahlen numerisch zu berechnen.
Beispiel:
(%i1) bfpsi(0, 1, 25); (%o1) - 5.772156649015328606065121b-1 (%i2) fpprec:25$ (%i3) psi[0](1.0b0); (%o3) - 5.772156649015328606065121b-1
Berechnet die Fakultät für komplexe große Gleitkommazahlen. Das Argument z ist eine komplexe große Gleitkommazahl. Das zweite Argument fpprec ist die Anzahl der Stellen, für die die Fakultät berechnet wird. Das Ergebnis ist eine komplexe große Gleitkommazahl.
Für das symbolische Rechnen mit der Fakultät und der Gammafunktion siehe die
entsprechenden Funktionen factorial
und gamma.
Maxima ruft
intern die Funktion cbffac auf, um die Fakultät factorial und
die Gammafunktion gamma für eine komplexe große Gleitkommazahl
numerisch zu berechnen.
Siehe auch die Funktion bffac.
Die Definition der Gammafunktion ist (A & S 6.1.1)
inf
/
[ z - 1 - t
gamma(z) = I t %e dt
]
/
0
Die Gammafunktion gamma ist für das numerische und symbolische Rechnen
geeignet. Für positive ganze Zahlen und rationale Zahlen als Argument z
wird die Gammafunktion vereinfacht. Für halbzahlige rationale Zahlen ist das
Ergebnis der Vereinfachung eine rationale Zahl multipliziert mit
sqrt(%pi). Die Vereinfachung für ganze Zahlen wird von der
Optionsvariablen factlim
kontrolliert. Für ganze Zahlen, die
größer als factlim sind, kann es zu einem Überlauf bei der
Berechnung der Gammafunktion kommen. Entsprechend wird die Vereinfachung für
rationale Zahlen von der Optionsvariablen gammalim
kontrolliert.
Für negative ganze Zahlen ist die Gammafunktion gamma nicht definiert.
Maxima berechnet gamma numerisch für reelle und komplexe Argumente
z. Das Ergebnis ist eine reelle oder komplexe Gleitkommazahl.
gamma hat Spiegelsymmetrie.
Hat die Optionsvariable gamma_expand
den Wert true, entwickelt
Maxima die Gammafunktion für Argumente der Form z+n und z-n,
wobei n eine ganze Zahl ist.
Maxima kennt die Ableitung der Gammafunktion gamma.
Siehe auch die Funktion makegamma,
um Fakultäten und
Betafunktionen in einem Ausdruck durch die Gammafunktion zu ersetzen.
Die Euler-Mascheroni-Konstante ist %gamma.
Beispiele:
Vereinfachung für ganze Zahlen und rationale Zahlen.
(%i1) map('gamma,[1,2,3,4,5,6,7,8,9]);
(%o1) [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
(%i2) map('gamma,[1/2,3/2,5/2,7/2]);
sqrt(%pi) 3 sqrt(%pi) 15 sqrt(%pi)
(%o2) [sqrt(%pi), ---------, -----------, ------------]
2 4 8
(%i3) map('gamma,[2/3,5/3,7/3]);
2 1
2 gamma(-) 4 gamma(-)
2 3 3
(%o3) [gamma(-), ----------, ----------]
3 3 9
Numerische Berechnung für reelle und komplexe Argumente.
(%i4) map('gamma,[2.5,2.5b0]);
(%o4) [1.329340388179137, 1.3293403881791370205b0]
(%i5) map('gamma,[1.0+%i,1.0b0+%i]);
(%o5) [0.498015668118356 - .1549498283018107 %i,
4.9801566811835604272b-1 - 1.5494982830181068513b-1 %i]
gamma hat Spiegelsymmetrie.
(%i6) declare(z,complex)$ (%i7) conjugate(gamma(z)); (%o7) gamma(conjugate(z))
Maxima entwickelt gamma(z+n) und gamma(z-n), wenn die
Optionsvariable gamma_expand den Wert true hat.
(%i8) gamma_expand:true$
(%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)];
gamma(z)
(%o9) [z gamma(z), --------, z + 1]
z - 1
Die Ableitung der Gammafunktion gamma.
(%i10) diff(gamma(z),z);
(%o10) psi (z) gamma(z)
0
Standardwert: false
Kontrolliert die Vereinfachung der Gammafunktion gamma
und verwandte
Funktionen wie gamma_incomplete
für den Fall, dass das Argument die
Form z+n oder z-n hat. Dabei ist z ist ein beliebiges
Argument und n ist eine ganze Zahl.
Siehe die Funktion gamma für ein Beispiel.
Der Logarithmus der Gammafunktion.
Die unvollständige Gammafunktion (A & S 6.5.2) die definiert ist als
inf
/
[ a - 1 - t
I t %e dt
]
/
z
Regularisierte unvollständige Gammafunktion (A & S 6.5.1)
gamma_incomplete(a, z)
----------------------
gamma(a)
Verallgemeinerte unvollständige Gammafunktion
z2
/
[ a - 1 - t
I t %e dt
]
/
z1
Standardwert: 1000000
Kontrolliert die Vereinfachung der Gammafunktion für rationale Argumente.
Ist der Betrag des Arguments der Gammafunktion größer als gammalim,
wird die Gammafunktion nicht vereinfacht. Damit wird verhindert, dass
die Berechnung der Gammafunktion zu einem Überlauf führt und mit einem
Fehler abbricht.
Siehe auch die Optionsvariable factlim,
um die Vereinfachung für
ganze Zahlen zu kontrollieren.
Ersetzt Fakultäten sowie Binomial- und Betafunktionen durch die Gammafunktion
gamma
im Ausdruck expr.
Siehe auch die Funktion makefact,
um stattdessen Fakultäten in den
Ausdruck einzusetzen.
Beispiel:
(%i1) expr: binomial(a,b)*gamma(b+1)/gamma(a+1);
binomial(a, b) gamma(b + 1)
(%o1) ---------------------------
gamma(a + 1)
(%i2) makegamma(expr);
1
(%o2) ------------------
gamma(- b + a + 1)
Die Betafunktion ist definiert als gamma(a) gamma(b)/gamma(a+b)
(A & S 6.2.1).
Maxima vereinfacht die Betafunktion für positive ganze Zahlen a und
b sowie rationale Zahlen, deren Summe a + b eine ganze
Zahl ist. Hat die Optionsvariable beta_args_sum_to_integer
den Wert
true, vereinfacht Maxima die Betafunktion für allgemeine Ausdrücke
a und b, deren Summe eine ganze Zahl ist.
Ist eines der Argumente a oder b Null, ist die Betafunktion nicht definiert.
Im allgemeinen ist die Betafunktion nicht definiert für negative ganze Zahlen als Argument. Ausnahme ist der Fall, dass a = -n, wobei n eine positive ganze Zahl und b eine positive ganze Zahl mit b <= b ist. In diesem Fall kann eine analytische Fortsetzung der Betafunktion definiert werden. Maxima gibt für diesen Fall ein Ergebnis zurück.
Hat die Optionsvariable beta_expand den Wert true, werden
Ausdrücke wie beta(a+n, b und beta(a-n, b) oder
beta(a, b+n und beta(a, b-n) entwickelt.
Maxima berechnet die Betafunktion für reelle und komplexe Gleitkommazahlen
numerisch. Für die numerische Berechnung nutzt Maxima die Funktion
log_gamma
:
- log_gamma(b + a) + log_gamma(b) + log_gamma(a)
%e
Maxima kennt Symmetrieeigenschaften der Betafunktion. Die Betafunktion ist symmetrisch und hat Spiegelsymmetrie.
Maxima kennt die Ableitung der Betafunktion nach den Argumenten a und b.
Mit der Funktion makegamma
kann die Betafunktion durch Gammafunktionen
ersetzt werden. Entsprechend ersetzt die Funktion makefact
Betafunktionen in einem Ausdruck durch Fakultäten.
Beispiele:
Vereinfachung der Betafunktion, wenn eines der Argumente eine ganze Zahl ist.
(%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
1 9 1
(%o1) [--, -, ---------]
12 4 a (a + 1)
Vereinfachung der Betafunktion für zwei rationale Argumente, die sich zu einer ganzen Zahl summieren.
(%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)];
3 %pi 2 %pi
(%o2) [-----, -------, sqrt(2) %pi]
8 sqrt(3)
Hat die Optionsvariable beta_args_sum_to_integer den Wert true,
vereinfacht die Betafunktion für allgemeine Ausdrücke, die sich zu einer
ganzen Zahl summieren.
(%i3) beta_args_sum_to_integer:true$
(%i4) beta(a+1,-a+2);
%pi (a - 1) a
(%o4) ------------------
2 sin(%pi (2 - a))
Die möglichen Ergebnisse, wenn eines der Argumente eine negative ganze Zahl ist.
(%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
1 1 1
(%o5) [- -, -, - -]
3 6 3
Vereinfachungen, wenn die Optionsvariable beta_expand den Wert
true hat.
(%i6) beta_expand:true$
(%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)];
a beta(a, b) beta(a, b) (b + a - 1) a
(%o7) [------------, ----------------------, -]
b + a a - 1 b
Die Betafunktion ist nicht definiert, wenn eines der Argumente Null ist.
(%i7) beta(0,b); beta: expected nonzero arguments; found 0, b -- an error. To debug this try debugmode(true);
Numerische Berechnung der Betafunktion für reelle und komplexe Argumente.
(%i8) beta(2.5,2.3); (%o8) .08694748611299981 (%i9) beta(2.5,1.4+%i); (%o9) 0.0640144950796695 - .1502078053286415 %i (%i10) beta(2.5b0,2.3b0); (%o10) 8.694748611299969b-2 (%i11) beta(2.5b0,1.4b0+%i); (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i
Die Betafunktion ist symmetrisch und hat Spiegelsymmetrie.
(%i14) beta(a,b)-beta(b,a); (%o14) 0 (%i15) declare(a,complex,b,complex)$ (%i16) conjugate(beta(a,b)); (%o16) beta(conjugate(a), conjugate(b))
Ableitung der Betafunktion.
(%i17) diff(beta(a,b),a);
(%o17) - beta(a, b) (psi (b + a) - psi (a))
0 0
Die Definition der unvollständigen Betafunktion ist (A & S 6.6.1)
z
/
[ b - 1 a - 1
I (1 - t) t dt
]
/
0
Diese Definition ist möglich für realpart(a)>0 und realpart(b)>0 sowie abs(z)<1. Für andere Werte kann die unvollständige Betafunktion als eine verallgemeinerte Hypergeometrische Funktion definiert werden:
gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z
(Siehe http://functions.wolfram.com für eine Definition der unvollständigen Betafunktion.)
Für negative ganze Zahlen a = -n und positive ganze Zahlen b = m mit m <= n kann die unvollständige Betafunktion definiert werden als
m - 1 k
==== (1 - m) z
n - 1 \ k
z > -----------
/ k! (n - k)
====
k = 0
Maxima nutzt diese Definition, um die Funktion beta_incomplete für
negative ganzzahlige Argumente a zu vereinfachen.
Für positive ganzzahlige Argumente a vereinfacht beta_incomplete
für jedes Argument b und z. Entsprechend vereinfacht
beta_incomplete für ein positives ganzzahliges Argument b mit
der Ausnahme, dass a eine negative ganze Zahl ist.
Für z=0 und realpart(a) > 0 hat beta_incomplete den
speziellen Wert Null. Für z=1 und realpart(b) > 0 vereinfacht
beta_incomplete zu einem Ausdruck mit der Betafunktion beta(a, b).
Maxima berechnet beta_incomplete numerisch für reelle und komplexe
Gleitkommazahlen als Argumente. Für die numerische Berechnung nutzt Maxima
eine Entwicklung der unvollständigen Betafunktion als Kettenbruch.
Hat die Optionsvariable beta_expand
den Wert true, entwickelt
Maxima Ausdrücke der Form beta_incomplete(a+n, b, z) und
beta_incomplete(a-n, b, z), wobei n eine ganze Zahl ist.
Maxima kennt die Ableitungen der unvollständigen Betafunktion nach den Variablen a, b und z und das Integral für die Integrationsvariable z.
Beispiele:
Vereinfachung für eine positive ganze Zahl als Argument a.
(%i1) beta_incomplete(2,b,z);
b
1 - (1 - z) (b z + 1)
(%o1) ----------------------
b (b + 1)
Vereinfachung für eine positive ganze Zahl als Argument b.
(%i2) beta_incomplete(a,2,z);
a
(a (1 - z) + 1) z
(%o2) ------------------
a (a + 1)
Vereinfachung für positive ganzzahlige Argumente a und b.
(%i3) beta_incomplete(3,2,z);
3
(3 (1 - z) + 1) z
(%o3) ------------------
12
a ist eine negative ganze Zahl mit b <= (-a). Maxima vereinfacht für diesem Fall.
(%i4) beta_incomplete(-3,1,z);
1
(%o4) - ----
3
3 z
Für die speziellen Werte z=0 und z=1 vereinfacht Maxima.
(%i5) assume(a>0,b>0)$ (%i6) beta_incomplete(a,b,0); (%o6) 0 (%i7) beta_incomplete(a,b,1); (%o7) beta(a, b)
Numerische Berechnung für reelle Argumente.
(%i8) beta_incomplete(0.25,0.50,0.9); (%o8) 4.594959440269333 (%i9) fpprec:25$ (%i10) beta_incomplete(0.25,0.50,0.9b0); (%o10) 4.594959440269324086971203b0
Für abs(z) > 1 ist das Ergebnis komplex.
(%i11) beta_incomplete(0.25,0.50,1.7); (%o11) 5.244115108584249 - 1.45518047787844 %i
Numerische Ergebnisse für komplexe Argumente.
(%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i); (%o14) 2.726960675662536 - .3831175704269199 %i (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i); (%o15) 13.04649635168716 %i - 5.802067956270001 (%i16)
Entwicklung, wenn beta_expand den Wert true hat.
(%i23) beta_incomplete(a+1,b,z),beta_expand:true;
b a
a beta_incomplete(a, b, z) (1 - z) z
(%o23) -------------------------- - -----------
b + a b + a
(%i24) beta_incomplete(a-1,b,z),beta_expand:true;
b a - 1
beta_incomplete(a, b, z) (- b - a + 1) (1 - z) z
(%o24) -------------------------------------- - ---------------
1 - a 1 - a
Ableitung und Integral der unvollständigen Betafunktion.
(%i34) diff(beta_incomplete(a, b, z), z);
b - 1 a - 1
(%o34) (1 - z) z
(%i35) integrate(beta_incomplete(a, b, z), z);
b a
(1 - z) z
(%o35) ----------- + beta_incomplete(a, b, z) z
b + a
a beta_incomplete(a, b, z)
- --------------------------
b + a
(%i36) factor(diff(%, z));
(%o36) beta_incomplete(a, b, z)
Die regularisierte unvollständige Beta Funktion (A & S 6.6.2), die definiert ist als
beta_incomplete(a, b, z)
------------------------
beta(a, b)
Wie bei der Funktion beta_incomplete
ist diese Definition nicht
vollständig. Siehe http://functions.wolfram.com für eine
vollständige Definition der Funktion.
beta_incomplete_regularized vereinfacht, wenn das Argument a oder
b eine positive ganze Zahl ist. Für Argumente z = 0 und
realpart(a) > 0 vereinfacht die Funktion
beta_incomplete_regularized zu 0. Für z = 1 und
realpart(b) > 0 vereinfacht die Funktion
beta_incomplete_regularized zu 1.
Maxima berechnet beta_incomplete_regularized für reelle und komplexe
Gleitkommazahlen als Argumente numerisch.
When beta_expand is true, Maxima expands
beta_incomplete_regularized for arguments a+n or a-n,
where n is an integer.
Hat die Optionsvariable beta_expand
den Wert true, expandiert
Maxima beta_incomplete_regularized für Argumente a+n oder
a-n, wobei n eine ganze Zahl ist.
Maxima kennt die Ableitung der Funktion beta_incomplete_regularized
nach den Argumenten a, b und z sowie das Integral für das
Argument z.
Beispiele:
Vereinfachung, wenn die Argumente a oder b ganze Zahlen sind.
(%i1) beta_incomplete_regularized(2,b,z);
b
(%o1) 1 - (1 - z) (b z + 1)
(%i2) beta_incomplete_regularized(a,2,z);
a
(%o2) (a (1 - z) + 1) z
(%i3) beta_incomplete_regularized(3,2,z);
3
(%o3) (3 (1 - z) + 1) z
Für die speziellen Werte z=0 und z=1 vereinfacht Maxima.
(%i4) assume(a>0,b>0)$ (%i5) beta_incomplete_regularized(a,b,0); (%o5) 0 (%i6) beta_incomplete_regularized(a,b,1); (%o6) 1
Numerische Berechnung für reelle und komplexe Argumente.
(%i7) beta_incomplete_regularized(0.12,0.43,0.9); (%o7) .9114011367359802 (%i8) fpprec:32$ (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0); (%o9) 9.1140113673598075519946998779975b-1 (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i); (%o10) .2865367499935405 %i - .1229959633346841 (%i11) fpprec:20$ (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i); (%o12) 2.8653674999354036142b-1 %i - 1.2299596333468400163b-1
Expansion, wenn beta_expand den Wert true hat.
(%i13) beta_incomplete_regularized(a+1,b,z);
b a
(1 - z) z
(%o13) beta_incomplete_regularized(a, b, z) - ------------
a beta(a, b)
(%i14) beta_incomplete_regularized(a-1,b,z);
(%o14) beta_incomplete_regularized(a, b, z)
b a - 1
(1 - z) z
- ----------------------
beta(a, b) (b + a - 1)
Die Ableitung und das Integral der Funktion.
(%i15) diff(beta_incomplete_regularized(a,b,z),z);
b - 1 a - 1
(1 - z) z
(%o15) -------------------
beta(a, b)
(%i16) integrate(beta_incomplete_regularized(a,b,z),z);
(%o16) beta_incomplete_regularized(a, b, z) z
b a
(1 - z) z
a (beta_incomplete_regularized(a, b, z) - ------------)
a beta(a, b)
- -------------------------------------------------------
b + a
Die Definition der verallgemeinerten unvollständigen Betafunktion ist
z2
/
[ b - 1 a - 1
I (1 - t) t dt
]
/
z1
Maxima vereinfacht beta_incomplete_refularized für positive ganzzahlige
Argumente a und b.
Ist realpart(a)>0 und z1=0 oder z2=0, vereinfacht Maxima
beta_incomplete_generalized zu der Funktion
beta_incomplete.
Ist realpart(b)>0 und z1=1 oder
z2=1, vereinfacht Maxima zu einem Ausdruck mit der Funktion
beta
und beta_incomplete.
Maxima berechnet beta_incomplete_regularized numerisch für reelle und
komplexe Gleitkommazahlen in doppelter und beliebiger Genauigkeit.
Hat die Optionsvariable beta_expand
den Wert true, dann expandiert
Maxima beta_incomplete_generalized für Argumente a+n und
a-n, wobei n eine positive ganze Zahl ist.
Maxima kennt die Ableitung der Funktion beta_incomplete_generalized nach
den Variablen a, b, z1 und z2 sowie die Integrale
für die Integrationsvariablen z1 und z2.
Beispiele:
Maxima vereinfacht beta_incomplete_generalized, wenn a und b
positive ganze Zahlen sind.
(%i1) beta_incomplete_generalized(2,b,z1,z2);
b b
(1 - z1) (b z1 + 1) - (1 - z2) (b z2 + 1)
(%o1) -------------------------------------------
b (b + 1)
(%i2) beta_incomplete_generalized(a,2,z1,z2);
a a
(a (1 - z2) + 1) z2 - (a (1 - z1) + 1) z1
(%o2) -------------------------------------------
a (a + 1)
(%i3) beta_incomplete_generalized(3,2,z1,z2);
2 2 2 2
(1 - z1) (3 z1 + 2 z1 + 1) - (1 - z2) (3 z2 + 2 z2 + 1)
(%o3) -----------------------------------------------------------
12
Vereinfachung für die speziellen Werte z1=0, z2=0, z1=1 und z2=1.
(%i4) assume(a > 0, b > 0)$ (%i5) beta_incomplete_generalized(a,b,z1,0); (%o5) - beta_incomplete(a, b, z1) (%i6) beta_incomplete_generalized(a,b,0,z2); (%o6) - beta_incomplete(a, b, z2) (%i7) beta_incomplete_generalized(a,b,z1,1); (%o7) beta(a, b) - beta_incomplete(a, b, z1) (%i8) beta_incomplete_generalized(a,b,1,z2); (%o8) beta_incomplete(a, b, z2) - beta(a, b)
Numerische Berechnung für reelle Argumente in doppelter und beliebiger Gleitkommagenauigkeit.
(%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31); (%o9) .09638178086368676 (%i10) fpprec:32$ (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0); (%o10) 9.6381780863686935309170054689964b-2
Numerische Berechnung für komplexe Argumente in doppelter und beliebiger Gleitkommagenauigkeit.
(%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31); (%o11) - .09625463003205376 %i - .003323847735353769 (%i12) fpprec:20$ (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0); (%o13) - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3
Expansion für a+n oder a-n und n eine positive ganze Zahl,
wenn beta_expand den Wert true hat.
(%i14) beta_expand:true$
(%i15) beta_incomplete_generalized(a+1,b,z1,z2);
b a b a
(1 - z1) z1 - (1 - z2) z2
(%o15) -----------------------------
b + a
a beta_incomplete_generalized(a, b, z1, z2)
+ -------------------------------------------
b + a
(%i16) beta_incomplete_generalized(a-1,b,z1,z2);
beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1)
(%o16) -------------------------------------------------------
1 - a
b a - 1 b a - 1
(1 - z2) z2 - (1 - z1) z1
- -------------------------------------
1 - a
Ableitung nach der Variablen z1 und die Integrale für die Integrationsvariablen z1 und z2.
(%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1);
b - 1 a - 1
(%o17) - (1 - z1) z1
(%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1);
(%o18) beta_incomplete_generalized(a, b, z1, z2) z1
+ beta_incomplete(a + 1, b, z1)
(%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2);
(%o19) beta_incomplete_generalized(a, b, z1, z2) z2
- beta_incomplete(a + 1, b, z2)
Standardwert: false
Hat die Optionsvariable beta_expand den Wert true, werden
beta(a,b) und verwandte Funktionen für Argumente a+n oder
a-n entwickelt, wobei n eine positive ganze Zahl ist.
Standardwert: false
Hat die Optionsvariable beta_args_sum_to_integer den Wert true,
vereinfacht Maxima die Funktion beta(a,b), wenn sich die Argumente
a und b zu einer ganzen Zahlen summieren. Siehe auch beta.
Ist definiert als die Ableitung der Funktion log(gamma(x)) der
Ordnung n+1. psi[0](x) ist die erste Ableitung,
psi[1](x) ist die zweite Ableitung, usw.
Maxima kann numerische Werte für reelle Gleitkommazahlen berechnen. Weiterhin
kann Maxima die Funktion psi für rationale Argumente zu exakten Werten
vereinfachen. Die Optionsvariablen maxpsiposint,
maxpsinegint,
maxpsifracnum
und maxpsifracdenom
kontrollieren, den Wertebereich der Argumente für den die Funktion psi
vereinfacht.
Die Funktion bfpsi
des bffac-Package kann numerische Werte der
Funktion psi berechnen.
Standardwert: 20
Die Optionsvariable maxpsiposint kontrolliert die Vereinfachung der
Funktion psi
und enthält eine obere positive Schranke. Ist das
Argument x der Funktion psi größer als maxpsiposint,
dann versucht Maxima nicht psi[n](x) zu vereinfachen.
Siehe auch maxpsifracdenom,
maxpsifracnum
und
maxpsinegint.
Beispiele:
(%o1) 20
(%i2) psi[0](20);
275295799
(%o2) --------- - %gamma
77597520
(%i3) maxpsiposint:10;
(%o3) 10
(%i4) psi[0](20);
(%o4) psi (20)
0
(%i5) psi[0](10);
7129
(%o5) ---- - %gamma
2520
Standardwert: -10
Die Optionsvariable maxpsinegint kontrolliert die Vereinfachung der
Funktion psi
und enthält eine untere negative Schranke. Ist das
Argument x der Funktion psi kleiner als maxpsinegint,
dann versucht Maxima nicht psi[n](x) zu vereinfachen.
Siehe auch maxpsifracdenom,
maxpsifracnum
und
maxpsiposint.
Beispiele:
(%i1) maxpsinegint:-10;
(%o1) - 10
(%i2) psi[0](-3/2);
8
(%o2) - 2 log(2) - %gamma + -
3
(%i3) maxpsinegint:-1;
(%o3) - 1
(%i4) psi[0](-3/2);
3
(%o4) psi (- -)
0 2
(%i5) psi[0](-1/2);
(%o5) - 2 log(2) - %gamma + 2
Standardwert: 6
Die Optionsvariable maxpsifracnum kontrolliert die Vereinfachung der
Funktion psi.
Ist das Argument x der Funktion psi eine
rationale Zahl kleiner als eins mit p/q und ist der Zähler p
größer als maxpsifracnum, dann versucht Maxima nicht
psi[n](x) zu vereinfachen.
Siehe auch maxpsifracdenom,
maxpsiposint
und
maxpsinegint.
Beispiele:
(%i1) maxpsifracnum: 6;
(%o1) 6
(%i2) psi[0](5/6);
3 log(3) sqrt(3) %pi
(%o2) - -------- - 2 log(2) + ----------- - %gamma
2 2
(%i3) maxpsifracnum: 3;
(%o3) 3
(%i4) psi[0](5/6);
5
(%o4) psi (-)
0 6
Standardwert: 6
Die Optionsvariable maxpsifracdenom kontrolliert die Vereinfachung der
Funktion psi.
Ist das Argument x der Funktion psi eine
rationale Zahl kleiner als eins mit p/q und ist der Nenner q
größer als maxpsifracdenom, dann versucht Maxima nicht
psi[n](x) zu vereinfachen.
Siehe auch maxpsifracnum,
maxpsiposint
und
maxpsinegint.
Beispiele:
(%i1) maxpsifracdenom: 6;
(%o1) 6
(%i2) psi[0](1/6);
3 log(3) sqrt(3) %pi
(%o2) - -------- - 2 log(2) - ----------- - %gamma
2 2
(%i3) maxpsifracdenom: 4;
(%o3) 4
(%i4) psi[0](1/6);
1
(%o4) psi (-)
0 6
(%i5) psi[0](1/5);
1
(%o5) psi (-)
0 5
(%i6) psi[0](1/4);
%pi
(%o6) - 3 log(2) - --- - %gamma
2
Ersetzt Binomial-, Gamma- und Beta-Funktionen, die im Ausdruck expr auftreten, durch Fakultäten.
Siehe auch die Funktion makegamma.
Gibt einen numerischen Faktor des Produktes expr zurück. Ist expr
kein Produkt oder enthält das Produkt keinen numerischen Faktor ist die
Rückgabe 1.
Beispiel:
(%i1) gamma (7/2);
15 sqrt(%pi)
(%o1) ------------
8
(%i2) numfactor (%);
15
(%o2) --
8
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Exponentiellen Integrale und verwandte Funktionen sind definiert in Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 5.
Das Exponentielle Integral E1(z) (A&S 5.1.1).
Das Exponentielle Integral Ei(z) (A&S 5.1.2).
Das Exponentielle Integral Li(z) (A&S 5.1.3).
Das Exponentielle Integral E[n](z) (A&S 5.1.4).
Das Exponentielle Integral Si(z) (A&S 5.2.1).
Das Exponentielle Integral Ci(z) (A&S 5.2.2).
Das Exponentielle Integral Shi(z) (A&S 5.2.3).
Das Exponentielle Integral Chi(z) (A&S 5.2.4).
Standardwert: false
Wechselt die Darstellung eines Exponentiellen Integrals in eine der anderen
Funktionen gamma_incomplete,
expintegral_e1,
expintegral_ei,
expintegral_li,
expintegral_si,
expintegral_ci,
expintegral_shi,
oder expintegral_chi.
Standardwert: false
Expandiert das Exponentielle Integral E[n](z) für halbzahlige, gerade
Ordnung n nach den Funktionen erfc
und erf.
sowie für
positive ganze Zahlen nach der Funktion expintegral_ei.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Fehlerfunktion und verwandte Funktionen sind definiert in Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 7.
Die Fehlerfunktion erf(z) (A&S 7.1.1).
Siehe auch die Optionsvariable erfflag.
Die komplementäre Fehlerfunktion erfc(z) = 1 - erf(z) (A & S 7.1.2).
Die imaginäre Fehlerfunktion erfi(z) = -%i*erf(%i*z).
Die verallgemeinerte Fehlerfunktion Erf(z1, z2).
Das Fresnel-Integral, das definiert ist als (A & S 7.3.1):
z
/ 2
[ %pi t
C(z) = I cos(------) dt
] 2
/
0
Hat die Optionsvariable trigsign
den Wert true, vereinfacht
Maxima fresnel_c(-x) zu -fresnel_c(x).
Hat die Optionsvariable %iargs
den Wert true, vereinfacht
Maxima fresnel_c(%i*x) zu %i*fresnel_c(x).
Siehe auch die Optionsvariable hypergeometric_representation,
um
die Fresnelfunktion in eine hypergeometrische Darstellung zu transformieren,
und die Optionsvariable erf_representation
für eine Darstellung als
Fehlerfunktion.
Das Fresnel-Integral, das definiert ist als (A & S 7.3.2):
z
/ 2
[ %pi t
S(z) = I sin(------) dt
] 2
/
0
Hat die Optionsvariable trigsign
den Wert true, vereinfacht
Maxima fresnel_s(-x) zu -fresnel_s(x).
Hat die Optionsvariable %iargs
den Wert true, vereinfacht
Maxima fresnel_s(%i*x) zu %i*fresnel_s(x).
Siehe auch die Optionsvariable hypergeometric_representation,
um
die Fresnelfunktion in eine hypergeometrische Darstellung zu transformieren,
und die Optionsvariable erf_representation
für eine Darstellung als
Fehlerfunktion.
Standarwert: false
Hat die Optionsvariable erf_representation den Wert true, werden
die Funktionen erfc,
erfi,
erf_generalized,
fresnel_s
und fresnel_c
in eine
Darstellung mit der Funktion erf
transformiert.
Standardwert: false
Hat die Optionsvariable hypergeometric_representation den Wert
true, werden die Funktionen fresnel_s
und fresnel_c
in
eine hypergeometrische Funktion transformiert.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 22.6.1 Einführung in Elliptische Funktionen und Integrale | ||
| 22.6.2 Funktionen und Variablen für Elliptische Funktionen | ||
| 22.6.3 Funktionen und Variablen für Elliptische Integrale |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Maxima unterstützt die Jacobischen elliptische Funktionen sowie die vollständigen und unvollständigen elliptischen Integrale. Die Funktionen sind für das symbolische und numerische Rechnen geeignet. Die Definition der Funktionen und viele ihrer Eigenschaften sind in Abramowitz and Stegun, Kapitel 16 und 17 enthalten. Die dort beschriebenen Definitionen und Beziehungen werden so weit als möglich verwendet.
Im besonderen nutzen alle elliptischen Funktionen und Integrale den Parameter m anstatt den Modulus k oder den modularen Winkel \alpha. Dies ist ein Unterschied zu der Definition von Abramowitz und Stegun. Es gelten die folgenden Beziehungen:
Die elliptischen Funktionen und Integrale sind zuallererst für das symbolische Rechnen gedacht. Daher sind die Ableitungen und Integrale der Funktionen im wesentlichen in Maxima bekannt. Maxima unterstützt jedoch auch die numerische Berechnung, wenn die Argumente Gleitkommazahlen sind.
Viele bekannte Eigenschaften der Elliptischen Funktionen und Integrale sind noch nicht in Maxima implementiert.
Einige Beispiele für elliptische Funktionen.
(%i1) jacobi_sn (u, m);
(%o1) jacobi_sn(u, m)
(%i2) jacobi_sn (u, 1);
(%o2) tanh(u)
(%i3) jacobi_sn (u, 0);
(%o3) sin(u)
(%i4) diff (jacobi_sn (u, m), u);
(%o4) jacobi_cn(u, m) jacobi_dn(u, m)
(%i5) diff (jacobi_sn (u, m), m);
(%o5) jacobi_cn(u, m) jacobi_dn(u, m)
elliptic_e(asin(jacobi_sn(u, m)), m)
(u - ------------------------------------)/(2 m)
1 - m
2
jacobi_cn (u, m) jacobi_sn(u, m)
+ --------------------------------
2 (1 - m)
Einige Beispiele für elliptische Integrale.
(%i1) elliptic_f (phi, m);
(%o1) elliptic_f(phi, m)
(%i2) elliptic_f (phi, 0);
(%o2) phi
(%i3) elliptic_f (phi, 1);
phi %pi
(%o3) log(tan(--- + ---))
2 4
(%i4) elliptic_e (phi, 1);
(%o4) sin(phi)
(%i5) elliptic_e (phi, 0);
(%o5) phi
(%i6) elliptic_kc (1/2);
1
(%o6) elliptic_kc(-)
2
(%i7) makegamma (%);
2 1
gamma (-)
4
(%o7) -----------
4 sqrt(%pi)
(%i8) diff (elliptic_f (phi, m), phi);
1
(%o8) ---------------------
2
sqrt(1 - m sin (phi))
(%i9) diff (elliptic_f (phi, m), m);
elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m)
(%o9) (-----------------------------------------------
m
cos(phi) sin(phi)
- ---------------------)/(2 (1 - m))
2
sqrt(1 - m sin (phi))
Die Implementierung der elliptischen Funktionen und Integrale wurde von Raymond Toy geschrieben. Der Code steht wie Maxima unter der General Public License (GPL).
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Jacobische elliptische Funktion sn(u,m).
Die Jacobische elliptische Funktion cn(u,m).
Die Jacobische elliptische Funktion dn(u,m).
Die Jacobische elliptische Funktion ns(u,m) = 1/sn(u,m).
Die Jacobische elliptische Funktion sc(u,m) = sn(u,m)/cn(u,m).
Die Jacobische elliptische Funktion sd(u,m) = sn(u,m)/dn(u,m).
Die Jacobische elliptische Funktion nc(u,m) = 1/cn(u,m).
Die Jacobische elliptische Funktion cs(u,m) = cn(u,m)/sn(u,m).
Die Jacobische elliptische Funktion cd(u,m) = cn(u,m)/dn(u,m).
Die Jacobische elliptische Funktion nc(u,m) = 1/cn(u,m).
Die Jacobische elliptische Funktion ds(u,m) = dn(u,m)/sn(u,m).
Die Jacobische elliptische Funktion dc(u,m) = dn(u,m)/cn(u,m).
Die inverse Jacobische elliptische Funktion sn(u,m).
Die inverse Jacobische elliptische Funktion cn(u,m).
Die inverse Jacobische elliptische Funktion dn(u,m).
Die inverse Jacobische elliptische Funktion ns(u,m).
Die inverse Jacobische elliptische Funktion sc(u,m).
Die inverse Jacobische elliptische Funktion sd(u,m).
Die inverse Jacobische elliptische Funktion nc(u,m).
Die inverse Jacobische elliptische Funktion cs(u,m).
Die inverse Jacobische elliptische Funktion cd(u,m).
Die inverse Jacobische elliptische Funktion nc(u,m).
Die inverse Jacobische elliptische Funktion ds(u,m).
Die inverse Jacobische elliptische Funktion dc(u,m).
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Das unvollständige elliptische Integral der ersten Art, das definiert ist als
integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)
Siehe auch elliptic_e
und elliptic_kc.
Das unvollständige elliptische Integral der zweiten Art, das definiert ist als
elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi)
Siehe auch elliptic_e
und elliptic_ec.
Das unvollständige elliptische Integral der zweiten Art, das definiert ist als
integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t, 0, tau)
mit tau = sn(u,m).
Dieses Integral steht in Beziehung zum elliptischen Integral elliptiec_e
elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m)
Siehe auch elliptic_e.
Das unvollständige elliptische Integral der dritten Art, das definiert ist als
integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)
Maxima kennt nur die Ableitung nach der Variablen phi.
Das vollständige elliptische Integral der ersten Art, das definiert ist als
integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)
Für einige spezielle Argumente m kennt Maxima Werte mit der
Gammafunktion gamma.
Die Werte können mit der Funktion
makegamma
berechnet werden.
Das vollständige elliptische Integral der zweiten Art, das definiert ist als
integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)
Für einige spezielle Argumente m kennt Maxima Werte mit der
Gammafunktion gamma.
Die Werte können mit der Funktion
makegamma
berechnet werden.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Ist die Whittaker M Funktion
M[k,u](z) = exp(-z/2) * z^(1/2+u) * M(1/2+u-k, 1+2*u, z).
Siehe A & S 13.1.32 für die Definition.
Ist die Whittaker W Funktion. Siehe A & S 13.1.33 für die Definition.
Ist die hypergeometrische Funktion
F[p,q](a_1, ..., a_p; b_1,..., b_q; z). Das Argument a ist eine
Liste mit den p-Elementen a_i und das Argument b die Liste
mit den q-Elementen b_i.
Ist die hypergeometrische Funktion. Im Unterschied zu den Funktionen
%f
und hgfred,
ist die Funktion hypergeometric eine
vereinfachende Funktion. hypergeometric unterstützt die Berechnung
von numerischen Werten für reelle und komplexe Gleitkommazahlen in doppelter
und mit beliebiger Genauigkeit. Für die Gaußsche hypergeometrische
Funktion ist p = 2 und q = 1. In diesem Fall wird auch die
numerische Berechnung außerhalb des Einheitskreises unterstützt.
Hat die Optionsvariable expand_hypergeometric den Wert true, das
ist der Standardwert, und eines der Argumente a_1, …, a_p
ist eine negative ganze Zahl, gibt hypergeometric ein Polynom zurück.
Beispiel:
(%i1) hypergeometric([],[],x); (%o1) %e^x
Expansion in ein Polynom für eine negative ganze Zahl, wenn die
Optionsvariable expand_hypergeometric den Wert true hat.
(%i2) hypergeometric([-3],[7],x); (%o2) hypergeometric([-3],[7],x) (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true; (%o3) -x^3/504+3*x^2/56-3*x/7+1
Numerische Berechnung in doppelter und beliebiger Gleitkommagenauigkeit.
(%i4) hypergeometric([5.1],[7.1 + %i],0.42);
(%o4) 1.346250786375334 - 0.0559061414208204 %i
(%i5) hypergeometric([5,6],[8], 5.7 - %i);
(%o5) .007375824009774946 - .001049813688578674 %i
(%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30;
(%o6) 7.37582400977494674506442010824b-3
- 1.04981368857867315858055393376b-3 %i
Die parabolische Zylinderfunktion parabolic_cylinder_d(v,z).
Die parabolischen Zylinderfunktionen sind in Abramowitz and Stegun, Handbook of Mathematical Functions, Kapitel 19 definiert.
Die parabolischen Zylinderfunktionen können als Ergebnis der Funktion
hgfred
auftreten. Maxima kennt keine weiteren Eigenschaften.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Ist der Polylogarithmus der Ordnung s mit dem Argument z. Der Polylogarithmus wird durch die folgende Reihe definiert werden:
inf
==== k
\ z
Li (z) = > --
s / s
==== k
k = 1
Für s=1 geht der Polylogarithmus in die gewöhnliche
Logarithmusfunktion über und man erhält -log(1-z). Für s=2
oder s=3 spricht man vom Dilogarithmus oder Trilogarithmus.
Maxima vereinfacht für s=1 sofort zum gewöhnlichen Logarithmus. Für negative ganze Zahlen s einschließlich der Null vereinfacht Maxima den Polylogarithmus zu einer rationalen Funktion.
Ist s=2 oder s=3 und das Argument z eine Gleitkommazahl, vereinfacht Maxima den Di- oder Trilogarithmus zu einer Gleitkommazahl.
Beispiele:
(%i1) assume (x > 0);
(%o1) [x > 0]
(%i2) integrate ((log (1 - t)) / t, t, 0, x);
(%o2) - li (x)
2
(%i3) li [2] (7);
(%o3) li (7)
2
(%i4) li [2] (7), numer;
(%o4) 1.24827317833392 - 6.113257021832577 %i
(%i5) li [3] (7);
(%o5) li (7)
3
(%i6) li [2] (7), numer;
(%o6) 1.24827317833392 - 6.113257021832577 %i
(%i7) L : makelist (i / 4.0, i, 0, 8);
(%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
(%i8) map (lambda ([x], li [2] (x)), L);
(%o8) [0, .2676526384986274, .5822405249432515,
.9784693966661848, 1.64493407, 2.190177004178597
- .7010261407036192 %i, 2.374395264042415
- 1.273806203464065 %i, 2.448686757245154
- 1.758084846201883 %i, 2.467401098097648
- 2.177586087815347 %i]
(%i9) map (lambda ([x], li [3] (x)), L);
(%o9) [0, .2584613953442624, 0.537213192678042,
.8444258046482203, 1.2020569, 1.642866878950322
- .07821473130035025 %i, 2.060877505514697
- .2582419849982037 %i, 2.433418896388322
- .4919260182322965 %i, 2.762071904015935
- .7546938285978846 %i]
Berechnet die Laplace-Transformation des Ausdrucks expr für die Integrationsvariable t. s ist der Parameter der Laplace-Transformation. Der Integrand expr kann spezielle Funktionen der Mathematik enthalten.
Die folgenden speziellen Funktionen können als Integrand auftreten: die
unvollständige Gammafunkion gamma_incomplete,
die
Fehlerfunktionen erf
und erfc,
nicht jedoch die Funktion
erfi,
die jedoch in eine andere Fehlerfunktion transformiert werden
kann, die Exponentiellen Integrale wie zum Beispiel expintegral_e1,
die Bessel-Funktionen wie zum Beispiel bessel_j,
einschließlich
der Produkte von Bessel-Funktionen, Hankel-Funktionen wie zum Beispiel
hankel_1,
Hermite hermite
und Laguerre Polynome
laguerre.
Weiterhin kann specint Integranden mit der
Hypergeometrische Funktion %f[p,q]([],[],z), die Whittaker Funktion der
ersten Art %m[u,k](z) und die der zweiten Art %w[u,k](z)
integrieren.
Das Ergebnis kann spezielle Funktionen und die Hypergeometrische Funktion enthalten.
Kann die Funktion laplace
keine Laplace-Transformation finden, wird
specint aufgerufen. Da die Funktion laplace einige allgemeine
Regeln kennt, um die Laplace-Transformation zu finden, ist es von Vorteil
die Laplace-Transformation mit der Funktion laplace zu berechnen.
demo(hypgeo) zeigt einige Beispiele für Laplace-Transformationen mit
der Funktion specint.
Beispiele:
(%i1) assume (p > 0, a > 0)$
(%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
sqrt(%pi)
(%o2) ------------
a 3/2
2 (p + -)
4
(%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
* exp(-p*t), t);
- a/p
sqrt(a) %e
(%o3) ---------------
2
p
Beispiel mit Exponentiellen Integralen.
(%i4) assume(s>0,a>0,s-a>0)$
(%i5) ratsimp(specint(%e^(a*t)
*(log(a)+expintegral_e1(a*t))*%e^(-s*t),t));
log(s)
(%o5) ------
s - a
(%i6) logarc:true$
(%i7) gamma_expand:true$
radcan(specint((cos(t)*expintegral_si(t)
-sin(t)*expintegral_ci(t))*%e^(-s*t),t));
log(s)
(%o8) ------
2
s + 1
ratsimp(specint((2*t*log(a)+2/a*sin(a*t)
-2*t*expintegral_ci(a*t))*%e^(-s*t),t));
2 2
log(s + a )
(%o9) ------------
2
s
Entwicklung der unvollständigen Gammafunktion und Wechsel in eine Darstellung
mit dem Exponentiellen Integral expintegral_e1.
(%i10) assume(s>0)$
(%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
1
gamma_incomplete(-, k s)
2
(%o11) ------------------------
sqrt(%pi) sqrt(s)
(%i12) gamma_expand:true$
(%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
erfc(sqrt(k) sqrt(s))
(%o13) ---------------------
sqrt(s)
(%i14) expintrep:expintegral_e1$
(%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t));
a s
a s %e expintegral_e1(a s) - 1
(%o15) - ---------------------------------
a
Vereinfacht die Hypergeometrische Funktion zu einfacheren Funktionen, wie Polynome und spezielle Funktionen. Die Hypergeometrische Funktion ist die verallgemeinerte geometrische Reihe und ist wie folgt definiert:
F (a_1, ... a_p; b_1, ..., b_q; z) =
p, q
inf p q k
==== /===\ gamma(k + a ) /===\ gamma(b ) z
\ ! ! i ! ! j
= > ! ! ------------- ! ! ----------------
/ ! ! gamma(a ) ! ! k! gamma(k + b )
==== i = 1 i j = 1 j
k = 0
Die Argumente a und b sind Listen mit den Parametern der
Hypergeometrischen Funktion a_1, …, a_p sowie
b_1, …, b_p. Die Liste a enthält die
p-Elemente a_i und die Liste b enthält die
q-Elemente b_i.
Kann hgfred die Hypergeomentrische Funktion nicht vereinfachen, wird
eine Substantivform %f[p,q]([a], [b], z) zurückgegeben.
Beispiele:
(%i1) assume(not(equal(z,0)));
(%o1) [notequal(z, 0)]
(%i2) hgfred([v+1/2],[2*v+1],2*%i*z);
v/2 %i z
4 bessel_j(v, z) gamma(v + 1) %e
(%o2) ---------------------------------------
v
z
(%i3) hgfred([1,1],[2],z);
log(1 - z)
(%o3) - ----------
z
(%i4) hgfred([a,a+1/2],[3/2],z^2);
1 - 2 a 1 - 2 a
(z + 1) - (1 - z)
(%o4) -------------------------------
2 (1 - 2 a) z
Der Hauptzweig der Lambert W Funktion, die Lösung von
z = W(z) * exp(W(z)).
Die Plasma Dispersion Funktion
nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z)).
Gibt realpart(nzeta(z)) zurück.
Gibt imagpart(nzeta(z)) zurück.
Lommels kleine Funktion s[u,v](z). Siehe Gradshteyn & Ryzhik 8.570.1.
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Crategus on Dezember, 12 2012 using texi2html 1.76.