- publishing free software manuals
 GNU Octave Manual Version 3 by John W. Eaton, David Bateman, Søren HaubergPaperback (6"x9"), 568 pagesISBN 095461206XRRP £24.95 (\$39.95)

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

1. Normal return.
2. Input error, return `NaN`.
3. Overflow, return `Inf`.
4. Loss of significance by argument reduction results in less than half of machine accuracy.
5. Complete loss of significance by argument reduction, return `NaN`.
6. 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. If the optional argument opt is non-zero the value is multiplied by the scale factor given in the table below.

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

1. Normal return.
2. Input error, return `NaN`.
3. Overflow, return `Inf`.
4. Loss of significance by argument reduction results in less than half of machine accuracy.
5. Complete loss of significance by argument reduction, return `NaN`.
6. 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)
```

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

Mapping Function: erfc (z)
Computes the complementary error function, `1 - erf (z)`.

Mapping Function: erfinv (z)
Computes the inverse of the error function.

Mapping Function: gamma (z)
Computes the Gamma function,
```            infinity
/
gamma (z) = | t^(z-1) exp (-t) dt.
/
t=0
```

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.

Function File: L = legendre (n, X)

Computes the 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 is defined as

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

where P_n(x) is the Legendre polynomial of degree n

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

For example, `legendre(3,[-1.0 -0.9 -0.8])` returns a matrix of results corresponding to the following values,

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

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.

 ISBN 095461206X GNU Octave Manual Version 3 See the print edition