Class 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
    • Field Summary

      Fields 
      Modifier and Type Field 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 Description
      BesselJ​(double order)
      Create a new BesselJ with the given order.
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method 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

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

      • 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