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

# 15. Special Functions

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

## 15.1 Introduction to Special Functions

Special function notation follows:

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

Categories:  Bessel functions · Airy functions · Special functions

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

## 15.2 Bessel Functions

Function: bessel_j (v, z)

The Bessel function of the first kind of order v and argument z.

`bessel_j` is defined as

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

although the infinite series is not used for computations.

Function: bessel_y (v, z)

The Bessel function of the second kind of order v and argument z.

`bessel_y` is defined as

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

when v is not an integer. When v is an integer n, the limit as v approaches n is taken.

Function: bessel_i (v, z)

The modified Bessel function of the first kind of order v and argument z.

`bessel_i` is defined as

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

although the infinite series is not used for computations.

Function: bessel_k (v, z)

The modified Bessel function of the second kind of order v and argument z.

`bessel_k` is defined as

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

when v is not an integer. If v is an integer n, then the limit as v approaches n is taken.

Function: hankel_1 (v, z)

The Hankel function of the first kind of order v and argument z (A&S 9.1.3). `hankel_1` is defined as

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

Maxima evaluates `hankel_1` numerically for a real order v and complex argument z in float precision. The numerical evaluation in bigfloat precision and for a complex order v is not supported.

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

Function: hankel_2 (v, z)

The Hankel function of the second kind of order v and argument z (A&S 9.1.4). `hankel_2` is defined as

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

Maxima evaluates `hankel_2` numerically for a real order v and complex argument z in float precision. The numerical evaluation in bigfloat precision and for a complex order v is not supported.

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

Option variable: besselexpand

Default value: `false`

Controls expansion of the Bessel functions when the order is half of an odd integer. In this case, the Bessel functions can be expanded in terms of other elementary functions. When `besselexpand` is `true`, the Bessel function is expanded.

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

Categories:  Special functions

Function: scaled_bessel_i (v, z)

The scaled modified Bessel function of the first kind of order v and argument z. That is, scaled_bessel_i(v,z) = exp(-abs(z))*bessel_i(v, z). This function is particularly useful for calculating bessel_i for large z, which is large. However, maxima does not otherwise know much about this function. For symbolic work, it is probably preferable to work with the expression `exp(-abs(z))*bessel_i(v, z)`.

Categories:  Bessel functions

Function: scaled_bessel_i0 (z)

Identical to `scaled_bessel_i(0,z)`.

Function: scaled_bessel_i1 (z)

Identical to `scaled_bessel_i(1,z)`.

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

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

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

## 15.3 Airy Functions

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

Categories:  Airy functions · Special functions

Function: airy_dai (x)

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

See `airy_ai`.

Categories:  Airy functions · Special functions

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

Categories:  Airy functions · Special functions

Function: airy_dbi (x)

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

See `airy_ai` and `airy_bi`.

Categories:  Airy functions · Special functions

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

## 15.4 Gamma and factorial Functions

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_greek (a, z)

The lower incomplete gamma function (A&S 6.5.2):

```                         z
/
[  a - 1   - t
gamma_greek(a, z) = I t      %e    dt
]
/
0
```

See also `gamma_incomplete` (upper incomplete gamma function).

Function: gamma_incomplete (a, z)

The incomplete upper gamma function A&S 6.5.3:

```                              inf
/
[     a - 1   - t
gamma_incomplete(a, z) = I    t      %e    dt
]
/
z
```

See also `gamma_expand` for controlling how `gamma_incomplete` is expressed in terms of elementary functions and `erfc`.

Also see the related functions `gamma_incomplete_regularized` and `gamma_incomplete_generalized`.

Function: gamma_incomplete_regularized (a, z)

The regularized incomplete upper gamma function A&S 6.5.1:

```gamma_incomplete_regularized(a, z) =
gamma_incomplete(a, z)
----------------------
gamma(a)
```

See also `gamma_expand` for controlling how `gamma_incomplete` is expressed in terms of elementary functions and `erfc`.

Also see `gamma_incomplete`.

Function: gamma_incomplete_generalized (a, z1, z1)

The generalized incomplete gamma function.

```gamma_incomplete_generalized(a, z1, z2) =
z2
/
[    a - 1   - t
I   t      %e    dt
]
/
z1
```

Also see `gamma_incomplete` and `gamma_incomplete_regularized`.

Option variable: gamma_expand

Default value: `false`

`gamma_expand` controls expansion of `gamma_incomplete`. When `gamma_expand` is `true`, `gamma_incomplete(v,z)` is expanded in terms of `z`, `exp(z)`, and `erfc(z)` when possible.

```(%i1) gamma_incomplete(2,z);
(%o1)                       gamma_incomplete(2, z)
(%i2) gamma_expand:true;
(%o2)                                true
(%i3) gamma_incomplete(2,z);
- z
(%o3)                            (z + 1) %e
(%i4) gamma_incomplete(3/2,z);
- z   sqrt(%pi) erfc(sqrt(z))
(%o4)               sqrt(z) %e    + -----------------------
2
```

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 the option variable `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_regularized(a, b, z) =
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)             .2865367499935403 %i - 0.122995963334684
(%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
```

Categories:  Expressions

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

## 15.5 Exponential Integrals

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

Categories:  Exponential Integrals

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

Categories:  Exponential Integrals

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

## 15.6 Error Function

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

Categories:  Special functions

Function: erfc (z)

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

`erfc(z) = 1-erf(z)`

Categories:  Special functions

Function: erfi (z)

The Imaginary Error Function.

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

Categories:  Special functions

Function: erf_generalized (z1,z2)

Generalized Error function Erf(z1,z2)

Categories:  Special functions

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

Categories:  Special functions

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

Categories:  Special functions

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

## 15.7 Struve Functions

The Struve functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 12.

Function: struve_h (v, z)

The Struve Function H of order v and argument z. (A&S 12.1.1)

Categories:  Special functions

Function: struve_l (v, z)

The Modified Struve Function L of order v and argument z. (A&S 12.2.1)

Categories:  Special functions

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

## 15.8 Hypergeometric Functions

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)

Categories:  Special functions

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

Whittaker W function. (A&S 13.1.33)

Categories:  Special functions

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

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

## 15.9 Parabolic Cylinder Functions

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

Function: parabolic_cylinder_d (v, z)

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

Categories:  Special functions

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

## 15.10 Functions and Variables for Special Functions

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\$

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

Categories:  Laplace transform

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 function W(z), the solution of `z = W(z) * exp(W(z))`. (DLMF 4.13)

Categories:  Special functions

Function: generalized_lambert_w (k, z)

The k-th branch of Lambert's W function W(z), the solution of `z = W(z) * exp(W(z))`. (DLMF 4.13)

The principal branch, denoted Wp(z) in DLMF, is `lambert_w(z) = generalized_lambert_w(0,z)`.

The other branch with real values, denoted Wm(z) in DLMF, is `generalized_lambert_w(-1,z)`.

Categories:  Special functions

Function: nzeta (z)

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

Categories:  Special functions

Function: nzetar (z)

Returns `realpart(nzeta(z))`.

Categories:  Special functions

Function: nzetai (z)

Returns `imagpart(nzeta(z))`.

Categories:  Special functions

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

This document was generated by Oliver Kullmann on May, 18 2013 using texi2html 1.76.