BesselJ (Commons MATH 3.5)

java.lang.Object
- org.apache.commons.math3.special.BesselJ

All Implemented Interfaces:

UnivariateFunction
```
public class BesselJ
extends java.lang.Object
implements UnivariateFunction
```
This class provides computation methods related to Bessel functions of the first kind. Detailed descriptions of these functions are available in Wikipedia, Abrabowitz and Stegun (Ch. 9-11), and DLMF (Ch. 10).
This implementation is based on the rjbesl Fortran routine at Netlib.

From the Fortran code:

This program is based on a program written by David J. Sookne (2) that computes values of the Bessel functions J or I of real argument and integer order. Modifications include the restriction of the computation to the J Bessel function of non-negative real argument, the extension of the computation to arbitrary positive order, and the elimination of most underflow.

References:
- "A Note on Backward Recurrence Algorithms," Olver, F. W. J., and Sookne, D. J., Math. Comp. 26, 1972, pp 941-947.
- "Bessel Functions of Real Argument and Integer Order," Sookne, D. J., NBS Jour. of Res. B. 77B, 1973, pp 125-132.
Since:

3.4

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BesselJ.BesselJResult
Encapsulates the results returned by rjBesl(double, double, int).

Nested Classes
Modifier and Type	Class and Description
`static class`	`BesselJ.BesselJResult` Encapsulates the results returned by `rjBesl(double, double, int)`.

Field Summary

Fields
Modifier and Type	Field and Description
`private static double`	`ENMTEN` Smallest ABS(X) such that X/4 does not underflow
`private static double`	`ENSIG` Decimal significance desired.
`private static double`	`ENTEN` 10.0^K, where K is the largest integer such that ENTEN is machine-representable in working precision
`private static double[]`	`FACT` First 25 factorials as doubles
`private double`	`order` Order of the function computed when `value(double)` is used
`private static double`	`PI2` -2 / pi
`private static double`	`RTNSIG` 10.0 ** (-K) for the smallest integer K such that K >= NSIG/4
`private static double`	`TOWPI1` first few significant digits of 2pi
`private static double`	`TWOPI` TOWPI1 + TWOPI2
`private static double`	`TWOPI2` 2pi - TWOPI1 to working precision
`private static double`	`X_MAX` Upper limit on the magnitude of x.
`private static double`	`X_MIN` Minimum acceptable value for x

Constructor Summary

Constructors
Constructor and Description

BesselJ(double order)
Create a new BesselJ with the given order.

Constructors
Constructor and Description
`BesselJ(double order)` Create a new BesselJ with the given order.

Method Summary

Methods
Modifier and Type	Method and Description
`static BesselJ.BesselJResult`	`rjBesl(double x, double alpha, int nb)` Calculates Bessel functions \(J_{n+alpha}(x)\) for non-negative argument x, and non-negative order n + alpha.
`double`	`value(double x)` Returns the value of the constructed Bessel function of the first kind, for the passed argument.
`static double`	`value(double order, double x)` Returns the first Bessel function, \(J_{order}(x)\).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PI2
```
private static final double PI2
```
    -2 / pi
    
    See Also:
    Constant Field Values
  - TOWPI1
```
private static final double TOWPI1
```
    first few significant digits of 2pi
    
    See Also:
    Constant Field Values
  - TWOPI2
```
private static final double TWOPI2
```
    2pi - TWOPI1 to working precision
    
    See Also:
    Constant Field Values
  - TWOPI
```
private static final double TWOPI
```
    TOWPI1 + TWOPI2
    
    See Also:
    Constant Field Values
  - ENTEN
```
private static final double ENTEN
```
    10.0^K, where K is the largest integer such that ENTEN is machine-representable in working precision
    
    See Also:
    Constant Field Values
  - ENSIG
```
private static final double ENSIG
```
    Decimal significance desired. Should be set to (INT(log_{10}(2) * (it)+1)). Setting NSIG lower will result in decreased accuracy while setting NSIG higher will increase CPU time without increasing accuracy. The truncation error is limited to a relative error of T=.5(10^(-NSIG)).
    
    See Also:
    Constant Field Values
  - RTNSIG
```
private static final double RTNSIG
```
    10.0 ** (-K) for the smallest integer K such that K >= NSIG/4
    
    See Also:
    Constant Field Values
  - ENMTEN
```
private static final double ENMTEN
```
    Smallest ABS(X) such that X/4 does not underflow
    
    See Also:
    Constant Field Values
  - X_MIN
```
private static final double X_MIN
```
    Minimum acceptable value for x
    
    See Also:
    Constant Field Values
  - X_MAX
```
private static final double X_MAX
```
    Upper limit on the magnitude of x. If abs(x) = n, then at least n iterations of the backward recursion will be executed. The value of 10.0 ** 4 is used on every machine.
    
    See Also:
    Constant Field Values
  - FACT
```
private static final double[] FACT
```
    First 25 factorials as doubles
  - order
```
private final double order
```
    Order of the function computed when value(double) is used
- Constructor Detail
  - BesselJ
```
public BesselJ(double order)
```
    Create a new BesselJ with the given order.
    
    Parameters:
    order - order of the function computed when using value(double).
- Method Detail
  - value
```
public double value(double x)
             throws MathIllegalArgumentException,
                    ConvergenceException
```
    Returns the value of the constructed Bessel function of the first kind, for the passed argument.
    
    Specified by:
    
    value in interface UnivariateFunction
    
    Parameters:
    x - Argument
    
    Returns:
    Value of the Bessel function at x
    
    Throws:
    
    MathIllegalArgumentException - if x is too large relative to order
    
    ConvergenceException - if the algorithm fails to converge
  - value
```
public static double value(double order,
           double x)
                    throws MathIllegalArgumentException,
                           ConvergenceException
```
    Returns the first Bessel function, \(J_{order}(x)\).
    
    Parameters:
    order - Order of the Bessel function
    x - Argument
    
    Returns:
    Value of the Bessel function of the first kind, \(J_{order}(x)\)
    
    Throws:
    
    MathIllegalArgumentException - if x is too large relative to order
    
    ConvergenceException - if the algorithm fails to converge
  - rjBesl
```
public static BesselJ.BesselJResult rjBesl(double x,
                           double alpha,
                           int nb)
```
    Calculates Bessel functions \(J_{n+alpha}(x)\) for non-negative argument x, and non-negative order n + alpha.
    Before using the output vector, the user should check that nVals = nb, i.e., all orders have been calculated to the desired accuracy. See BesselResult class javadoc for details on return values.
    
    Parameters:
    x - non-negative real argument for which J's are to be calculated
    alpha - fractional part of order for which J's or exponentially scaled J's (\(J\cdot e^{x}\)) are to be calculated. 0 <= alpha < 1.0.
    nb - integer number of functions to be calculated, nb > 0. The first function calculated is of order alpha, and the last is of order nb - 1 + alpha.
    
    Returns:
    BesselJResult a vector of the functions \(J_{alpha}(x)\) through \(J_{nb-1+alpha}(x)\), or the corresponding exponentially scaled functions and an integer output variable indicating possible errors

Class BesselJ

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI2

TOWPI1

TWOPI2

TWOPI

ENTEN

ENSIG

RTNSIG

ENMTEN

X_MIN

X_MAX

FACT

order

Constructor Detail

BesselJ

Method Detail

value

value

rjBesl