The routines described in this section compute the Cylindrical Bessel functions J_n(x), Y_n(x), Modified cylindrical Bessel functions I_n(x), K_n(x), Spherical Bessel functions j_l(x), y_l(x), and Modified Spherical Bessel functions i_l(x), k_l(x).  For more information see Abramowitz & Stegun, Chapters 9 and 10.  The Bessel functions are defined in the header file gsl_sf_bessel.h.

Regular Cylindrical Bessel Functions
------------------------------------

 -- Function: double gsl_sf_bessel_J0 (double X)
 -- Function: int gsl_sf_bessel_J0_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular cylindrical Bessel function of zeroth order, J_0(x).

 -- Function: double gsl_sf_bessel_J1 (double X)
 -- Function: int gsl_sf_bessel_J1_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular cylindrical Bessel function of first order, J_1(x).

 -- Function: double gsl_sf_bessel_Jn (int N, double X)
 -- Function: int gsl_sf_bessel_Jn_e (int N, double X, gsl_sf_result * RESULT)
     These routines compute the regular cylindrical Bessel function of order N, J_n(x).

 -- Function: int gsl_sf_bessel_Jn_array (int NMIN, int NMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the regular cylindrical Bessel functions J_n(x) for n from NMIN to NMAX inclusive, storing the results in the array RESULT_ARRAY.  The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Irregular Cylindrical Bessel Functions
--------------------------------------

 -- Function: double gsl_sf_bessel_Y0 (double X)
 -- Function: int gsl_sf_bessel_Y0_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular cylindrical Bessel function of zeroth order, Y_0(x), for x>0.

 -- Function: double gsl_sf_bessel_Y1 (double X)
 -- Function: int gsl_sf_bessel_Y1_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular cylindrical Bessel function of first order, Y_1(x), for x>0.

 -- Function: double gsl_sf_bessel_Yn (int N, double X)
 -- Function: int gsl_sf_bessel_Yn_e (int N, double X, gsl_sf_result * RESULT)
     These routines compute the irregular cylindrical Bessel function of order N, Y_n(x), for x>0.

 -- Function: int gsl_sf_bessel_Yn_array (int NMIN, int NMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the irregular cylindrical Bessel functions Y_n(x) for n from NMIN to NMAX inclusive, storing the results in the array RESULT_ARRAY.  The domain of the function is x>0.  The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Regular Modified Cylindrical Bessel Functions
---------------------------------------------

 -- Function: double gsl_sf_bessel_I0 (double X)
 -- Function: int gsl_sf_bessel_I0_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular modified cylindrical Bessel function of zeroth order, I_0(x).

 -- Function: double gsl_sf_bessel_I1 (double X)
 -- Function: int gsl_sf_bessel_I1_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular modified cylindrical Bessel function of first order, I_1(x).

 -- Function: double gsl_sf_bessel_In (int N, double X)
 -- Function: int gsl_sf_bessel_In_e (int N, double X, gsl_sf_result * RESULT)
     These routines compute the regular modified cylindrical Bessel function of order N, I_n(x).

 -- Function: int gsl_sf_bessel_In_array (int NMIN, int NMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the regular modified cylindrical Bessel functions I_n(x) for n from NMIN to NMAX inclusive, storing the results in the array RESULT_ARRAY.  The start of the range NMIN must be positive or zero.  The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

 -- Function: double gsl_sf_bessel_I0_scaled (double X)
 -- Function: int gsl_sf_bessel_I0_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified cylindrical Bessel function of zeroth order \exp(-|x|) I_0(x).

 -- Function: double gsl_sf_bessel_I1_scaled (double X)
 -- Function: int gsl_sf_bessel_I1_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified cylindrical Bessel function of first order \exp(-|x|) I_1(x).

 -- Function: double gsl_sf_bessel_In_scaled (int N, double X)
 -- Function: int gsl_sf_bessel_In_scaled_e (int N, double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified cylindrical Bessel function of order N, \exp(-|x|) I_n(x)

 -- Function: int gsl_sf_bessel_In_scaled_array (int NMIN, int NMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the scaled regular cylindrical Bessel functions \exp(-|x|) I_n(x) for n from NMIN to NMAX inclusive, storing the results in the array RESULT_ARRAY. The start of the range NMIN must be positive or zero.  The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Irregular Modified Cylindrical Bessel Functions
-----------------------------------------------

 -- Function: double gsl_sf_bessel_K0 (double X)
 -- Function: int gsl_sf_bessel_K0_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular modified cylindrical Bessel function of zeroth order, K_0(x), for x > 0.

 -- Function: double gsl_sf_bessel_K1 (double X)
 -- Function: int gsl_sf_bessel_K1_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular modified cylindrical Bessel function of first order, K_1(x), for x > 0.

 -- Function: double gsl_sf_bessel_Kn (int N, double X)
 -- Function: int gsl_sf_bessel_Kn_e (int N, double X, gsl_sf_result * RESULT)
     These routines compute the irregular modified cylindrical Bessel function of order N, K_n(x), for x > 0.

 -- Function: int gsl_sf_bessel_Kn_array (int NMIN, int NMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the irregular modified cylindrical Bessel functions K_n(x) for n from NMIN to NMAX inclusive, storing the results in the array RESULT_ARRAY. The start of the range NMIN must be positive or zero. The domain of the function is x>0. The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

 -- Function: double gsl_sf_bessel_K0_scaled (double X)
 -- Function: int gsl_sf_bessel_K0_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified cylindrical Bessel function of zeroth order \exp(x) K_0(x) for x>0.

 -- Function: double gsl_sf_bessel_K1_scaled (double X)
 -- Function: int gsl_sf_bessel_K1_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified cylindrical Bessel function of first order \exp(x) K_1(x) for x>0.

 -- Function: double gsl_sf_bessel_Kn_scaled (int N, double X)
 -- Function: int gsl_sf_bessel_Kn_scaled_e (int N, double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified cylindrical Bessel function of order N, \exp(x) K_n(x), for x>0.

 -- Function: int gsl_sf_bessel_Kn_scaled_array (int NMIN, int NMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the scaled irregular cylindrical Bessel functions \exp(x) K_n(x) for n from NMIN to NMAX inclusive, storing the results in the array RESULT_ARRAY. The start of the range NMIN must be positive or zero.  The domain of the function is x>0. The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Regular Spherical Bessel Functions
----------------------------------

 -- Function: double gsl_sf_bessel_j0 (double X)
 -- Function: int gsl_sf_bessel_j0_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular spherical Bessel function of zeroth order, j_0(x) = \sin(x)/x.

 -- Function: double gsl_sf_bessel_j1 (double X)
 -- Function: int gsl_sf_bessel_j1_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular spherical Bessel function of first order, j_1(x) = (\sin(x)/x - \cos(x))/x.

 -- Function: double gsl_sf_bessel_j2 (double X)
 -- Function: int gsl_sf_bessel_j2_e (double X, gsl_sf_result * RESULT)
     These routines compute the regular spherical Bessel function of second order, j_2(x) = ((3/x^2 - 1)\sin(x) - 3\cos(x)/x)/x.

 -- Function: double gsl_sf_bessel_jl (int L, double X)
 -- Function: int gsl_sf_bessel_jl_e (int L, double X, gsl_sf_result * RESULT)
     These routines compute the regular spherical Bessel function of order L, j_l(x), for $l \geq 0$ l >= 0 and $x \geq 0$ x >= 0.

 -- Function: int gsl_sf_bessel_jl_array (int LMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the regular spherical Bessel functions j_l(x) for l from 0 to LMAX inclusive  for $lmax \geq 0$ lmax >= 0 and $x \geq 0$ x >= 0, storing the results in the array RESULT_ARRAY. The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

 -- Function: int gsl_sf_bessel_jl_steed_array (int LMAX, double X, double * RESULT_ARRAY)
     This routine uses Steed's method to compute the values of the regular spherical Bessel functions j_l(x) for l from 0 to LMAX inclusive for $lmax \geq 0$ lmax >= 0 and $x \geq 0$ x >= 0, storing the results in the array RESULT_ARRAY. The Steed/Barnett algorithm is described in Comp. Phys. Comm. 21, 297 (1981).  Steed's method is more stable than the recurrence used in the other functions but is also slower.

Irregular Spherical Bessel Functions
------------------------------------

 -- Function: double gsl_sf_bessel_y0 (double X)
 -- Function: int gsl_sf_bessel_y0_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular spherical Bessel function of zeroth order, y_0(x) = -\cos(x)/x.

 -- Function: double gsl_sf_bessel_y1 (double X)
 -- Function: int gsl_sf_bessel_y1_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular spherical Bessel function of first order, y_1(x) = -(\cos(x)/x + \sin(x))/x.

 -- Function: double gsl_sf_bessel_y2 (double X)
 -- Function: int gsl_sf_bessel_y2_e (double X, gsl_sf_result * RESULT)
     These routines compute the irregular spherical Bessel function of second order, y_2(x) = (-3/x^3 + 1/x)\cos(x) - (3/x^2)\sin(x).

 -- Function: double gsl_sf_bessel_yl (int L, double X)
 -- Function: int gsl_sf_bessel_yl_e (int L, double X, gsl_sf_result * RESULT)
     These routines compute the irregular spherical Bessel function of order L, y_l(x), for $l \geq 0$ l >= 0.

 -- Function: int gsl_sf_bessel_yl_array (int LMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the irregular spherical Bessel functions y_l(x) for l from 0 to LMAX inclusive  for $lmax \geq 0$ lmax >= 0, storing the results in the array RESULT_ARRAY. The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Regular Modified Spherical Bessel Functions
-------------------------------------------

The regular modified spherical Bessel functions i_l(x) are related to the modified Bessel functions of fractional order, $i_l(x) = \sqrt\pi/(2x) I_l+1/2(x)$ i_l(x) = \sqrt{\pi/(2x)} I_{l+1/2}(x)

 -- Function: double gsl_sf_bessel_i0_scaled (double X)
 -- Function: int gsl_sf_bessel_i0_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified spherical Bessel function of zeroth order, \exp(-|x|) i_0(x).

 -- Function: double gsl_sf_bessel_i1_scaled (double X)
 -- Function: int gsl_sf_bessel_i1_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified spherical Bessel function of first order, \exp(-|x|) i_1(x).

 -- Function: double gsl_sf_bessel_i2_scaled (double X)
 -- Function: int gsl_sf_bessel_i2_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified spherical Bessel function of second order,  \exp(-|x|) i_2(x)

 -- Function: double gsl_sf_bessel_il_scaled (int L, double X)
 -- Function: int gsl_sf_bessel_il_scaled_e (int L, double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified spherical Bessel function of order L,  \exp(-|x|) i_l(x)

 -- Function: int gsl_sf_bessel_il_scaled_array (int LMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the scaled regular modified cylindrical Bessel functions \exp(-|x|) i_l(x) for l from 0 to LMAX inclusive for $lmax \geq 0$ lmax >= 0, storing the results in the array RESULT_ARRAY. The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Irregular Modified Spherical Bessel Functions
---------------------------------------------

The irregular modified spherical Bessel functions k_l(x) are related to the irregular modified Bessel functions of fractional order, $k_l(x) = \sqrt\pi/(2x) K_l+1/2(x)$ k_l(x) = \sqrt{\pi/(2x)} K_{l+1/2}(x).

 -- Function: double gsl_sf_bessel_k0_scaled (double X)
 -- Function: int gsl_sf_bessel_k0_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified spherical Bessel function of zeroth order, \exp(x) k_0(x), for x>0.

 -- Function: double gsl_sf_bessel_k1_scaled (double X)
 -- Function: int gsl_sf_bessel_k1_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified spherical Bessel function of first order, \exp(x) k_1(x), for x>0.

 -- Function: double gsl_sf_bessel_k2_scaled (double X)
 -- Function: int gsl_sf_bessel_k2_scaled_e (double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified spherical Bessel function of second order, \exp(x) k_2(x), for x>0.

 -- Function: double gsl_sf_bessel_kl_scaled (int L, double X)
 -- Function: int gsl_sf_bessel_kl_scaled_e (int L, double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified spherical Bessel function of order L, \exp(x) k_l(x), for x>0.

 -- Function: int gsl_sf_bessel_kl_scaled_array (int LMAX, double X, double RESULT_ARRAY[])
     This routine computes the values of the scaled irregular modified spherical Bessel functions \exp(x) k_l(x) for l from 0 to LMAX inclusive for $lmax \geq 0$ lmax >= 0 and x>0, storing the results in the array RESULT_ARRAY. The values are computed using recurrence relations for efficiency, and therefore may differ slightly from the exact values.

Regular Bessel Function---Fractional Order
------------------------------------------

 -- Function: double gsl_sf_bessel_Jnu (double NU, double X)
 -- Function: int gsl_sf_bessel_Jnu_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the regular cylindrical Bessel function of fractional order \nu, J_\nu(x).

 -- Function: int gsl_sf_bessel_sequence_Jnu_e (double NU, gsl_mode_t MODE, size_t SIZE, double V[])
     This function computes the regular cylindrical Bessel function of fractional order \nu, J_\nu(x), evaluated at a series of x values.  The array V of length SIZE contains the x values.  They are assumed to be strictly ordered and positive. The array is over-written with the values of J_\nu(x_i).

Irregular Bessel Functions---Fractional Order
---------------------------------------------

 -- Function: double gsl_sf_bessel_Ynu (double NU, double X)
 -- Function: int gsl_sf_bessel_Ynu_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the irregular cylindrical Bessel function of fractional order \nu, Y_\nu(x).

Regular Modified Bessel Functions---Fractional Order
----------------------------------------------------

 -- Function: double gsl_sf_bessel_Inu (double NU, double X)
 -- Function: int gsl_sf_bessel_Inu_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the regular modified Bessel function of fractional order \nu, I_\nu(x) for x>0, \nu>0.

 -- Function: double gsl_sf_bessel_Inu_scaled (double NU, double X)
 -- Function: int gsl_sf_bessel_Inu_scaled_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the scaled regular modified Bessel function of fractional order \nu, \exp(-|x|)I_\nu(x) for x>0, \nu>0.

Irregular Modified Bessel Functions---Fractional Order
------------------------------------------------------

 -- Function: double gsl_sf_bessel_Knu (double NU, double X)
 -- Function: int gsl_sf_bessel_Knu_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the irregular modified Bessel function of fractional order \nu, K_\nu(x) for x>0, \nu>0.

 -- Function: double gsl_sf_bessel_lnKnu (double NU, double X)
 -- Function: int gsl_sf_bessel_lnKnu_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0.

 -- Function: double gsl_sf_bessel_Knu_scaled (double NU, double X)
 -- Function: int gsl_sf_bessel_Knu_scaled_e (double NU, double X, gsl_sf_result * RESULT)
     These routines compute the scaled irregular modified Bessel function of fractional order \nu, \exp(+|x|) K_\nu(x) for x>0, \nu>0.

Zeros of Regular Bessel Functions
---------------------------------

 -- Function: double gsl_sf_bessel_zero_J0 (unsigned int S)
 -- Function: int gsl_sf_bessel_zero_J0_e (unsigned int S, gsl_sf_result * RESULT)
     These routines compute the location of the S-th positive zero of the Bessel function J_0(x).

 -- Function: double gsl_sf_bessel_zero_J1 (unsigned int S)
 -- Function: int gsl_sf_bessel_zero_J1_e (unsigned int S, gsl_sf_result * RESULT)
     These routines compute the location of the S-th positive zero of the Bessel function J_1(x).

 -- Function: double gsl_sf_bessel_zero_Jnu (double NU, unsigned int S)
 -- Function: int gsl_sf_bessel_zero_Jnu_e (double NU, unsigned int S, gsl_sf_result * RESULT)
     These routines compute the location of the S-th positive zero of the Bessel function J_\nu(x).  The current implementation does not support negative values of NU.