[ < ] [ > ]   [ << ] [ 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 (index, expr)         Bessel function, 1st kind
bessel_y (index, expr)         Bessel function, 2nd kind
bessel_i (index, expr)         Modified Bessel function, 1st kind
bessel_k (index, expr)         Modified Bessel function, 2nd kind

hankel_1 (v,z)                 Hankel function of the 1st kind
hankel_2 (v,z)                 Hankel function of the 2nd kind
struve_h (v,z)                 Struve H function
struve_l (v,z)                 Struve L function

assoc_legendre_p[v,u] (z)      Legendre function of degree v and order u 
assoc_legendre_q[v,u] (z)      Legendre function, 2nd kind

%f[p,q] ([], [], expr)         Generalized Hypergeometric function
gamma()                        Gamma function
gammagreek(a,z)                Incomplete gamma function
gammaincomplete(a,z)           Tail of incomplete gamma function
hypergeometric(l1, l2, z)      Hypergeometric function
slommel
%m[u,k] (z)                    Whittaker function, 1st kind
%w[u,k] (z)                    Whittaker function, 2nd kind
erfc (z)                       Complement of the erf function

expintegral_e (v,z)            Exponential integral E
expintegral_e1 (z)             Exponential integral E1
expintegral_ei (z)             Exponential integral Ei
expintegral_li (z)             Logarithmic integral Li
expintegral_si (z)             Exponential integral Si
expintegral_ci (z)             Exponential integral Ci
expintegral_shi (z)            Exponential integral Shi
expintegral_chi (z)            Exponential integral Chi

kelliptic (z)                  Complete elliptic integral of the first 
                               kind (K)
parabolic_cylinder_d (v,z)     Parabolic cylinder D function

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

22.2 Besselfunktionen und verwandte Funktionen


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

22.2.1 Besselfunktionen

Funktion: bessel_j (v, z)

Die Besselfunktion der ersten Art der Ordnung v und dem Argument z. bessel_j ist definiert als

                inf
                ====       k  - v - 2 k  v + 2 k
                \     (- 1)  2          z
                 >    --------------------------
                /        k! gamma(v + k + 1)
                ====
                k = 0

Die Reihenentwicklung wird nicht für die numerische Berechnung genutzt.

Die Besselfunktion 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 Zahlen sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.

Die Besselfunktion hat die folgenden Eigenschaften, die mit 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.

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 in Bezug auf das Argument z.

gradef

Maxima kennt die Ableitungen der Funktion bessel_j in Bezug auf die Argumente v und z.

Die Vereinfachung der Besselfunktion bessel_j wird von den folgenden Optionsvariablen kontrolliert:

distribute_over

Hat die Optionsvariable distribute_over den Wert true und ist das Argument der Besselfunktion 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, werden Besselfunktion mit einer halbzahligen Ordnung v als Sinus- und Kosinusfunktionen entwickelt.

bessel_reduce

Hat die Optionsvariable bessel_reduce den Wert true, werden Besselfunktionen mit einer ganzzahligen Ordnung n nach Besselfunktionen mit der niedrigsten Ordnung 0 und 1 entwickelt.

Zusätzlich kennt Maxima die geraden und ungeraden Symmetrieeigenschaften der Besselfunktionen für eine ganzzahlige Ordnung v.

Beispiele:

Numerisches Rechnen mit der Besselfunktion. 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 Besselfunktion 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 Besselfunktion.

(%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

Besselfunktionen 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 Besselfunktion der zweiten Art der Ordnung v und dem Argument z. bessel_y ist definiert als

              cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
              -------------------------------------------
                             sin(%pi v)

für den Fall, dass v keine ganze Zahl ist. Ist v eine ganze Zahl n, dann wird die Besselfunktion bessel_y als der Grenzwert definiert, wenn v gegen die ganze Zahl n geht.

Die Besselfunktion 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 Zahlen sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.

Funktion: bessel_i (v, z)

Die modifizierte Besselfunktion der ersten Art der Ordnung v und dem Argument v. bessel_i ist definiert als

                    inf
                    ====   - v - 2 k  v + 2 k
                    \     2          z
                     >    -------------------
                    /     k! gamma(v + k + 1)
                    ====
                    k = 0

Die Reihenentwicklung wird nicht für die numerische Berechnung genutzt.

Die Besselfunktion 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 Zahlen sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.

Funktion: bessel_k (v, z)

Die modifizierte Besselfunktion der zweiten Art der Ordnung v und dem Argument z. bessel_k ist definiert als

           %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
           -------------------------------------------------
                                  2

für den Fall, dass v keine ganze Zahl ist. Ist v eine ganze Zahl n, dann wird die Besselfunktion bessel_k als der Grenzwert definiert, wenn v gegen die ganze Zahl n geht.

Die Besselfunktion 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 Zahlen sind. Die numerische Berechnung für große Gleitkommazahlen ist nicht implementiert. In diesem Fall gibt Maxima eine Substantivform zurück.

Optionsvariable: bessel_reduce

Standardwert: false

Hat die Optionsvariable bessel_reduce den Wert true, werden Besselfunktionen mit einer ganzzahligen Ordnung n nach Besselfunktionen mit der niedrigsten Ordnung 0 und 1 entwickelt.

Optionsvariable: besselexpand

Standardwert: false

Hat die Optionsvariable besselexpand den Wert true, werden Besselfunktion mit einer halbzahligen Ordnung v als Sinus- und Kosinusfunktionen entwickelt. Die Optionsvariable besselexpand kontrolliert auch die Entwicklung der Hankelfunktionen hankel_1 und hankel_2 sowie der Struvefunktionen 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)

Funktion: scaled_bessel_i (v, z)

Die skalierte modifizierte Besselfunktion der ersten Art der Ordnung v und dem Argument z. Diese ist definiert als scaled_bessel_i(v,z) = exp(-abs(z))*bessel_i(v, z). 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 kann die Funktion bessel_i verwendet werden.

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)

Identical to scaled_bessel_i(0,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 Hankelfunktion

Funktion: hankel_1 (v, z)

Die Hankelfunktion der ersten Art der Ordnung v und dem Argument z. Siehe A & S 9.1.3. hankel_1 ist definiert als

   bessel_j(v,z) + %i * bessel_y(v,z)

Die Hankelfunktion 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.

When besselexpand is true, hankel_1 is expanded in terms of elementary functions when the order v is half of an odd integer. See besselexpand.

Maxima knows the derivative of hankel_1 wrt the argument z.

Examples:

Numerical evaluation:

(%i1) hankel_1(1,0.5);
(%o1)              .2422684576748738 - 1.471472392670243 %i
(%i2) hankel_1(1,0.5+%i);
(%o2)             - .2558287994862166 %i - 0.239575601883016

A complex order v is not supported. Maxima returns a noun form:

(%i3) hankel_1(%i,0.5+%i);
(%o3)                       hankel_1(%i, %i + 0.5)

Expansion of hankel_1 when besselexpand is true:

(%i4) hankel_1(1/2,z),besselexpand:true;
                      sqrt(2) sin(z) - sqrt(2) %i cos(z)
(%o4)                 ----------------------------------
                              sqrt(%pi) sqrt(z)

Derivative of hankel_1 wrt the argument z. The derivative wrt the order v is not supported. Maxima returns a noun form:

(%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 Hankelfunktion der ersten Art der Ordnung v und dem Argument z. Siehe A & S 9.1.4. hankel_2 ist definiert als

   bessel_j(v,z) - %i * bessel_y(v,z)

Die Hankelfunktion 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.

When besselexpand is true, hankel_2 is expanded in terms of elementary functions when the order v is half of an odd integer. See besselexpand.

Maxima knows the derivative of hankel_2 wrt the argument z.

For examples see hankel_1.


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

22.2.3 Airyfunktionen

The Airy functions Ai(x) and Bi(x) are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 10.4.

y = Ai(x) and y = Bi(x) are two linearly independent solutions of the Airy differential equation diff (y(x), x, 2) - x y(x) = 0.

If the argument x is a real or complex floating point number, the numerical value of the function is returned.

Function: airy_ai (x)

The Airy function Ai(x). (A&S 10.4.2)

The derivative diff (airy_ai(x), x) is airy_dai(x).

See also airy_bi, airy_dai, airy_dbi.

Function: airy_dai (x)

The derivative of the Airy function Ai airy_ai(x).

See airy_ai.

Function: airy_bi (x)

The Airy function Bi(x). (A&S 10.4.3)

The derivative diff (airy_bi(x), x) is airy_dbi(x).

See airy_ai, airy_dbi.

Function: airy_dbi (x)

The derivative of the Airy Bi function airy_bi(x).

See airy_ai and airy_bi.


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

22.2.4 Struvefunktionen

Funktion: struve_h (v, z)

Die Struvefunktion H der Ordnung v und 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
   (-)       >    ----------------------------------
    2       /      2 k           3                3
            ====  2    gamma(k + -) gamma(v + k + -)
            k = 0                2                2

Die Struvefunktion struve_h ist für das numerische und symbolische Rechnen geeignet. Im Unterschied zu den Besselfunktionen 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 Struvefunktion struve_h mit einer halbzahligen Ordnung v als Sinus- und Kosinusfunktionen entwickelt.

Maxima kennt die Ableitung der Struvefunktion struve_h nach dem Argument z.

Siehe auch die Struvefunktion 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 Struvefunktion L der Ordnung v und dem Argument z. Siehe Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel 12. Die Definition ist

            inf
            ====                  2 k
    z v + 1 \                    z
   (-)       >    ----------------------------------
    2       /      2 k           3                3
            ====  2    gamma(k + -) gamma(v + k + -)
            k = 0                2                2

Die Struvefunktion struve_l ist für das numerische und symbolische Rechnen geeignet. Im Unterschied zu den Besselfunktionen 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 Struvefunktion struve_l mit einer halbzahligen Ordnung v als Sinus- und Kosinusfunktionen entwickelt.

Maxima kennt die Ableitung der Struvefunktion struve_l nach dem Argument z.

Siehe auch die Struvefunktion 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

The gamma function and the related beta, psi and incomplete gamma functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 6.

Function: bffac (expr, n)

Bigfloat version of the factorial (shifted gamma) function. The second argument is how many digits to retain and return, it's a good idea to request a couple of extra.

Function: bfpsi (n, z, fpprec)
Function: bfpsi0 (z, fpprec)

bfpsi is the polygamma function of real argument z and integer order n. bfpsi0 is the digamma function. bfpsi0 (z, fpprec) is equivalent to bfpsi (0, z, fpprec).

These functions return bigfloat values. fpprec is the bigfloat precision of the return value.

Function: cbffac (z, fpprec)

Complex bigfloat factorial.

load ("bffac") loads this function.

Function: gamma (z)

The basic definition of the gamma function (A&S 6.1.1) is

                       inf
                      /
                      [     z - 1   - t
           gamma(z) = I    t      %e    dt
                      ]
                      /
                       0

Maxima simplifies gamma for positive integer and positive and negative rational numbers. For half integral values the result is a rational number times sqrt(%pi). The simplification for integer values is controlled by factlim. For integers greater than factlim the numerical result of the factorial function, which is used to calculate gamma, will overflow. The simplification for rational numbers is controlled by gammalim to avoid internal overflow. See factlim and gammalim.

For negative integers gamma is not definied.

Maxima can evalute gamma numerically for real and complex values in float and bigfloat precision.

gamma has mirror symmetry.

When gamma_expand is true, Maxima expands gamma for arguments z+n and z-n where n is an integer.

Maxima knows the derivate of gamma.

Examples:

Simplification for integer, half integral, and rational numbers:

(%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

Numerical evaluation for real and complex values:

(%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 has mirror symmetry:

(%i6) declare(z,complex)$
(%i7) conjugate(gamma(z));
(%o7)                  gamma(conjugate(z))

Maxima expands gamma(z+n) and gamma(z-n), when gamma_expand is true:

(%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

The deriviative of gamma:

(%i10) diff(gamma(z),z);
(%o10)                  psi (z) gamma(z)
                           0

See also makegamma.

The Euler-Mascheroni constant is %gamma.

Function: log_gamma (z)

The natural logarithm of the gamma function.

Function: gamma_incomplete (a, z)

The incomplete upper gamma function A&S 6.5.2:

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

Function: gamma_incomplete_regularized (a, z)

The regularized incomplete upper gamma function A&S 6.5.1.

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

Function: gamma_incomplete_generalized (a, z1, z2)

The generalized incomplete gamma function defined as

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

Option variable: gammalim

Default value: 1000000

gammalim controls simplification of the gamma function for integral and rational number arguments. If the absolute value of the argument is not greater than gammalim, then simplification will occur. Note that the factlim switch controls simplification of the result of gamma of an integer argument as well.

Function: makegamma (expr)

Transforms instances of binomial, factorial, and beta functions in expr into gamma functions.

See also makefact.

Function: beta (a, b)

The beta function is defined as gamma(a) gamma(b)/gamma(a+b) (A&S 6.2.1).

Maxima simplifies the beta function for positive integers and rational numbers, which sum to an integer. When beta_args_sum_to_integer is true, Maxima simplifies also general expressions which sum to an integer.

For a or b equal to zero the beta function is not defined.

In general the beta function is not defined for negative integers as an argument. The exception is for a=-n, n a positive integer and b a positive integer with b<=n, it is possible to define an analytic continuation. Maxima gives for this case a result.

When beta_expand is true, expressions like beta(a+n,b) and beta(a-n,b) or beta(a,b+n) and beta(a,b-n) with n an integer are simplified.

Maxima can evaluate the beta function for real and complex values in float and bigfloat precision. For numerical evaluation Maxima uses log_gamma:

           - log_gamma(b + a) + log_gamma(b) + log_gamma(a)
         %e

Maxima knows that the beta function is symmetric and has mirror symmetry.

Maxima knows the derivatives of the beta function with respect to a or b.

To express the beta function as a ratio of gamma functions see makegamma.

Examples:

Simplification, when one of the arguments is an integer:

(%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
                               1   9      1
(%o1)                         [--, -, ---------]
                               12  4  a (a + 1)

Simplification for two rational numbers as arguments which sum to an integer:

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

When setting beta_args_sum_to_integer to true more general expression are simplified, when the sum of the arguments is an integer:

(%i3) beta_args_sum_to_integer:true$
(%i4) beta(a+1,-a+2);
                                %pi (a - 1) a
(%o4)                         ------------------
                              2 sin(%pi (2 - a))

The possible results, when one of the arguments is a negative integer:

(%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
                                    1  1    1
(%o5)                            [- -, -, - -]
                                    3  6    3

beta(a+n,b) or beta(a-n) with n an integer simplifies when beta_expand is true:

(%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

Beta is not definied, when one of the arguments is zero:

(%i7) beta(0,b);
beta: expected nonzero arguments; found 0, b
 -- an error.  To debug this try debugmode(true);

Numercial evaluation for real and complex arguments in float or bigfloat precision:

(%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

Beta is symmetric and has mirror symmetry:

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

The derivative of the beta function wrt a:

(%i17) diff(beta(a,b),a);
(%o17)               - beta(a, b) (psi (b + a) - psi (a))
                                      0             0

Function: beta_incomplete (a, b, z)

The basic definition of the incomplete beta function (A&S 6.6.1) is

                       z
                      /
                      [         b - 1  a - 1
                      I  (1 - t)      t      dt
                      ]
                      /
                       0

This definition is possible for realpart(a)>0 and realpart(b)>0 and abs(z)<1. For other values the incomplete beta function can be defined through a generalized hypergeometric function:

   gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z

(See functions.wolfram.com for a complete definition of the incomplete beta function.)

For negative integers a = -n and positive integers b=m with m<=n the incomplete beta function is defined through

                            m - 1           k
                            ====  (1 - m)  z
                      n - 1 \            k
                     z       >    -----------
                            /     k! (n - k)
                            ====
                            k = 0

Maxima uses this definition to simplify beta_incomplete for a a negative integer.

For a a positive integer, beta_incomplete simplifies for any argument b and z and for b a positive integer for any argument a and z, with the exception of a a negative integer.

For z=0 and realpart(a)>0, beta_incomplete has the specific value zero. For z=1 and realpart(b)>0, beta_incomplete simplifies to the beta function beta(a,b).

Maxima evaluates beta_incomplete numerically for real and complex values in float or bigfloat precision. For the numerical evaluation an expansion of the incomplete beta function in continued fractions is used.

When beta_expand is true, Maxima expands expressions like beta_incomplete (a+n, b, z) and beta_incomplete (a-n, b, z) where n is a positive integer.

Maxima knows the derivatives of beta_incomplete with respect to the variables a, b and z and the integral with respect to the variable z.

Examples:

Simplification for a a positive integer:

(%i1) beta_incomplete(2,b,z);
                                       b
                            1 - (1 - z)  (b z + 1)
(%o1)                       ----------------------
                                  b (b + 1)

Simplification for b a positive integer:

(%i2) beta_incomplete(a,2,z);
                                               a
                              (a (1 - z) + 1) z
(%o2)                         ------------------
                                  a (a + 1)

Simplification for a and b a positive integer:

(%i3) beta_incomplete(3,2,z);
                                               3
                              (3 (1 - z) + 1) z
(%o3)                         ------------------
                                      12

a is a negative integer and b<=(-a), Maxima simplifies:

(%i4) beta_incomplete(-3,1,z);
                                       1
(%o4)                              - ----
                                        3
                                     3 z

For the specific values z=0 and z=1, Maxima simplifies:

(%i5) assume(a>0,b>0)$
(%i6) beta_incomplete(a,b,0);
(%o6)                                 0
(%i7) beta_incomplete(a,b,1);
(%o7)                            beta(a, b)

Numerical evaluation in float or bigfloat precision:

(%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

For abs(z)>1 beta_incomplete returns a complex result:

(%i11) beta_incomplete(0.25,0.50,1.7);
(%o11)              5.244115108584249 - 1.45518047787844 %i

Results for more general complex arguments:

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

Expansion, when beta_expand is true:

(%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

Derivative and integral for beta_incomplete:

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

Function: beta_incomplete_regularized (a, b, z)

The regularized incomplete beta function A&S 6.6.2, defined as

              beta_incomplete(a, b, z)
              ------------------------
                     beta(a, b)

As for beta_incomplete this definition is not complete. See functions.wolfram.com for a complete definition of beta_incomplete_regularized.

beta_incomplete_regularized simplifies a or b a positive integer.

For z=0 and realpart(a)>0, beta_incomplete_regularized has the specific value 0. For z=1 and realpart(b)>0, beta_incomplete_regularized simplifies to 1.

Maxima can evaluate beta_incomplete_regularized for real and complex arguments in float and bigfloat precision.

When beta_expand is true, Maxima expands beta_incomplete_regularized for arguments a+n or a-n, where n is an integer.

Maxima knows the derivatives of beta_incomplete_regularized with respect to the variables a, b, and z and the integral with respect to the variable z.

Examples:

Simplification for a or b a positive integer:

(%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

For the specific values z=0 and z=1, Maxima simplifies:

(%i4) assume(a>0,b>0)$

(%i5) beta_incomplete_regularized(a,b,0);
(%o5)                           0
(%i6) beta_incomplete_regularized(a,b,1);
(%o6)                           1

Numerical evaluation for real and complex arguments in float and bigfloat precision:

(%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, when beta_expand is true:

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

The derivative and the integral wrt z:

(%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

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

The basic definition of the generalized incomplete beta function is

                      z2
                     /
                     [          b - 1  a - 1
                     I   (1 - t)      t      dt
                     ]
                     /
                      z1

Maxima simplifies beta_incomplete_regularized for a and b a positive integer.

For realpart(a)>0 and z1=0 or z2=0, Maxima simplifies beta_incomplete_generalized to beta_incomplete. For realpart(b)>0 and z1=1 or z2=1, Maxima simplifies to an expression with beta and beta_incomplete.

Maxima evaluates beta_incomplete_regularized for real and complex values in float and bigfloat precision.

When beta_expand is true, Maxima expands beta_incomplete_generalized for a+n and a-n, n a positive integer.

Maxima knows the derivative of beta_incomplete_generalized with respect to the variables a, b, z1, and z2 and the integrals with respect to the variables z1 and z2.

Examples:

Maxima simplifies beta_incomplete_generalized for a and b a positive integer:

(%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

Simplification for specific values z1=0, z2=0, z1=1, or 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)

Numerical evaluation for real arguments in float or bigfloat precision:

(%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

Numerical evaluation for complex arguments in float or bigfloat precision:

(%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 for a+n or a-n, n a positive integer, when beta_expand is true:

(%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

Derivative wrt the variable z1 and integrals wrt z1 and 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)

Option variable: beta_expand

Default value: false

When beta_expand is true, beta(a,b) and related functions are expanded for arguments like a+n or a-n, where n is an integer.

Option variable: beta_args_sum_to_integer

Default value: false

When beta_args_sum_to_integer is true, Maxima simplifies beta(a,b), when the arguments a and b sum to an integer.

Function: psi [n](x)

The derivative of log (gamma (x)) of order n+1. Thus, psi[0](x) is the first derivative, psi[1](x) is the second derivative, etc.

Maxima does not know how, in general, to compute a numerical value of psi, but it can compute some exact values for rational args. Several variables control what range of rational args psi will return an exact value, if possible. See maxpsiposint, maxpsinegint, maxpsifracnum, and maxpsifracdenom. That is, x must lie between maxpsinegint and maxpsiposint. If the absolute value of the fractional part of x is rational and has a numerator less than maxpsifracnum and has a denominator less than maxpsifracdenom, psi will return an exact value.

The function bfpsi in the bffac package can compute numerical values.

Option variable: maxpsiposint

Default value: 20

maxpsiposint is the largest positive value for which psi[n](x) will try to compute an exact value.

Option variable: maxpsinegint

Default value: -10

maxpsinegint is the most negative value for which psi[n](x) will try to compute an exact value. That is if x is less than maxnegint, psi[n](x) will not return simplified answer, even if it could.

Option variable: maxpsifracnum

Default value: 6

Let x be a rational number less than one of the form p/q. If p is greater than maxpsifracnum, then psi[n](x) will not try to return a simplified value.

Option variable: maxpsifracdenom

Default value: 6

Let x be a rational number less than one of the form p/q. If q is greater than maxpsifracdenom, then psi[n](x) will not try to return a simplified value.

Function: makefact (expr)

Transforms instances of binomial, gamma, and beta functions in expr into factorials.

See also makegamma.

Function: numfactor (expr)

Returns the numerical factor multiplying the expression expr, which should be a single term.

content returns the greatest common divisor (gcd) of all terms in a sum.

(%i1) gamma (7/2);
                          15 sqrt(%pi)
(%o1)                     ------------
                               8
(%i2) numfactor (%);
                               15
(%o2)                          --
                               8

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

22.4 Exponentielle Integrale

The Exponential Integral and related funtions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 5

Function: expintegral_e1 (z)

The Exponential Integral E1(z) (A&S 5.1.1)

Function: expintegral_ei (z)

The Exponential Integral Ei(z) (A&S 5.1.2)

Function: expintegral_li (n,z)

The Exponential Integral Li(z) (A&S 5.1.3)

Function: expintegral_e (n,z)

The Exponential Integral En(z) (A&S 5.1.4)

Function: expintegral_si (z)

The Exponential Integral Si(z) (A&S 5.2.1)

Function: expintegral_ci (z)

The Exponential Integral Ci(z) (A&S 5.2.2)

Function: expintegral_shi (z)

The Exponential Integral Shi(z) (A&S 5.2.3)

Function: expintegral_chi (z)

The Exponential Integral Chi(z) (A&S 5.2.4)

Option variable: expintrep

Default value: false

Change the representation of the Exponential Integral to gamma_incomplete, expintegral_e1, expintegral_ei, expintegral_li, expintegral_trig, expintegral_hyp

Option variable: expintexpand

Default value: false

Expand the Exponential Integral E[n](z) for half integral values in terms of Erfc or Erf and for positive integers in terms of Ei


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

22.5 Fehlerfunktionen

The Error function and related funtions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 7

Function: erf (z)

The Error Function erf(z) (A&S 7.1.1)

See also flag erfflag.

Function: erfc (z)

The Complementary Error Function erfc(z) (A&S 7.1.2)

erfc(z) = 1-erf(z)

Function: erfi (z)

The Imaginary Error Function.

erfi(z) = -%i*erf(%i*z)

Function: erf_generalized (z1,z2)

Generalized Error function Erf(z1,z2)

Function: fresnel_c (z)

The Fresnel Integral C(z) = integrate(cos((%pi/2)*t^2),t,0,z). (A&S 7.3.1)

The simplification fresnel_c(-x) = -fresnel_c(x) is applied when flag trigsign is true.

The simplification fresnel_c(%i*x) = %i*fresnel_c(x) is applied when flag %iargs is true.

See flags erf_representation and hypergeometric_representation.

Function: fresnel_s (z)

The Fresnel Integral S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 7.3.2)

The simplification fresnel_s(-x) = -fresnel_s(x) is applied when flag trigsign is true.

The simplification fresnel_s(%i*x) = %i*fresnel_s(x) is applied when flag %iargs is true.

See flags erf_representation and hypergeometric_representation.

Option variable: erf_representation

Default value: false

When T erfc, erfi, erf_generalized, fresnel_s and fresnel_c are transformed to erf.

Option variable: hypergeometric_representation

Default value: false

Enables transformation to a Hypergeometric representation for fresnel_s and fresnel_c


[ < ] [ > ]   [ << ] [ 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 includes support for Jacobian elliptic functions and for complete and incomplete elliptic integrals. This includes symbolic manipulation of these functions and numerical evaluation as well. Definitions of these functions and many of their properties can by found in Abramowitz and Stegun, Chapter 16-17. As much as possible, we use the definitions and relationships given there.

In particular, all elliptic functions and integrals use the parameter m instead of the modulus k or the modular angle \alpha. This is one area where we differ from Abramowitz and Stegun who use the modular angle for the elliptic functions. The following relationships are true:

The elliptic functions and integrals are primarily intended to support symbolic computation. Therefore, most of derivatives of the functions and integrals are known. However, if floating-point values are given, a floating-point result is returned.

Support for most of the other properties of elliptic functions and integrals other than derivatives has not yet been written.

Some examples of elliptic functions:

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

Some examples of elliptic integrals:

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

Support for elliptic functions and integrals was written by Raymond Toy. It is placed under the terms of the General Public License (GPL) that governs the distribution of Maxima.


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

22.6.2 Funktionen und Variablen für Elliptische Funktionen

Function: jacobi_sn (u, m)

The Jacobian elliptic function sn(u,m).

Function: jacobi_cn (u, m)

The Jacobian elliptic function cn(u,m).

Function: jacobi_dn (u, m)

The Jacobian elliptic function dn(u,m).

Function: jacobi_ns (u, m)

The Jacobian elliptic function ns(u,m) = 1/sn(u,m).

Function: jacobi_sc (u, m)

The Jacobian elliptic function sc(u,m) = sn(u,m)/cn(u,m).

Function: jacobi_sd (u, m)

The Jacobian elliptic function sd(u,m) = sn(u,m)/dn(u,m).

Function: jacobi_nc (u, m)

The Jacobian elliptic function nc(u,m) = 1/cn(u,m).

Function: jacobi_cs (u, m)

The Jacobian elliptic function cs(u,m) = cn(u,m)/sn(u,m).

Function: jacobi_cd (u, m)

The Jacobian elliptic function cd(u,m) = cn(u,m)/dn(u,m).

Function: jacobi_nd (u, m)

The Jacobian elliptic function nc(u,m) = 1/cn(u,m).

Function: jacobi_ds (u, m)

The Jacobian elliptic function ds(u,m) = dn(u,m)/sn(u,m).

Function: jacobi_dc (u, m)

The Jacobian elliptic function dc(u,m) = dn(u,m)/cn(u,m).

Function: inverse_jacobi_sn (u, m)

The inverse of the Jacobian elliptic function sn(u,m).

Function: inverse_jacobi_cn (u, m)

The inverse of the Jacobian elliptic function cn(u,m).

Function: inverse_jacobi_dn (u, m)

The inverse of the Jacobian elliptic function dn(u,m).

Function: inverse_jacobi_ns (u, m)

The inverse of the Jacobian elliptic function ns(u,m).

Function: inverse_jacobi_sc (u, m)

The inverse of the Jacobian elliptic function sc(u,m).

Function: inverse_jacobi_sd (u, m)

The inverse of the Jacobian elliptic function sd(u,m).

Function: inverse_jacobi_nc (u, m)

The inverse of the Jacobian elliptic function nc(u,m).

Function: inverse_jacobi_cs (u, m)

The inverse of the Jacobian elliptic function cs(u,m).

Function: inverse_jacobi_cd (u, m)

The inverse of the Jacobian elliptic function cd(u,m).

Function: inverse_jacobi_nd (u, m)

The inverse of the Jacobian elliptic function nc(u,m).

Function: inverse_jacobi_ds (u, m)

The inverse of the Jacobian elliptic function ds(u,m).

Function: inverse_jacobi_dc (u, m)

The inverse of the Jacobian elliptic function dc(u,m).


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

22.6.3 Funktionen und Variablen für Elliptische Integrale

Function: elliptic_f (phi, m)

The incomplete elliptic integral of the first kind, defined as

integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)

See also elliptic_e and elliptic_kc.

Function: elliptic_e (phi, m)

The incomplete elliptic integral of the second kind, defined as

elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi)

See also elliptic_e and elliptic_ec.

Function: elliptic_eu (u, m)

The incomplete elliptic integral of the second kind, defined as

integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t, 0, tau)

where tau = sn(u,m).

This is related to elliptic_e by

elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m)

See also elliptic_e.

Function: elliptic_pi (n, phi, m)

The incomplete elliptic integral of the third kind, defined as

integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)

Only the derivative with respect to phi is known by Maxima.

Function: elliptic_kc (m)

The complete elliptic integral of the first kind, defined as

integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

For certain values of m, the value of the integral is known in terms of Gamma functions. Use makegamma to evaluate them.

Function: elliptic_ec (m)

The complete elliptic integral of the second kind, defined as

integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

For certain values of m, the value of the integral is known in terms of Gamma functions. Use makegamma to evaluate them.


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

22.7 Hypergeometrische Funktionen

The Hypergeometric Functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapters 13 and 15.

Maxima has very limited knowledge of these functions. They can be returned from function hgfred.

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

Whittaker M function M[k,u](z) = exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z). (A&S 13.1.32)

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

Whittaker W function. (A&S 13.1.33)

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

The pFq(a1,a2,..ap;b1,b2,..bq;z) hypergeometric function, where a a list of length p and b a list of length q.

Function: hypergeometric ([a1, …, ap],[b1, … ,bq], x)

The hypergeometric function. Unlike Maxima's %f hypergeometric function, the function hypergeometric is a simplifying function; also, hypergeometric supports complex double and big floating point evaluation. For the Gauss hypergeometric function, that is p = 2 and q = 1, floating point evaluation outside the unit circle is supported, but in general, it is not supported.

When the option variable expand_hypergeometric is true (default is false) and one of the arguments a1 through ap is a negative integer (a polynomial case), hypergeometric returns an expanded polynomial.

Examples:

 (%i1)  hypergeometric([],[],x);
 (%o1) %e^x

Polynomial cases automatically expand when expand_hypergeometric is true:

 (%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

Both double float and big float evaluation is supported:

(%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

Function: parabolic_cylinder_d (v, z)

The parabolic cylinder function parabolic_cylinder_d(v,z). (A&s 19.3.1)

The Parabolic Cylinder Functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 19.

Maxima has very limited knowledge of these functions. They can be returned from function hgfred.


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

22.8 Funktionen und Variablen für spezielle Funktionen

Funktion: li [s] (z)

ist der Polylogarithmus der Ordnung s und 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]

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

Compute the Laplace transform of expr with respect to the variable t. The integrand expr may contain special functions.

The following special functions are handled by specint: incomplete gamma function, error functions (but not the error function erfi, it is easy to transform erfi e.g. to the error function erf), exponential integrals, bessel functions (including products of bessel functions), hankel functions, hermite and the laguerre polynomials.

Furthermore, specint can handle the hypergeometric function %f[p,q]([],[],z), the whittaker function of the first kind %m[u,k](z) and of the second kind %w[u,k](z).

The result may be in terms of special functions and can include unsimplified hypergeomtric functions.

When laplace fails to find a Laplace transform, specint is called. Because laplace knows more general rules for Laplace transforms, it is preferable to use laplace and not specint.

demo(hypgeo) displays several examples of Laplace transforms computed by specint.

Examples:

(%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

Examples for exponential integrals:

(%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

Results when using the expansion of gamma_incomplete and when changing the representation to 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

Function: hgfred (a, b, t)

Simplify the generalized hypergeometric function in terms of other, simpler, forms. a is a list of numerator parameters and b is a list of the denominator parameters.

If hgfred cannot simplify the hypergeometric function, it returns an expression of the form %f[p,q]([a], [b], x) where p is the number of elements in a, and q is the number of elements in b. This is the usual pFq generalized hypergeometric function.

(%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

It can be beneficial to load orthopoly too as the following example shows. Note that L is the generalized Laguerre polynomial.

(%i5) load(orthopoly)$
(%i6) hgfred([-2],[a],z);

                                    (a - 1)
                                 2 L       (z)
                                    2
(%o6)                            -------------
                                   a (a + 1)
(%i7) ev(%);

                                  2
                                 z        2 z
(%o7)                         --------- - --- + 1
                              a (a + 1)    a

Function: lambert_w (z)

The principal branch of Lambert's W funtion W(z), the solution of z = W(z) * exp(W(z)).

Function: nzeta (z)

The Plasma Dispersion Function nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))

Function: nzetar (z)

Returns realpart(nzeta(z)).

Function: nzetai (z)

Returns imagpart(nzeta(z)).

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

Lommel's little s[u,v](z) function. Probably Gradshteyn & Ryzhik 8.570.1.


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

This document was generated by Robert Dodier on April, 4 2011 using texi2html 1.76.