Nächste: Hankel-Funktionen, Vorige: Bessel-Funktionen und verwandte Funktionen, Nach oben: Bessel-Funktionen und verwandte Funktionen [Inhalt][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.
Nächste: Hankel-Funktionen, Vorige: Bessel-Funktionen und verwandte Funktionen, Nach oben: Bessel-Funktionen und verwandte Funktionen [Inhalt][Index]