JMSLTM Numerical Library 7.2.0
com.imsl.math

## Class Bessel

• ```public class Bessel
extends Object```
Collection of Bessel functions.
Example
• ### Method Summary

Methods
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.
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Method Detail

• #### I

```public 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. The Bessel function , is defined to be 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.

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 of the Bessel functions to be evaluated
`n` - 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+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 floating-point 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 v-I 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. ```
• ``` ```
``` ```
• ``` ```
``` ```
``` ```
``` Overview Package Class Tree Index Help JMSLTM Numerical Library 7.2.0 Prev Class Next Class Frames No Frames All Classes <!-- allClassesLink = document.getElementById("allclasses_navbar_bottom"); if(window==top) { allClassesLink.style.display = "block"; } else { allClassesLink.style.display = "none"; } //--> Summary:  Nested |  Field |  Constr |  Method Detail:  Field |  Constr |  Method Copyright © 1970-2015 Rogue Wave SoftwareBuilt October 13 2015. ```