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

# Special Functions

## Introduction to 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.