Go to the first, previous, next, last section, table of contents.

# Special Functions

## specint

hypgeo is a package for handling Laplace transforms of special functions. hyp is a package for handling generalized Hypergeometric functions.

specint attempts to compute the definite integral (over the range from zero to infinity) of an expression containing special functions. When the integrand contains a factor exp (-s t), the result is a Laplace transform.

The syntax is as follows:

specint (exp (-s*t) * expr, t);

where t is the variable of integration and expr is an expression containing special functions.

If specint cannot compute the integral, the return value may contain various Lisp symbols, including other-defint-to-follow-negtest, other-lt-exponential-to-follow, product-of-y-with-nofract-indices, etc.; this is a bug.

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
%he[n] (z)                     Hermite polynomial (Nota bene: he, not h. See A&S 22.5.18)
%p[u,v] (z)                    Legendre function
%q[u,v] (z)                    Legendre function, 2nd kind
hstruve[n] (z)                 Struve H function
lstruve[n] (z)                 Struve L function
%f[p,q] ([], [], expr)         Generalized Hypergeometric function
gamma()                        Gamma function
gammagreek(a,z)                Incomplete gamma function
gammaincomplete(a,z)           Tail of incomplete gamma 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
ei (z)                         Exponential integral (?)
kelliptic (z)                  Complete elliptic integral of the first kind (K)
%d [n] (z)                     Parabolic cylinder function

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

This is a work in progress. Some of the function names may change.

## Definitions for Special Functions

Function: airy (x)
The Airy function Ai. If the argument x is a number, the numerical value of airy (x) is returned. Otherwise, an unevaluated expression airy (x) is returned.

The Airy equation diff (y(x), x, 2) - x y(x) = 0 has two linearly independent solutions, named ai and bi. This equation is very popular as an approximation to more complicated problems in many mathematical physics settings.

load ("airy") loads the functions ai, bi, dai, and dbi.

The airy package contains routines to compute ai and bi and their derivatives dai and dbi. The result is a floating point number if the argument is a number, and an unevaluated expression otherwise.

An error occurs if the argument is large enough to cause an overflow in the exponentials, or a loss of accuracy in sin or cos. This makes the range of validity about -2800 to 10^38 for ai and dai, and -2800 to 25 for bi and dbi.

These derivative rules are known to Maxima:

• diff (ai(x), x) yields dai(x),
• diff (dai(x), x) yields x ai(x),
• diff (bi(x), x) yields dbi(x),
• diff (dbi(x), x) yields x bi(x).

Function values are computed from the convergent Taylor series for abs(x) < 3, and from the asymptotic expansions for x < -3 or x > 3 as needed. This results in only very minor numerical discrepancies at x = 3 and x = -3. For details, see Abramowitz and Stegun, Handbook of Mathematical Functions, Section 10.4 and Table 10.11.

ev (taylor (ai(x), x, 0, 9), infeval) yields a floating point Taylor expansions of the function ai. A similar expression can be constructed for bi.

Function: airy_ai (x)
The Airy function Ai, as defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 10.4.

The Airy equation diff (y(x), x, 2) - x y(x) = 0 has two linearly independent solutions, y = Ai(x) and y = Bi(x). The derivative diff (airy_ai(x), x) is airy_dai(x).

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

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, as defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 10.4, is the second solution of the Airy 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 airy_bi is returned when possible. In other cases the unevaluated expression is returned.

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.

Function: asympa
asympa is a package for asymptotic analysis. The package contains simplification functions for asymptotic analysis, including the "big O" and "little o" functions that are widely used in complexity analysis and numerical analysis.

load ("asympa") loads this package.

Function: bessel (z, a)
The Bessel function of the first kind.

This function is deprecated. Write bessel_j (z, a) instead.

Function: bessel_j (v, z)
The Bessel function of the first kind of order v and argument z.

bessel_j computes the array besselarray such that besselarray [i] = bessel_j [i + v - int(v)] (z) for i from zero to int(v).

bessel_j is defined as @example inf ==== k - v - 2 k v + 2 k \ (- 1) 2 z > -------------------------- / k! gamma(v + k + 1) ==== k = 0 @end example

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 computes the array besselarray such that besselarray [i] = bessel_y [i + v - int(v)] (z) for i from zero to int(v).

bessel_y is defined as @example cos(%pi v) bessel_j(v, z) - bessel_j(-v, z) ------------------------------------------- sin(%pi v) @end example

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 computes the array besselarray such that besselarray [i] = bessel_i [i + v - int(v)] (z) for i from zero to int(v).

bessel_i is defined as @example inf ==== - v - 2 k v + 2 k \ 2 z > ------------------- / k! gamma(v + k + 1) ==== k = 0 @end example

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 computes the array besselarray such that besselarray [i] = bessel_k [i + v - int(v)] (z) for i from zero to int(v).

bessel_k is defined as @example %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z)) ------------------------------------------------- 2 @end example

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

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);
2 z   sin(z)   cos(z)
(%o4)                sqrt(---) (------ - ------)
%pi      2       z
z

Function: j0 (x)
The Bessel function of the first kind of order 0.

This function is deprecated. Write bessel_j (0, x) instead.

Function: j1 (x)
The Bessel function of the first kind of order 1.

This function is deprecated. Write bessel_j (1, x) instead.

Function: jn (x, n)
The Bessel function of the first kind of order n.

This function is deprecated. Write bessel_j (n, x) instead.

Function: i0 (x)
The modified Bessel function of the first kind of order 0.

This function is deprecated. Write bessel_i (0, x) instead.

Function: i1 (x)
The modified Bessel function of the first kind of order 1.

This function is deprecated. Write bessel_i (1, x) instead.

Function: beta (x, y)
The beta function, defined as gamma(x) gamma(y)/gamma(x + y).

Function: gamma (x)
The gamma function.

See also makegamma.

The variable gammalim controls simplification of the gamma function.

The Euler-Mascheroni constant is %gamma.

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: intopois (a)
Converts a into a Poisson encoding.

Function: makefact (expr)
Transforms instances of binomial, gamma, and beta functions in expr into factorials.

See also makegamma.

Function: makegamma (expr)
Transforms instances of binomial, factorial, and beta functions in expr into gamma functions.

See also makefact.

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

Function: outofpois (a)
Converts a from Poisson encoding to general representation. If a is not in Poisson form, outofpois carries out the conversion, i.e., the return value is outofpois (intopois (a)). This function is thus a canonical simplifier for sums of powers of sine and cosine terms of a particular type.

Function: poisdiff (a, b)
Differentiates a with respect to b. b must occur only in the trig arguments or only in the coefficients.

Function: poisexpt (a, b)
Functionally identical to intopois (a^b). b must be a positive integer.

Function: poisint (a, b)
Integrates in a similarly restricted sense (to poisdiff). Non-periodic terms in b are dropped if b is in the trig arguments.

Option variable: poislim
Default value: 5

poislim determines the domain of the coefficients in the arguments of the trig functions. The initial value of 5 corresponds to the interval [-2^(5-1)+1,2^(5-1)], or [-15,16], but it can be set to [-2^(n-1)+1, 2^(n-1)].

Function: poismap (series, sinfn, cosfn)
will map the functions sinfn on the sine terms and cosfn on the cosine terms of the Poisson series given. sinfn and cosfn are functions of two arguments which are a coefficient and a trigonometric part of a term in series respectively.

Function: poisplus (a, b)
Is functionally identical to intopois (a + b).

Function: poissimp (a)
Converts a into a Poisson series for a in general representation.

Special symbol: poisson
The symbol /P/ follows the line label of Poisson series expressions.

Function: poissubst (a, b, c)
Substitutes a for b in c. c is a Poisson series.

(1) Where B is a variable u, v, w, x, y, or z, then a must be an expression linear in those variables (e.g., 6*u + 4*v).

(2) Where b is other than those variables, then a must also be free of those variables, and furthermore, free of sines or cosines.

poissubst (a, b, c, d, n) is a special type of substitution which operates on a and b as in type (1) above, but where d is a Poisson series, expands cos(d) and sin(d) to order n so as to provide the result of substituting a + d for b in c. The idea is that d is an expansion in terms of a small parameter. For example, poissubst (u, v, cos(v), %e, 3) yields cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6).

Function: poistimes (a, b)
Is functionally identical to intopois (a*b).

Function: poistrim ()
is a reserved function name which (if the user has defined it) gets applied during Poisson multiplication. It is a predicate function of 6 arguments which are the coefficients of the u, v, ..., z in a term. Terms for which poistrim is true (for the coefficients of that term) are eliminated during multiplication.

Function: printpois (a)
Prints a Poisson series in a readable format. In common with outofpois, it will convert a into a Poisson encoding first, if necessary.

Function: psi (x)
Function: psi [n](x)
The derivative of log (gamma (x)).

Maxima does not know how to compute a numerical value of psi. However, the function bfpsi in the bffac package can compute numerical values.

Go to the first, previous, next, last section, table of contents.