Class BesselJ

java.lang.Object
org.apache.commons.math3.special.BesselJ
All Implemented Interfaces:
UnivariateFunction

public class BesselJ extends 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
    Description
    static class 
    Encapsulates the results returned by rjBesl(double, double, int).
  • Field Summary

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

    Constructors
    Constructor
    Description
    BesselJ(double order)
    Create a new BesselJ with the given order.
  • Method Summary

    Modifier and Type
    Method
    Description
    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 Details

    • PI2

      private static final double PI2
      -2 / pi
      See Also:
    • TOWPI1

      private static final double TOWPI1
      first few significant digits of 2pi
      See Also:
    • TWOPI2

      private static final double TWOPI2
      2pi - TWOPI1 to working precision
      See Also:
    • TWOPI

      private static final double TWOPI
      TOWPI1 + TWOPI2
      See Also:
    • 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:
    • 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:
    • RTNSIG

      private static final double RTNSIG
      10.0 ** (-K) for the smallest integer K such that K >= NSIG/4
      See Also:
    • ENMTEN

      private static final double ENMTEN
      Smallest ABS(X) such that X/4 does not underflow
      See Also:
    • X_MIN

      private static final double X_MIN
      Minimum acceptable value for x
      See Also:
    • 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:
    • 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 Details

    • 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 Details

    • 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 invalid input: '<'= alpha invalid input: '<' 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