Next: Hankel-Funktionen, Previous: Bessel-Funktionen und verwandte Funktionen, Up: Bessel-Funktionen und verwandte Funktionen [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`.

Next: Hankel-Funktionen, Previous: Bessel-Funktionen und verwandte Funktionen, Up: Bessel-Funktionen und verwandte Funktionen [Contents][Index]