[ < ] | [ > ] |  | [ << ] | [ 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
    gamma_incomplete_lower(a, z)   unvollständige Gamma-Funktion der unteren Grenze
    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 Viktor T. Toth on Oktober, 3 2017 using texi2html 1.76.