Modifier and Type  Method and Description 

static double[] 
I(double xnu,
double x,
int n)
Evaluates a sequence of modified Bessel functions of the first kind with
real order and real argument.

static double[] 
I(double x,
int n)
Evaluates a sequence of modified Bessel functions of the first kind with
integer order and real argument.

static double[] 
J(double xnu,
double x,
int n)
Evaluate a sequence of Bessel functions of the first kind with real order
and real positive argument.

static double[] 
J(double x,
int n)
Evaluates a sequence of Bessel functions of the first kind with integer
order and real argument.

static double[] 
K(double xnu,
double x,
int n)
Evaluates a sequence of modified Bessel functions of the third kind with
fractional order and real argument.

static double[] 
K(double x,
int n)
Evaluates a sequence of modified Bessel functions of the third kind with
integer order and real argument.

static double[] 
scaledK(double v,
double x,
int n)
Evaluate a sequence of exponentially scaled modified Bessel functions of
the third kind with fractional order and real argument.

static double[] 
Y(double xnu,
double x,
int n)
Evaluate a sequence of Bessel functions of the second kind with real
nonnegative order and real positive argument.

public static double[] I(double xnu, double x, int n)
Here, argument xnu
is represented by
in the above equation.
The input x must be nonnegative and less than or equal to log(b) (b is
the largest representable number). The argument = xnu
must satisfy .
This function is based on a code due to Cody (1983), which uses backward recursion.
xnu
 a double
representing the lowest order desired.
xnu
must be at least zero and less than 1x
 a double
representing the argument of the Bessel
functions to be evaluatedn
 is the int
order of the last element in the
sequencedouble
array of length n+1
containing
the values of the function through the series. Bessel.I[i]
contains the value of the Bessel function of order i+xnu.

I
public static double[] I(double x,
int n)
Evaluates a sequence of modified Bessel functions of the first kind with
integer order and real argument. The Bessel function is defined to be
The input x
must satisfy where b is the largest representable floatingpoint
number. The algorithm is based on a code due to Sookne (1973b), which
uses backward recursion.
 Parameters:
x
 a double
representing the argument of the Bessel
functions to be evaluatedn
 is the int
order of the last element in the
sequence
 Returns:
 a
double
array of length n+1
containing
the values of the function through the series. Bessel.I[i]
contains the value of the Bessel function of order i.

J
public static double[] J(double xnu,
double x,
int n)
Evaluate a sequence of Bessel functions of the first kind with real order
and real positive argument. The Bessel function , is defined to be
This code is based on the work of Gautschi (1964) and Skovgaard (1975).
It uses backward recursion.
 Parameters:
xnu
 a double
representing the lowest order desired.
xnu
must be at least zero and less than 1.x
 a double
representing the argument for which the
sequence of Bessel functions is to be evaluatedn
 an int
representing the order of the last element
in the sequence. If order is the highest order desired, set
n
to int
(order).
 Returns:
 a
double
array of length n+1
containing
the values of the function through the series. Bessel.J[I]
contains the value of the Bessel function of order I+v at x
for I=0 to n
.

J
public static double[] J(double x,
int n)
Evaluates a sequence of Bessel functions of the first kind with integer
order and real argument. The Bessel function , is defined to be
The algorithm is based on a code due to Sookne (1973b) that uses backward
recursion with strict error control.
 Parameters:
x
 a double
representing the argument for which the
sequence of Bessel functions is to be evaluatedn
 an int
which specifies the order of the last
element in the sequence
 Returns:
 a
double
array of length n+1
containing
the values of the function through the series. Bessel.J[i]
contains the value of the Bessel function of order i at x
for i=0 to n
.

K
public static double[] K(double xnu,
double x,
int n)
Evaluates a sequence of modified Bessel functions of the third kind with
fractional order and real argument. The Bessel function is defined to be
Currently, xnu
(represented by in
the above equation) is restricted to be less than one in absolute value.
A total of n values is stored in the result, K
.
K
,
K
, , K
.
This method is based on the work of Cody (1983).
 Parameters:
xnu
 a double
representing the fractional order of the
function. xnu
must be less than one in absolute value.x
 a double
representing the argument for which the
sequence of Bessel functions is to be evaluated.n
 an int
representing the order of the last element
in the sequence. If order is the highest order desired, set
n
to int(order).
 Returns:
 a
double
array of length n+1 containing the values
of the function through the series. Bessel.K[I] contains the value of the
Bessel function of order I+v at x
for I=0 to n
.

K
public static double[] K(double x,
int n)
Evaluates a sequence of modified Bessel functions of the third kind with
integer order and real argument. This function uses for and
. For the definition of , see above.
 Parameters:
x
 a double
representing the argument for which the
sequence of Bessel functions is to be evaluatedn
 an int
which specifies the order of the last
element in the sequence
 Returns:
 a
double
array of length n+1 containing the values
of the function through the series

scaledK
public static double[] scaledK(double v,
double x,
int n)
Evaluate a sequence of exponentially scaled modified Bessel functions of
the third kind with fractional order and real argument. This function
evaluates , for i=1,...,n where K
is the modified Bessel function of the third kind. Currently, v is
restricted to be less than 1 in absolute value. A total of
elements are returned in the array. This code
is particularly useful for calculating sequences for large x provided n =
x. (Overflow becomes a problem if .) n
must not be zero, and x must be greater than zero. must be less than 1. Also, when is
large compared with x, must not be so large
that
overflows. The code is based on work of Cody (1983).
 Parameters:
v
 a double
representing the fractional order of the
function. v
must be less than one in absolute value.x
 a double
representing the argument for which the
sequence of Bessel functions is to be evaluated.n
 an int
representing the order of the last element
in the sequence. If order is the highest order desired, set
n
to int(order).
 Returns:
 a
double
array of length n+1
containing
the values of the function through the series. If n
is
positive, Bessel.K[I]
contains
times the value of the Bessel function of order
I+v
at x
for I=0 to n
. If
n
is negative, Bessel.K[I]
contains
times the value of the Bessel function of order
vI
at x
for I=0 to n
.

Y
public static double[] Y(double xnu,
double x,
int n)
Evaluate a sequence of Bessel functions of the second kind with real
nonnegative order and real positive argument. The Bessel function
is defined to be
The variable xnu
(represented by in the above equation) must satisfy . If this condition is not met, then Y
is set to
NaN
. In addition, x
must be in where and . If , then the largest representable number is returned; and if
, then zero is returned.
The algorithm is based on work of Cody and others, (see Cody et al. 1976;
Cody 1969; NATS FUNPACK 1976). It uses a special series expansion for
small arguments. For moderate arguments, an analytic continuation in the
argument based on Taylor series with special rational minimax
approximations providing starting values is employed. An asymptotic
expansion is used for large arguments.
 Parameters:
xnu
 a double
representing the lowest order desired.
xnu
must be at least zero and less than 1x
 a double
representing the argument for which the
sequence of Bessel functions is to be evaluatedn
 an int
such that n+1
elements will be
evaluated in the sequence
 Returns:
 a
double
array of length n+1
containing
the values of the function through the series. Bessel.K[I]
contains the value of the Bessel function of order I+v at x
for I=0 to n
.
Copyright © 19702015 Rogue Wave Software
Built October 13 2015.