[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

22. Spezielle Funktionen


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

22.1 Einführung für spezielle Funktionen

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 Bessel-Funktionen und verwandte Funktionen


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

22.2.1 Bessel-Funktionen

Funktion: bessel_j (v, z)

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 function

bessel_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 characteristic

Maxima kennt den Realteil und den Imaginärteil von bessel_j für spezielle Argumente v und z.

limit function

Maxima kennt spezielle Grenzwerte der Funktion bessel_j.

integral

Maxima kennt das Integral der Funktion bessel_j für die Integrationsvariable z.

gradef

Maxima 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_over

Hat 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.

besselexpand

Hat die Optionsvariable besselexpand den Wert true, wird bessel_j mit einer halbzahligen Ordnung v als Sinus- und Kosinusfunktionen entwickelt.

bessel_reduce

Hat 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_representation

Hat 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)

Funktion: bessel_y (v, z)

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 function

bessel_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 characteristic

Maxima kennt den Realteil und den Imaginärteil von bessel_y für spezielle Argumente v und z.

limit function

Maxima kennt spezielle Grenzwerte der Funktion bessel_y.

integral

Maxima kennt das Integral der Funktion bessel_y für die Integrationsvariable z.

gradef

Maxima 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_over

Hat 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.

besselexpand

Hat die Optionsvariable besselexpand den Wert true, wird bessel_y mit einer halbzahligen Ordnung v als Sinus- und Kosinusfunktionen entwickelt.

bessel_reduce

Hat 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_representation

Hat 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.

Funktion: bessel_i (v, z)

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 function

bessel_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 characteristic

Maxima kennt den Realteil und den Imaginärteil von bessel_i für spezielle Argumente v und z.

limit function

Maxima kennt spezielle Grenzwerte der Funktion bessel_i.

integral

Maxima kennt das Integral der Funktion bessel_i für die Integrationsvariable z.

gradef

Maxima 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_over

Hat 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.

besselexpand

Hat die Optionsvariable besselexpand den Wert true, wird bessel_i mit einer halbzahligen Ordnung v als Hyperbelfunktionen entwickelt.

bessel_reduce

Hat 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_representation

Hat 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.

Funktion: bessel_k (v, z)

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 function

bessel_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 characteristic

Maxima kennt den Realteil und den Imaginärteil von bessel_k für spezielle Argumente v und z.

limit function

Maxima kennt spezielle Grenzwerte der Funktion bessel_k.

integral

Maxima kennt das Integral der Funktion bessel_k für die Integrationsvariable z.

gradef

Maxima 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_over

Hat 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.

besselexpand

Hat die Optionsvariable besselexpand den Wert true, wird bessel_k mit einer halbzahligen Ordnung v als Exponentialfunktion entwickelt.

bessel_reduce

Hat 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_representation

Hat 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.

Optionsvariable: bessel_reduce

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.

Optionsvariable: besselexpand

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

Funktion: scaled_bessel_i (v, 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

Funktion: scaled_bessel_i0 (z)

Entspricht scaled_bessel_i(0,z). Siehe scaled_bessel_i.

Funktion: scaled_bessel_i1 (z)

Entspricht scaled_bessel_i(1,z). Siehe scaled_bessel_i.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

22.2.2 Hankel-Funktionen

Funktion: hankel_1 (v, z)

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

Funktion: hankel_2 (v, z)

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] [ ? ]

22.2.3 Airy-Funktionen

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

Funktion: airy_ai (z)

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

Funktion: airy_dai (z)

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.

Funktion: airy_bi (z)

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.

Funktion: airy_dbi (z)

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] [ ? ]

22.2.4 Struve-Funktionen

Funktion: struve_h (v, z)

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

Funktion: struve_l (v, z)

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] [ ? ]

22.3 Gammafunktionen und verwandte Funktionen

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.

Funktion: bffac (x, fpprec)

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

Funktion: bfpsi (n, x, fpprec)
Funktion: bfpsi0 (x, fpprec)

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

Funktion: cbffac (z, fpprec)

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.

Funktion: gamma (z)

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

Optionsvariable: gamma_expand

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.

Funktion: log_gamma (z)

Der Logarithmus der Gammafunktion.

Funktion: gamma_incomplete (a, z)

Die unvollständige Gammafunktion (A & S 6.5.2) die definiert ist als

                  inf
                 /
                 [     a - 1   - t
                 I    t      %e    dt
                 ]
                 /
                  z

Funktion: gamma_incomplete_regularized (a, z)

Regularisierte unvollständige Gammafunktion (A & S 6.5.1)

               gamma_incomplete(a, z)
               ----------------------
                      gamma(a)

Funktion: gamma_incomplete_generalized (a, z1, z2)

Verallgemeinerte unvollständige Gammafunktion

                  z2
                 /
                 [    a - 1   - t
                 I   t      %e    dt
                 ]
                 /
                  z1

Optionsvariable: gammalim

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.

Funktion: makegamma (expr)

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)

Funktion: beta (a, b)

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

Funktion: beta_incomplete (a, b, z)

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 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)

Funktion: beta_incomplete_regularized (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 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

Funktion: beta_incomplete_generalized (a, b, z1, z2)

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)

Optionsvariable: beta_expand

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.

Optionsvariable: beta_args_sum_to_integer

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.

Funktion: psi [n](x)

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.

Optionsvariable: maxpsiposint

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

Optionsvariable: maxpsinegint

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

Optionsvariable: maxpsifracnum

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

Optionsvariable: maxpsifracdenom

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

Funktion: makefact (expr)

Ersetzt Binomial-, Gamma- und Beta-Funktionen, die im Ausdruck expr auftreten, durch Fakultäten.

Siehe auch die Funktion makegamma.

Funktion: numfactor (expr)

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] [ ? ]

22.4 Exponentielle Integrale

Die Exponentiellen Integrale und verwandte Funktionen sind definiert in Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 5.

Funktion: expintegral_e1 (z)

Das Exponentielle Integral E1(z) (A&S 5.1.1).

Funktion: expintegral_ei (z)

Das Exponentielle Integral Ei(z) (A&S 5.1.2).

Funktion: expintegral_li (n,z)

Das Exponentielle Integral Li(z) (A&S 5.1.3).

Funktion: expintegral_e (n, z)

Das Exponentielle Integral E[n](z) (A&S 5.1.4).

Funktion: expintegral_si (z)

Das Exponentielle Integral Si(z) (A&S 5.2.1).

Funktion: expintegral_ci (z)

Das Exponentielle Integral Ci(z) (A&S 5.2.2).

Funktion: expintegral_shi (z)

Das Exponentielle Integral Shi(z) (A&S 5.2.3).

Funktion: expintegral_chi (z)

Das Exponentielle Integral Chi(z) (A&S 5.2.4).

Optionsvariable: expintrep

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.

Optionsvariable: expintexpand

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] [ ? ]

22.5 Fehlerfunktionen

Die Fehlerfunktion und verwandte Funktionen sind definiert in Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 7.

Funktion: erf (z)

Die Fehlerfunktion erf(z) (A&S 7.1.1).

Siehe auch die Optionsvariable erfflag.

Function: erfc (z)

Die komplementäre Fehlerfunktion erfc(z) = 1 - erf(z) (A & S 7.1.2).

Funktion: erfi (z)

Die imaginäre Fehlerfunktion erfi(z) = -%i*erf(%i*z).

Funktion: erf_generalized (z1, z2)

Die verallgemeinerte Fehlerfunktion Erf(z1, z2).

Funktion: fresnel_c (z)

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.

Funktion: fresnel_s (z)

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.

Optionsvariable: erf_representation

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.

Optionsvariable: hypergeometric_representation

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 Elliptische Funktionen und Integrale


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

22.6.1 Einführung in Elliptische Funktionen und Integrale

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] [ ? ]

22.6.2 Funktionen und Variablen für Elliptische Funktionen

Funktion: jacobi_sn (u, m)

Die Jacobische elliptische Funktion sn(u,m).

Funktion: jacobi_cn (u, m)

Die Jacobische elliptische Funktion cn(u,m).

Funktion: jacobi_dn (u, m)

Die Jacobische elliptische Funktion dn(u,m).

Funktion: jacobi_ns (u, m)

Die Jacobische elliptische Funktion ns(u,m) = 1/sn(u,m).

Funktion: jacobi_sc (u, m)

Die Jacobische elliptische Funktion sc(u,m) = sn(u,m)/cn(u,m).

Funktion: jacobi_sd (u, m)

Die Jacobische elliptische Funktion sd(u,m) = sn(u,m)/dn(u,m).

Funktion: jacobi_nc (u, m)

Die Jacobische elliptische Funktion nc(u,m) = 1/cn(u,m).

Funktion: jacobi_cs (u, m)

Die Jacobische elliptische Funktion cs(u,m) = cn(u,m)/sn(u,m).

Funktion: jacobi_cd (u, m)

Die Jacobische elliptische Funktion cd(u,m) = cn(u,m)/dn(u,m).

Funktion: jacobi_nd (u, m)

Die Jacobische elliptische Funktion nc(u,m) = 1/cn(u,m).

Funktion: jacobi_ds (u, m)

Die Jacobische elliptische Funktion ds(u,m) = dn(u,m)/sn(u,m).

Funktion: jacobi_dc (u, m)

Die Jacobische elliptische Funktion dc(u,m) = dn(u,m)/cn(u,m).

Funktion: inverse_jacobi_sn (u, m)

Die inverse Jacobische elliptische Funktion sn(u,m).

Funktion: inverse_jacobi_cn (u, m)

Die inverse Jacobische elliptische Funktion cn(u,m).

Funktion: inverse_jacobi_dn (u, m)

Die inverse Jacobische elliptische Funktion dn(u,m).

Funktion: inverse_jacobi_ns (u, m)

Die inverse Jacobische elliptische Funktion ns(u,m).

Funktion: inverse_jacobi_sc (u, m)

Die inverse Jacobische elliptische Funktion sc(u,m).

Funktion: inverse_jacobi_sd (u, m)

Die inverse Jacobische elliptische Funktion sd(u,m).

Funktion: inverse_jacobi_nc (u, m)

Die inverse Jacobische elliptische Funktion nc(u,m).

Funktion: inverse_jacobi_cs (u, m)

Die inverse Jacobische elliptische Funktion cs(u,m).

Funktion: inverse_jacobi_cd (u, m)

Die inverse Jacobische elliptische Funktion cd(u,m).

Funktion: inverse_jacobi_nd (u, m)

Die inverse Jacobische elliptische Funktion nc(u,m).

Funktion: inverse_jacobi_ds (u, m)

Die inverse Jacobische elliptische Funktion ds(u,m).

Funktion: inverse_jacobi_dc (u, m)

Die inverse Jacobische elliptische Funktion dc(u,m).


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

22.6.3 Funktionen und Variablen für Elliptische Integrale

Funktion: elliptic_f (phi, m)

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.

Funktion: elliptic_e (phi, m)

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.

Funktion: elliptic_eu (u, m)

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.

Funktion: elliptic_pi (n, phi, m)

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.

Funktion: elliptic_kc (m)

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.

Funktion: elliptic_ec (m)

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] [ ? ]

22.7 Hypergeometrische Funktionen

Funktion: %m [k, u] (z)

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.

Funktion: %w [k, u] (z)

Ist die Whittaker W Funktion. Siehe A & S 13.1.33 für die Definition.

Funktion: %f [p,q] ([a], [b], z)

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.

Funktion: hypergeometric ([a_1, …, a_p], [b_1, … ,b_q], z)

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

Funktion: parabolic_cylinder_d (v, z)

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] [ ? ]

22.8 Weitere spezielle Funktionen

Funktion: li [s] (z)

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]

Funktion: specint (exp(- s*t) * expr, t)

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

Funktion: hgfred (a, b, z)

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

Funktion: lambert_w (z)

Der Hauptzweig der Lambert W Funktion, die Lösung von z = W(z) * exp(W(z)).

Funktion: nzeta (z)

Die Plasma Dispersion Funktion nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z)).

Funktion: nzetar (z)

Gibt realpart(nzeta(z)) zurück.

Funktion: nzetai (z)

Gibt imagpart(nzeta(z)) zurück.

Funktion: %s [u,v] (z)

Lommels kleine Funktion s[u,v](z). Siehe Gradshteyn & Ryzhik 8.570.1.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on Juli, 9 2012 using texi2html 1.76.