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

Functions and Variables for Special Functions
=============================================

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

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

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

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

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

 -- 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: 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).

 -- 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: 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 [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 maxpsifracnum. 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: 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.

     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.

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

     Examples:

          (%i1) assume (p > 0, a > 0);
          (%o1)                    [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