### 17.5 Special Functions

— Loadable Function: [j, ierr] = besselj (alpha, x, opt)
— Loadable Function: [y, ierr] = bessely (alpha, x, opt)
— Loadable Function: [i, ierr] = besseli (alpha, x, opt)
— Loadable Function: [k, ierr] = besselk (alpha, x, opt)
— Loadable Function: [h, ierr] = besselh (alpha, k, x, opt)

> Compute Bessel or Hankel functions of various kinds:

> `besselj`
>   Bessel functions of the first kind. If the argument opt is supplied, the result is multiplied by `exp(-abs(imag(x)))`.
> `bessely`
>   Bessel functions of the second kind. If the argument opt is supplied, the result is multiplied by `exp(-abs(imag(x)))`.
> `besseli`
>   Modified Bessel functions of the first kind. If the argument opt is supplied, the result is multiplied by `exp(-abs(real(x)))`.
> `besselk`
>   Modified Bessel functions of the second kind. If the argument opt is supplied, the result is multiplied by `exp(x)`.
> `besselh`
>   Compute Hankel functions of the first (k = 1) or second (k = 2) kind. If the argument opt is supplied, the result is multiplied by `exp (-I*`x`)` for k = 1 or `exp (I*`x`)` for k = 2.

> If alpha is a scalar, the result is the same size as x. If x is a scalar, the result is the same size as alpha. If alpha is a row vector and x is a column vector, the result is a matrix with `length (`x`)` rows and `length (`alpha`)` columns. Otherwise, alpha and x must conform and the result will be the same size.

> The value of alpha must be real. The value of x may be complex.

> If requested, ierr contains the following status information and is the same size as the result.

> 0. Normal return.
> 1. Input error, return `NaN`.
> 2. Overflow, return `Inf`.
> 3. Loss of significance by argument reduction results in less than half of machine accuracy.
> 4. Complete loss of significance by argument reduction, return `NaN`.
> 5. Error—no computation, algorithm termination condition not met, return `NaN`.

— Loadable Function: [a, ierr] = airy (k, z, opt)

> Compute Airy functions of the first and second kind, and their derivatives.

>                K   Function   Scale factor (if 'opt' is supplied)
>               ---  --------   ---------------------------------------
>                0   Ai (Z)     exp ((2/3) * Z * sqrt (Z))
>                1   dAi(Z)/dZ  exp ((2/3) * Z * sqrt (Z))
>                2   Bi (Z)     exp (-abs (real ((2/3) * Z *sqrt (Z))))
>                3   dBi(Z)/dZ  exp (-abs (real ((2/3) * Z *sqrt (Z))))

> The function call `airy (`z`)` is equivalent to `airy (0,` z`)`.

> The result is the same size as z.

> If requested, ierr contains the following status information and is the same size as the result.

> 0. Normal return.
> 1. Input error, return `NaN`.
> 2. Overflow, return `Inf`.
> 3. Loss of significance by argument reduction results in less than half of machine accuracy.
> 4. Complete loss of significance by argument reduction, return `NaN`.
> 5. Error—no computation, algorithm termination condition not met, return `NaN`.

— Mapping Function: beta (a, b)

> Return the Beta function,

>               beta (a, b) = gamma (a) * gamma (b) / gamma (a + b).

— Mapping Function: betainc (x, a, b)

> Return the incomplete Beta function,

>                                                     x
>                                                    /
>               betainc (x, a, b) = beta (a, b)^(-1) | t^(a-1) (1-t)^(b-1) dt.
>                                                    /
>                                                 t=0

> If x has more than one component, both a and b must be scalars. If x is a scalar, a and b must be of compatible dimensions.

— Mapping Function: betaln (a, b)

> Return the log of the Beta function,

>               betaln (a, b) = gammaln (a) + gammaln (b) - gammaln (a + b)

> See also: beta, betai, gammaln.

— Mapping Function: bincoeff (n, k)

> Return the binomial coefficient of n and k, defined as

>                /   \
>                | n |    n (n-1) (n-2) ... (n-k+1)
>                |   |  = -------------------------
>                | k |               k!
>                \   /

> For example,

>               bincoeff (5, 2)
>               => 10

— Mapping Function: erf (z)

> Computes the error function,

>                                        z
>                                       /
>               erf (z) = (2/sqrt (pi)) | e^(-t^2) dt
>                                       /
>                                    t=0

> See also: erfc, erfinv.

— Mapping Function: erfc (z)

> Computes the complementary error function, `1 - erf (`z`)`.

> See also: erf, erfinv.

— Mapping Function: erfinv (z)

> Computes the inverse of the error function.

> See also: erf, erfc.

— Mapping Function: gamma (z)

> Computes the Gamma function,

>                           infinity
>                           /
>               gamma (z) = | t^(z-1) exp (-t) dt.
>                           /
>                        t=0

> See also: gammai, lgamma.

— Mapping Function: gammainc (x, a)

> Compute the normalized incomplete gamma function,

>                                               x
>                                     1        /
>               gammainc (x, a) = ---------    | exp (-t) t^(a-1) dt
>                                 gamma (a)    /
>                                           t=0

> with the limiting value of 1 as x approaches infinity. The standard notation is P(a,x), e.g. Abramowitz and Stegun (6.5.1).

> If a is scalar, then `gammainc (`x`,` a`)` is returned for each element of x and vice versa.

> If neither x nor a is scalar, the sizes of x and a must agree, and gammainc is applied element-by-element.

> See also: gamma, lgamma.

— Function File: L = legendre (n, X)

> Legendre Function of degree n and order m where all values for m = 0..n are returned. n must be a scalar in the range [0..255]. The return value has one dimension more than x.

>               The Legendre Function of degree n and order m

>                m        m       2  m/2   d^m
>               P(x) = (-1) * (1-x  )    * ----  P (x)
>                n                         dx^m   n

>               with:
>               Legendre polynomial of degree n

>                         1     d^n   2    n
>               P (x) = ------ [----(x - 1)  ]
>                n      2^n n!  dx^n

>               legendre(3,[-1.0 -0.9 -0.8]) returns the matrix

>                x  |   -1.0   |   -0.9   |  -0.8
>               ------------------------------------
>               m=0 | -1.00000 | -0.47250 | -0.08000
>               m=1 |  0.00000 | -1.99420 | -1.98000
>               m=2 |  0.00000 | -2.56500 | -4.32000
>               m=3 |  0.00000 | -1.24229 | -3.24000

— Mapping Function: lgamma (x)
— Mapping Function: gammaln (x)

> Return the natural logarithm of the absolute value of the gamma function of x.

> See also: gamma, gammai.

— Function File: cross (x, y, dim)

> Computes the vector cross product of the two 3-dimensional vectors x and y.

>               cross ([1,1,0], [0,1,1])
>               => [ 1; -1; 1 ]

> If x and y are matrices, the cross product is applied along the first dimension with 3 elements. The optional argument dim is used to force the cross product to be calculated along the dimension defined by dim.

— Function File: commutation_matrix (m, n)

> Return the commutation matrix K(m,n) which is the unique m*n by m*n matrix such that K(m,n) * vec(A) = vec(A') for all m by n matrices A.

> If only one argument m is given, K(m,m) is returned.

> See Magnus and Neudecker (1988), Matrix differential calculus with applications in statistics and econometrics.

— Function File: duplication_matrix (n)

> Return the duplication matrix Dn which is the unique n^2 by n*(n+1)/2 matrix such that Dn vech (A) = vec (A) for all symmetric n by n matrices A.

> See Magnus and Neudecker (1988), Matrix differential calculus with applications in statistics and econometrics.