Bessel.h

Go to the documentation of this file.

#ifndef BESSEL_H
#define BESSEL_H


// ----------------------------------------------------------------------
//
// Bridge object between C++ code and the GSL Bessel functions
//
// ----------------------------------------------------------------------

#ifndef ZMENVIRONMENT_H
  #include "ZMutility/ZMenvironment.h"
#endif
#include <utility>
#include <vector>

ZM_BEGIN_NAMESPACE( zmsf )      /*  namespace zmsf  {  */

typedef std::vector<double> Dvector;
typedef std::pair<double,double> Dpair;


struct Bessel {

  static double J0( const double x );   // Evaluate the J0 function

  static Dpair J0Err( const double x ); 

  static double J1( const double x );   // Evaluate the J1 function

  static Dpair J1Err( const double x ); 

  static double Jn( const int n, const double x );

  static Dpair JnErr( const int n, const double x ); 

  static Dvector JnArray( const int nmin, const int nmax, const double x );

  static Dvector JnErrArray( const int nmin, const int nmax, const double x );

  static double Y0( const double x );   // Evaluate the Y0 function

  static Dpair Y0Err( const double x ); 

  static double Y1( const double x );   // Evaluate the Y1 function

  static Dpair Y1Err( const double x ); 

  static double Yn( const int n, const double x );

  static Dpair YnErr( const int n, const double x );

  static Dvector YnArray( const int nmin, const int nmax, const double x );

  static Dvector YnErrArray( const int nmin, const int nmax, const double x );

  static double I0( const double x );   // Evaluate the I0 function

  static Dpair I0Err( const double x ); 

  static double I1( const double x );   // Evaluate the I1 function

  static Dpair I1Err( const double x ); 

  static double In( const int n, const double x );

  static Dpair InErr( const int n, const double x ); 

  static Dvector InArray( const int nmin, const int nmax, const double x );

  static Dvector InErrArray( const int nmin, const int nmax, const double x );

  static double I0Scaled( const double x );     // Evaluate exp(-|x|)*I0(x)

  static Dpair I0ErrScaled( const double x ); 

  static double I1Scaled( const double x );     // Evaluate the scaled I1 function

  static Dpair I1ErrScaled( const double x ); 

  static double InScaled( const int n, const double x );

  static Dpair InErrScaled( const int n, const double x ); 

  static Dvector InArrayScaled( const int nmin, const int nmax, const double x );

  static Dvector InErrArrayScaled( const int nmin, const int nmax, const double x );

  static double K0( const double x );   // Evaluate the K0 function

  static Dpair K0Err( const double x ); 

  static double K1( const double x );   // Evaluate the K1 function

  static Dpair K1Err( const double x ); 

  static double Kn( const int n, const double x );

  static Dpair KnErr( const int n, const double x );

  static Dvector KnArray( const int nmin, const int nmax, const double x );

  static Dvector KnErrArray( const int nmin, const int nmax, const double x );

  static double K0Scaled( const double x );     // Evaluate exp(x)* K0 

  static Dpair K0ErrScaled( const double x ); 

  static double K1Scaled( const double x );     // Evaluate the scaled K1 function

  static Dpair K1ErrScaled( const double x ); 

  static double KnScaled( const int n, const double x );

  static Dpair KnErrScaled( const int n, const double x );

  static Dvector KnArrayScaled( const int nmin, const int nmax, const double x );

  static Dvector KnErrArrayScaled( const int nmin, const int nmax, const double x );

  static double RegularSphericalJ0( const double x );

  static Dpair RegularSphericalJ0Err( const double x ); 

  static double RegularSphericalJ1( const double x );

  static Dpair RegularSphericalJ1Err( const double x ); 

  static double RegularSphericalJ2( const double x );

  static Dpair RegularSphericalJ2Err( const double x ); 

  static double RegularSphericalJn( const int n, const double x );

  static Dpair RegularSphericalJnErr( const int n, const double x ); 

  static Dvector RegularSphericalJnArray( const int nmax, const double x );

  static Dvector RegularSphericalJnErrArray( const int nmax, const double x );

  static Dvector RegularSphericalJnSteedArray( const int nmax, const double x );

  static double IrregularSphericalY0( const double x );

  static Dpair IrregularSphericalY0Err( const double x ); 

  static double IrregularSphericalY1( const double x );

  static Dpair IrregularSphericalY1Err( const double x ); 

  static double IrregularSphericalY2( const double x );

  static Dpair IrregularSphericalY2Err( const double x ); 

  static double IrregularSphericalYn( const int n, const double x );

  static Dpair IrregularSphericalYnErr( const int n, const double x ); 

  static Dvector IrregularSphericalYnArray( const int nmax, const double x );

  static Dvector IrregularSphericalYnErrArray( const int nmax, const double x );

  static double RegularModifiedSphericalJ0( const double x );

  static Dpair RegularModifiedSphericalJ0Err( const double x ); 

  static double RegularModifiedSphericalJ1( const double x );

  static Dpair RegularModifiedSphericalJ1Err( const double x ); 

  static double RegularModifiedSphericalJ2( const double x );

  static Dpair RegularModifiedSphericalJ2Err( const double x ); 

  static double RegularModifiedSphericalJn( const int n, const double x );

  static Dpair RegularModifiedSphericalJnErr( const int n, const double x ); 

  static Dvector RegularModifiedSphericalJnArray( const int nmax, const double x );

  static Dvector RegularModifiedSphericalJnErrArray( const int nmax, const double x );

  static double IrregularModifiedSphericalY0( const double x );

  static Dpair IrregularModifiedSphericalY0Err( const double x ); 

  static double IrregularModifiedSphericalY1( const double x );

  static Dpair IrregularModifiedSphericalY1Err( const double x ); 

  static double IrregularModifiedSphericalY2( const double x );

  static Dpair IrregularModifiedSphericalY2Err( const double x ); 

  static double IrregularModifiedSphericalYn( const int n, const double x );

  static Dpair IrregularModifiedSphericalYnErr( const int n, const double x ); 

  static Dvector IrregularModifiedSphericalYnArray( const int nmax, const double x );

  static Dvector IrregularModifiedSphericalYnErrArray( const int nmax, const double x );

  static double Jnu( const double nu, const double x );

  static Dpair JnuErr( const double nu, const double x ); 

  static Dvector JnuArray( const double nu, Dvector x );

  static Dvector JnuErrArray( const double nu, Dvector x );

  static double Ynu( const double nu, const double x );

  static Dpair YnuErr( const double nu, const double x );

  static double Inu( const double nu, const double x );

  static Dpair InuErr( const double nu, const double x ); 

  static double InuScaled( const double nu, const double x );

  static Dpair InuErrScaled( const double nu, const double x ); 

  static double Knu( const double nu, const double x );

  static Dpair KnuErr( const double nu, const double x );

  static double lnKnu( const double nu, const double x );

  static Dpair lnKnuErr( const double nu, const double x );

  static double KnuScaled( const double nu, const double x );

  static Dpair KnuErrScaled( const double nu, const double x );

  static double J0Zero( const int n );

  static Dpair J0ZeroErr( const int n ); 

  static double J1Zero( const int n );

#ifdef NOT_THERE

  static Dpair J1ZeroErr( const int n );
#endif

  static double JnuZero( const double nu, const int n );

  static Dpair JnuZeroErr( const double nu, const int n ); 


//-----------------------------------------------

};  // Bessel

ZM_END_NAMESPACE( zmsf )        /*  }  // namespace zmsf  */

#endif  /* BESSEL_H */

---