Module: Numo::GSL::Sf

Defined in:

ext/numo/gsl/sf/gsl_sf.c

Defined Under Namespace

Classes: Mathieu

Class Method Summary

• .airy_Ai(x[,mode]) ⇒ DFloat

  These routines compute the Airy function Ai(x) with an accuracy specified by mode.

• .airy_Ai_deriv(x[,mode]) ⇒ DFloat

  These routines compute the Airy function derivative Ai’(x) with an accuracy specified by mode.

• .airy_Ai_deriv_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Airy function derivative Ai’(x) with an accuracy specified by mode.

• .airy_Ai_deriv_scaled(x[,mode]) ⇒ DFloat

  These routines compute the scaled Airy function derivative S_A(x) Ai’(x).

• .airy_Ai_deriv_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled Airy function derivative S_A(x) Ai’(x).

• .airy_Ai_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Airy function Ai(x) with an accuracy specified by mode.

• .airy_Ai_scaled(x[,mode]) ⇒ DFloat

  These routines compute a scaled version of the Airy function S_A(x) Ai(x).

• .airy_Ai_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute a scaled version of the Airy function S_A(x) Ai(x).

• .airy_Bi(x[,mode]) ⇒ DFloat

  These routines compute the Airy function Bi(x) with an accuracy specified by mode.

• .airy_Bi_deriv(x[,mode]) ⇒ DFloat

  These routines compute the Airy function derivative Bi’(x) with an accuracy specified by mode.

• .airy_Bi_deriv_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Airy function derivative Bi’(x) with an accuracy specified by mode.

• .airy_Bi_deriv_scaled(x[,mode]) ⇒ DFloat

  These routines compute the scaled Airy function derivative S_B(x) Bi’(x).

• .airy_Bi_deriv_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled Airy function derivative S_B(x) Bi’(x).

• .airy_Bi_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Airy function Bi(x) with an accuracy specified by mode.

• .airy_Bi_scaled(x[,mode]) ⇒ DFloat

  These routines compute a scaled version of the Airy function S_B(x) Bi(x).

• .airy_Bi_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute a scaled version of the Airy function S_B(x) Bi(x).

• .airy_zero_Ai(s) ⇒ DFloat

  These routines compute the location of the s-th zero of the Airy function Ai(x).

• .airy_zero_Ai_deriv(s) ⇒ DFloat

  These routines compute the location of the s-th zero of the Airy function derivative Ai’(x).

• .airy_zero_Ai_deriv_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th zero of the Airy function derivative Ai’(x).

• .airy_zero_Ai_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th zero of the Airy function Ai(x).

• .airy_zero_Bi(s) ⇒ DFloat

  These routines compute the location of the s-th zero of the Airy function Bi(x).

• .airy_zero_Bi_deriv(s) ⇒ DFloat

  These routines compute the location of the s-th zero of the Airy function derivative Bi’(x).

• .airy_zero_Bi_deriv_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th zero of the Airy function derivative Bi’(x).

• .airy_zero_Bi_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th zero of the Airy function Bi(x).

• .angle_restrict_pos(theta) ⇒ DFloat

  These routines force the angle theta to lie in the range [0, 2\pi).

• .angle_restrict_symm(theta) ⇒ DFloat

  These routines force the angle theta to lie in the range (-\pi,\pi].

• .atanint(x) ⇒ DFloat

  These routines compute the Arctangent integral, which is defined as $\hboxAtanInt(x) = \int_0^x dt \arctan(t)/t$ AtanInt(x) = \int_0^x dt \arctan(t)/t.

• .atanint_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Arctangent integral, which is defined as $\hboxAtanInt(x) = \int_0^x dt \arctan(t)/t$ AtanInt(x) = \int_0^x dt \arctan(t)/t.

• .bessel_I0(x) ⇒ DFloat

  These routines compute the regular modified cylindrical Bessel function of zeroth order, I_0(x).

• .bessel_I0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular modified cylindrical Bessel function of zeroth order, I_0(x).

• .bessel_I0_scaled(x) ⇒ DFloat

  These routines compute the scaled regular modified cylindrical Bessel function of zeroth order \exp(-

  x

  ) I_0(x).

• .bessel_i0_scaled(x) ⇒ DFloat

  These routines compute the scaled regular modified spherical Bessel function of zeroth order, \exp(-

  x

  ) i_0(x).

• .bessel_I0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified cylindrical Bessel function of zeroth order \exp(-

  x

  ) I_0(x).

• .bessel_i0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified spherical Bessel function of zeroth order, \exp(-

  x

  ) i_0(x).

• .bessel_I1(x) ⇒ DFloat

  These routines compute the regular modified cylindrical Bessel function of first order, I_1(x).

• .bessel_I1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular modified cylindrical Bessel function of first order, I_1(x).

• .bessel_I1_scaled(x) ⇒ DFloat

  These routines compute the scaled regular modified cylindrical Bessel function of first order \exp(-

  x

  ) I_1(x).

• .bessel_i1_scaled(x) ⇒ DFloat

  These routines compute the scaled regular modified spherical Bessel function of first order, \exp(-

  x

  ) i_1(x).

• .bessel_I1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified cylindrical Bessel function of first order \exp(-

  x

  ) I_1(x).

• .bessel_i1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified spherical Bessel function of first order, \exp(-

  x

  ) i_1(x).

• .bessel_i2_scaled(x) ⇒ DFloat

  These routines compute the scaled regular modified spherical Bessel function of second order, \exp(-

  x

  ) i_2(x) Exceptional Return Values: GSL_EUNDRFLW.

• .bessel_i2_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified spherical Bessel function of second order, \exp(-

  x

  ) i_2(x) Exceptional Return Values: GSL_EUNDRFLW.

• .bessel_il_scaled(l, x) ⇒ DFloat

  These routines compute the scaled regular modified spherical Bessel function of order l, \exp(-

  x

  ) i_l(x) Domain: l >= 0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW.

• .bessel_il_scaled_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  This routine computes the values of the scaled regular modified spherical 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.

• .bessel_il_scaled_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified spherical Bessel function of order l, \exp(-

  x

  ) i_l(x) Domain: l >= 0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW.

• .bessel_In(n, x) ⇒ DFloat

  These routines compute the regular modified cylindrical Bessel function of order n, I_n(x).

• .bessel_In_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_In_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular modified cylindrical Bessel function of order n, I_n(x).

• .bessel_In_scaled(n, x) ⇒ DFloat

  These routines compute the scaled regular modified cylindrical Bessel function of order n, \exp(-

  x

  ) I_n(x) Exceptional Return Values: GSL_EUNDRFLW.

• .bessel_In_scaled_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_In_scaled_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified cylindrical Bessel function of order n, \exp(-

  x

  ) I_n(x) Exceptional Return Values: GSL_EUNDRFLW.

• .bessel_Inu(nu, x) ⇒ DFloat

  These routines compute the regular modified Bessel function of fractional order \nu, I_\nu(x) for x>0, \nu>0.

• .bessel_Inu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular modified Bessel function of fractional order \nu, I_\nu(x) for x>0, \nu>0.

• .bessel_Inu_scaled(nu, x) ⇒ DFloat

  These routines compute the scaled regular modified Bessel function of fractional order \nu, \exp(-

  x

  )I_\nu(x) for x>0, \nu>0.

• .bessel_Inu_scaled_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled regular modified Bessel function of fractional order \nu, \exp(-

  x

  )I_\nu(x) for x>0, \nu>0.

• .bessel_J0(x) ⇒ DFloat

  These routines compute the regular cylindrical Bessel function of zeroth order, J_0(x).

• .bessel_j0(x) ⇒ DFloat

  These routines compute the regular spherical Bessel function of zeroth order, j_0(x) = \sin(x)/x.

• .bessel_J0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular cylindrical Bessel function of zeroth order, J_0(x).

• .bessel_j0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular spherical Bessel function of zeroth order, j_0(x) = \sin(x)/x.

• .bessel_J1(x) ⇒ DFloat

  These routines compute the regular cylindrical Bessel function of first order, J_1(x).

• .bessel_j1(x) ⇒ DFloat

  These routines compute the regular spherical Bessel function of first order, j_1(x) = (\sin(x)/x - \cos(x))/x.

• .bessel_J1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular cylindrical Bessel function of first order, J_1(x).

• .bessel_j1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular spherical Bessel function of first order, j_1(x) = (\sin(x)/x - \cos(x))/x.

• .bessel_j2(x) ⇒ DFloat

  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.

• .bessel_j2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  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.

• .bessel_jl(l, x) ⇒ DFloat

  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.

• .bessel_jl_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_jl_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  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.

• .bessel_jl_steed_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_Jn(n, x) ⇒ DFloat

  These routines compute the regular cylindrical Bessel function of order n, J_n(x).

• .bessel_Jn_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_Jn_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular cylindrical Bessel function of order n, J_n(x).

• .bessel_Jnu(nu, x) ⇒ DFloat

  These routines compute the regular cylindrical Bessel function of fractional order \nu, J_\nu(x).

• .bessel_Jnu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular cylindrical Bessel function of fractional order \nu, J_\nu(x).

• .bessel_K0(x) ⇒ DFloat

  These routines compute the irregular modified cylindrical Bessel function of zeroth order, K_0(x), for x > 0.

• .bessel_K0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular modified cylindrical Bessel function of zeroth order, K_0(x), for x > 0.

• .bessel_K0_scaled(x) ⇒ DFloat

  These routines compute the scaled irregular modified cylindrical Bessel function of zeroth order \exp(x) K_0(x) for x>0.

• .bessel_k0_scaled(x) ⇒ DFloat

  These routines compute the scaled irregular modified spherical Bessel function of zeroth order, \exp(x) k_0(x), for x>0.

• .bessel_K0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified cylindrical Bessel function of zeroth order \exp(x) K_0(x) for x>0.

• .bessel_k0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified spherical Bessel function of zeroth order, \exp(x) k_0(x), for x>0.

• .bessel_K1(x) ⇒ DFloat

  These routines compute the irregular modified cylindrical Bessel function of first order, K_1(x), for x > 0.

• .bessel_K1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular modified cylindrical Bessel function of first order, K_1(x), for x > 0.

• .bessel_K1_scaled(x) ⇒ DFloat

  These routines compute the scaled irregular modified cylindrical Bessel function of first order \exp(x) K_1(x) for x>0.

• .bessel_k1_scaled(x) ⇒ DFloat

  These routines compute the scaled irregular modified spherical Bessel function of first order, \exp(x) k_1(x), for x>0.

• .bessel_K1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified cylindrical Bessel function of first order \exp(x) K_1(x) for x>0.

• .bessel_k1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified spherical Bessel function of first order, \exp(x) k_1(x), for x>0.

• .bessel_k2_scaled(x) ⇒ DFloat

  These routines compute the scaled irregular modified spherical Bessel function of second order, \exp(x) k_2(x), for x>0.

• .bessel_k2_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified spherical Bessel function of second order, \exp(x) k_2(x), for x>0.

• .bessel_kl_scaled(l, x) ⇒ DFloat

  These routines compute the scaled irregular modified spherical Bessel function of order l, \exp(x) k_l(x), for x>0.

• .bessel_kl_scaled_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_kl_scaled_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified spherical Bessel function of order l, \exp(x) k_l(x), for x>0.

• .bessel_Kn(n, x) ⇒ DFloat

  These routines compute the irregular modified cylindrical Bessel function of order n, K_n(x), for x > 0.

• .bessel_Kn_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_Kn_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular modified cylindrical Bessel function of order n, K_n(x), for x > 0.

• .bessel_Kn_scaled(n, x) ⇒ DFloat

  These routines compute the scaled irregular modified cylindrical Bessel function of order n, \exp(x) K_n(x), for x>0.

• .bessel_Kn_scaled_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_Kn_scaled_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified cylindrical Bessel function of order n, \exp(x) K_n(x), for x>0.

• .bessel_Knu(nu, x) ⇒ DFloat

  These routines compute the irregular modified Bessel function of fractional order \nu, K_\nu(x) for x>0, \nu>0.

• .bessel_Knu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular modified Bessel function of fractional order \nu, K_\nu(x) for x>0, \nu>0.

• .bessel_Knu_scaled(nu, x) ⇒ DFloat

  These routines compute the scaled irregular modified Bessel function of fractional order \nu, \exp(+

  x

  ) K_\nu(x) for x>0, \nu>0.

• .bessel_Knu_scaled_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the scaled irregular modified Bessel function of fractional order \nu, \exp(+

  x

  ) K_\nu(x) for x>0, \nu>0.

• .bessel_lnKnu(nu, x) ⇒ DFloat

  These routines compute the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0.

• .bessel_lnKnu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0.

• .bessel_Y0(x) ⇒ DFloat

  These routines compute the irregular cylindrical Bessel function of zeroth order, Y_0(x), for x>0.

• .bessel_y0(x) ⇒ DFloat

  These routines compute the irregular spherical Bessel function of zeroth order, y_0(x) = -\cos(x)/x.

• .bessel_Y0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular cylindrical Bessel function of zeroth order, Y_0(x), for x>0.

• .bessel_y0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular spherical Bessel function of zeroth order, y_0(x) = -\cos(x)/x.

• .bessel_Y1(x) ⇒ DFloat

  These routines compute the irregular cylindrical Bessel function of first order, Y_1(x), for x>0.

• .bessel_y1(x) ⇒ DFloat

  These routines compute the irregular spherical Bessel function of first order, y_1(x) = -(\cos(x)/x + \sin(x))/x.

• .bessel_Y1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular cylindrical Bessel function of first order, Y_1(x), for x>0.

• .bessel_y1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular spherical Bessel function of first order, y_1(x) = -(\cos(x)/x + \sin(x))/x.

• .bessel_y2(x) ⇒ DFloat

  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).

• .bessel_y2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  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).

• .bessel_yl(l, x) ⇒ DFloat

  These routines compute the irregular spherical Bessel function of order l, y_l(x), for $l \geq 0$ l >= 0.

• .bessel_yl_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_yl_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular spherical Bessel function of order l, y_l(x), for $l \geq 0$ l >= 0.

• .bessel_Yn(n, x) ⇒ DFloat

  These routines compute the irregular cylindrical Bessel function of order n, Y_n(x), for x>0.

• .bessel_Yn_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

  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.

• .bessel_Yn_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular cylindrical Bessel function of order n, Y_n(x), for x>0.

• .bessel_Ynu(nu, x) ⇒ DFloat

  These routines compute the irregular cylindrical Bessel function of fractional order \nu, Y_\nu(x).

• .bessel_Ynu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular cylindrical Bessel function of fractional order \nu, Y_\nu(x).

• .bessel_zero_J0(s) ⇒ DFloat

  These routines compute the location of the s-th positive zero of the Bessel function J_0(x).

• .bessel_zero_J0_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th positive zero of the Bessel function J_0(x).

• .bessel_zero_J1(s) ⇒ DFloat

  These routines compute the location of the s-th positive zero of the Bessel function J_1(x).

• .bessel_zero_J1_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th positive zero of the Bessel function J_1(x).

• .bessel_zero_Jnu(nu, s) ⇒ DFloat

  These routines compute the location of the s-th positive zero of the Bessel function J_\nu(x).

• .bessel_zero_Jnu_e(nu, s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the location of the s-th positive zero of the Bessel function J_\nu(x).

• .beta(a, b) ⇒ DFloat

  These routines compute the Beta Function, B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b) subject to a and b not being negative integers.

• .beta_e(a, b) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Beta Function, B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b) subject to a and b not being negative integers.

• .beta_inc(a, b, x) ⇒ DFloat

  These routines compute the normalized incomplete Beta function I_x(a,b)=B_x(a,b)/B(a,b) where $B_x(a,b) = \int_0^x t^a-1 (1-t)^b-1 dt$ B_x(a,b) = \int_0^x t^[a-1] (1-t)^[b-1] dt for $0 \le x \le 1$ 0 <= x <= 1.

• .beta_inc_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the normalized incomplete Beta function I_x(a,b)=B_x(a,b)/B(a,b) where $B_x(a,b) = \int_0^x t^a-1 (1-t)^b-1 dt$ B_x(a,b) = \int_0^x t^[a-1] (1-t)^[b-1] dt for $0 \le x \le 1$ 0 <= x <= 1.

• .Chi(x) ⇒ DFloat

  These routines compute the integral $\hboxSf.Chi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t]$ Chi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t] , where \gamma_E is the Euler constant (available as the macro M_EULER).

• .Chi_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the integral $\hboxSf.Chi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t]$ Chi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t] , where \gamma_E is the Euler constant (available as the macro M_EULER).

• .choose(n, m) ⇒ Numo::DFloat

  These routines compute the combinatorial factor n choose m = n!/(m!(n-m)!) exceptions: GSL_EDOM, GSL_EOVRFLW.

• .choose_e(n, m) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the combinatorial factor n choose m = n!/(m!(n-m)!) exceptions: GSL_EDOM, GSL_EOVRFLW.

• .Ci(x) ⇒ DFloat

  These routines compute the Cosine integral $\hboxSf.Ci(x) = -\int_x^\infty dt \cos(t)/t$ Ci(x) = -\int_x^\infty dt \cos(t)/t for x > 0.

• .Ci_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Cosine integral $\hboxSf.Ci(x) = -\int_x^\infty dt \cos(t)/t$ Ci(x) = -\int_x^\infty dt \cos(t)/t for x > 0.

• .clausen(x) ⇒ DFloat

  These routines compute the Clausen integral Cl_2(x).

• .clausen_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Clausen integral Cl_2(x).

• .complex_cos_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the complex cosine, \cos(z_r + i z_i) storing the real and imaginary parts in czr, czi.

• .complex_dilog_e(r, theta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the full complex-valued dilogarithm for the complex argument z = r \exp(i \theta).

• .complex_log_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This routine computes the complex logarithm of z = z_r + i z_i.

• .complex_logsin_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the logarithm of the complex sine, \log(\sin(z_r + i z_i)) storing the real and imaginary parts in lszr, lszi.

• .complex_sin_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the complex sine, \sin(z_r + i z_i) storing the real and imaginary parts in szr, szi.

• .conicalP_0(lambda, x) ⇒ DFloat

  These routines compute the conical function $P^0+ i \lambda(x)$ P^0-1/2 + i \lambda for x > -1.

• .conicalP_0_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the conical function $P^0+ i \lambda(x)$ P^0-1/2 + i \lambda for x > -1.

• .conicalP_1(lambda, x) ⇒ DFloat

  These routines compute the conical function $P^1+ i \lambda(x)$ P^1-1/2 + i \lambda for x > -1.

• .conicalP_1_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the conical function $P^1+ i \lambda(x)$ P^1-1/2 + i \lambda for x > -1.

• .conicalP_cyl_reg(m, lambda, x) ⇒ Numo::DFloat

  These routines compute the Regular Cylindrical Conical Function $P^-m+ i \lambda(x)$ P^[-m]-1/2 + i \lambda for x > -1, $m \ge -1$ m >= -1.

• .conicalP_cyl_reg_e(m, lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Regular Cylindrical Conical Function $P^-m+ i \lambda(x)$ P^[-m]-1/2 + i \lambda for x > -1, $m \ge -1$ m >= -1.

• .conicalP_half(lambda, x) ⇒ DFloat

  These routines compute the irregular Spherical Conical Function $P^1/2+ i \lambda(x)$ P^[1/2]-1/2 + i \lambda for x > -1.

• .conicalP_half_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the irregular Spherical Conical Function $P^1/2+ i \lambda(x)$ P^[1/2]-1/2 + i \lambda for x > -1.

• .conicalP_mhalf(lambda, x) ⇒ DFloat

  These routines compute the regular Spherical Conical Function $P^-1/2+ i \lambda(x)$ P^[-1/2]-1/2 + i \lambda for x > -1.

• .conicalP_mhalf_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regular Spherical Conical Function $P^-1/2+ i \lambda(x)$ P^[-1/2]-1/2 + i \lambda for x > -1.

• .conicalP_sph_reg(l, lambda, x) ⇒ Numo::DFloat

  These routines compute the Regular Spherical Conical Function $P^-1/2-l+ i \lambda(x)$ P^[-1/2-l]-1/2 + i \lambda for x > -1, $l \ge -1$ l >= -1.

• .conicalP_sph_reg_e(l, lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Regular Spherical Conical Function $P^-1/2-l+ i \lambda(x)$ P^[-1/2-l]-1/2 + i \lambda for x > -1, $l \ge -1$ l >= -1.

• .cos(x) ⇒ DFloat

  These routines compute the cosine function \cos(x).

• .cos_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the cosine function \cos(x).

• .cos_err_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This routine computes the cosine of an angle x with an associated absolute error dx, $\cos(x \pm dx)$ \cos(x \pm dx).

• .coulomb_CL_array(Lmin, kmax, eta) ⇒ [Numo::DFloat, Numo::Int]

  This function computes the Coulomb wave function normalization constant C_L(\eta) for L = Lmin \dots Lmin + kmax, Lmin > -1.

• .coulomb_CL_e(L, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the Coulomb wave function normalization constant C_L(\eta) for L > -1.

• .coulomb_wave_F_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the Coulomb wave function F_L(\eta,x) for L = Lmin \dots Lmin + kmax, storing the results in fc_array.

• .coulomb_wave_FG_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the functions F_L(\eta,x), G_L(\eta,x) for L = Lmin \dots Lmin + kmax storing the results in fc_array and gc_array.

• .coulomb_wave_FG_e(eta, x, L_F, k) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the Coulomb wave functions F_L(\eta,x), $G_L-k(\eta,x)$ G_L-k and their derivatives F’L(\eta,x), $G’L-k(\eta,x)$ G’_L-k with respect to x.

• .coulomb_wave_FGp_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the functions F_L(\eta,x), G_L(\eta,x) and their derivatives F’_L(\eta,x), G’_L(\eta,x) for L = Lmin \dots Lmin + kmax storing the results in fc_array, gc_array, fcp_array and gcp_array.

• .coulomb_wave_sphF_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the Coulomb wave function divided by the argument F_L(\eta, x)/x for L = Lmin \dots Lmin + kmax, storing the results in fc_array.

• .coupling_3j(two_ja, two_jb, two_jc, two_ma, two_mb, two_mc) ⇒ Float

  These routines compute the Wigner 3-j coefficient,.

• .coupling_3j_e(two_ja, two_jb, two_jc, two_ma, two_mb, two_mc) ⇒ [Float, Float, Integer]

  These routines compute the Wigner 3-j coefficient,.

• .coupling_6j(two_ja, two_jb, two_jc, two_jd, two_je, two_jf) ⇒ Float

  These routines compute the Wigner 6-j coefficient,.

• .coupling_6j_e(two_ja, two_jb, two_jc, two_jd, two_je, two_jf) ⇒ [Float, Float, Integer]

  These routines compute the Wigner 6-j coefficient,.

• .coupling_9j(two_ja, two_jb, two_jc, two_jd, two_je, two_jf, two_jg, two_jh, two_ji) ⇒ Float

  These routines compute the Wigner 9-j coefficient,.

• .coupling_9j_e(two_ja, two_jb, two_jc, two_jd, two_je, two_jf, two_jg, two_jh, two_ji) ⇒ [Float, Float, Integer]

  These routines compute the Wigner 9-j coefficient,.

• .dawson(x) ⇒ DFloat

  These routines compute the value of Dawson’s integral for x.

• .dawson_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the value of Dawson’s integral for x.

• .debye_1(x) ⇒ DFloat

  These routines compute the first-order Debye function D_1(x) = (1/x) \int_0^x dt (t/(e^t - 1)).

• .debye_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the first-order Debye function D_1(x) = (1/x) \int_0^x dt (t/(e^t - 1)).

• .debye_2(x) ⇒ DFloat

  These routines compute the second-order Debye function D_2(x) = (2/x^2) \int_0^x dt (t^2/(e^t - 1)).

• .debye_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the second-order Debye function D_2(x) = (2/x^2) \int_0^x dt (t^2/(e^t - 1)).

• .debye_3(x) ⇒ DFloat

  These routines compute the third-order Debye function D_3(x) = (3/x^3) \int_0^x dt (t^3/(e^t - 1)).

• .debye_3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the third-order Debye function D_3(x) = (3/x^3) \int_0^x dt (t^3/(e^t - 1)).

• .debye_4(x) ⇒ DFloat

  These routines compute the fourth-order Debye function D_4(x) = (4/x^4) \int_0^x dt (t^4/(e^t - 1)).

• .debye_4_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the fourth-order Debye function D_4(x) = (4/x^4) \int_0^x dt (t^4/(e^t - 1)).

• .debye_5(x) ⇒ DFloat

  These routines compute the fifth-order Debye function D_5(x) = (5/x^5) \int_0^x dt (t^5/(e^t - 1)).

• .debye_5_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the fifth-order Debye function D_5(x) = (5/x^5) \int_0^x dt (t^5/(e^t - 1)).

• .debye_6(x) ⇒ DFloat

  These routines compute the sixth-order Debye function D_6(x) = (6/x^6) \int_0^x dt (t^6/(e^t - 1)).

• .debye_6_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the sixth-order Debye function D_6(x) = (6/x^6) \int_0^x dt (t^6/(e^t - 1)).

• .dilog(x) ⇒ DFloat

  These routines compute the dilogarithm for a real argument.

• .dilog_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the dilogarithm for a real argument.

• .doublefact(n) ⇒ DFloat

  These routines compute the double factorial n!! = n(n-2)(n-4) \dots.

• .doublefact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the double factorial n!! = n(n-2)(n-4) \dots.

• .ellint_D(phi, k, [mode]) ⇒ Numo::DFloat

  These functions compute the incomplete elliptic integral D(\phi,k) which is defined through the Carlson form RD(x,y,z) by the following relation,.

• .ellint_D_e(phi, k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions compute the incomplete elliptic integral D(\phi,k) which is defined through the Carlson form RD(x,y,z) by the following relation,.

• .ellint_E(phi, k, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral E(\phi,k) to the accuracy specified by the mode variable mode.

• .ellint_E_e(phi, k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral E(\phi,k) to the accuracy specified by the mode variable mode.

• .ellint_Ecomp(k[,mode]) ⇒ DFloat

  These routines compute the complete elliptic integral E(k) to the accuracy specified by the mode variable mode.

• .ellint_Ecomp_e(k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete elliptic integral E(k) to the accuracy specified by the mode variable mode.

• .ellint_F(phi, k, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral F(\phi,k) to the accuracy specified by the mode variable mode.

• .ellint_F_e(phi, k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral F(\phi,k) to the accuracy specified by the mode variable mode.

• .ellint_Kcomp(k[,mode]) ⇒ DFloat

  These routines compute the complete elliptic integral K(k) to the accuracy specified by the mode variable mode.

• .ellint_Kcomp_e(k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete elliptic integral K(k) to the accuracy specified by the mode variable mode.

• .ellint_P(phi, k, n, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral \Pi(\phi,k,n) to the accuracy specified by the mode variable mode.

• .ellint_P_e(phi, k, n, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral \Pi(\phi,k,n) to the accuracy specified by the mode variable mode.

• .ellint_Pcomp(k, n, [mode]) ⇒ Numo::DFloat

  These routines compute the complete elliptic integral \Pi(k,n) to the accuracy specified by the mode variable mode.

• .ellint_Pcomp_e(k, n, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete elliptic integral \Pi(k,n) to the accuracy specified by the mode variable mode.

• .ellint_RC(x, y, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral RC(x,y) to the accuracy specified by the mode variable mode.

• .ellint_RC_e(x, y, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral RC(x,y) to the accuracy specified by the mode variable mode.

• .ellint_RD(x, y, z, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral RD(x,y,z) to the accuracy specified by the mode variable mode.

• .ellint_RD_e(x, y, z, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral RD(x,y,z) to the accuracy specified by the mode variable mode.

• .ellint_RF(x, y, z, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral RF(x,y,z) to the accuracy specified by the mode variable mode.

• .ellint_RF_e(x, y, z, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral RF(x,y,z) to the accuracy specified by the mode variable mode.

• .ellint_RJ(x, y, z, p, [mode]) ⇒ Numo::DFloat

  These routines compute the incomplete elliptic integral RJ(x,y,z,p) to the accuracy specified by the mode variable mode.

• .ellint_RJ_e(x, y, z, p, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete elliptic integral RJ(x,y,z,p) to the accuracy specified by the mode variable mode.

• .elljac_e(u, m) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function computes the Jacobian elliptic functions sn(u

  m), cn(u

  m), dn(u

  m) by descending Landen transformations.

• .erf(x) ⇒ DFloat

  These routines compute the error function $\erf(x)$ erf(x), where $\erf(x) = (2/\sqrt\pi) \int_0^x dt \exp(-t^2)$ erf(x) = (2/\sqrt(\pi)) \int_0^x dt \exp(-t^2).

• .erf_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the error function $\erf(x)$ erf(x), where $\erf(x) = (2/\sqrt\pi) \int_0^x dt \exp(-t^2)$ erf(x) = (2/\sqrt(\pi)) \int_0^x dt \exp(-t^2).

• .erf_Q(x) ⇒ DFloat

  These routines compute the upper tail of the Gaussian probability function $Q(x) = (1/\sqrt2\pi) \int_x^\infty dt \exp(-t^2/2)$ Q(x) = (1/\sqrt[2\pi]) \int_x^\infty dt \exp(-t^2/2).

• .erf_Q_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the upper tail of the Gaussian probability function $Q(x) = (1/\sqrt2\pi) \int_x^\infty dt \exp(-t^2/2)$ Q(x) = (1/\sqrt[2\pi]) \int_x^\infty dt \exp(-t^2/2).

• .erf_Z(x) ⇒ DFloat

  These routines compute the Gaussian probability density function $Z(x) = (1/\sqrt2\pi) \exp(-x^2/2)$ Z(x) = (1/\sqrt[2\pi]) \exp(-x^2/2).

• .erf_Z_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Gaussian probability density function $Z(x) = (1/\sqrt2\pi) \exp(-x^2/2)$ Z(x) = (1/\sqrt[2\pi]) \exp(-x^2/2).

• .erfc(x) ⇒ DFloat

  These routines compute the complementary error function $\erfc(x) = 1 - \erf(x) = (2/\sqrt\pi) \int_x^\infty \exp(-t^2)$ erfc(x) = 1 - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2).

• .erfc_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complementary error function $\erfc(x) = 1 - \erf(x) = (2/\sqrt\pi) \int_x^\infty \exp(-t^2)$ erfc(x) = 1 - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2).

• .eta(s) ⇒ DFloat

  These routines compute the eta function \eta(s) for arbitrary s.

• .eta_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the eta function \eta(s) for arbitrary s.

• .eta_int(n) ⇒ DFloat

  These routines compute the eta function \eta(n) for integer n.

• .eta_int_e(n) ⇒ [Float, Float, Integer]

  These routines compute the eta function \eta(n) for integer n.

• .exp(x) ⇒ DFloat

  These routines provide an exponential function \exp(x) using GSL semantics and error checking.

• .exp_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines provide an exponential function \exp(x) using GSL semantics and error checking.

• .exp_e10_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

  This function computes the exponential \exp(x) using the gsl_sf_result_e10 type to return a result with extended range.

• .exp_err_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This function exponentiates x with an associated absolute error dx.

• .exp_err_e10_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

  This function exponentiates a quantity x with an associated absolute error dx using the gsl_sf_result_e10 type to return a result with extended range.

• .exp_mult(x, y) ⇒ DFloat

  These routines exponentiate x and multiply by the factor y to return the product y \exp(x).

• .exp_mult_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines exponentiate x and multiply by the factor y to return the product y \exp(x).

• .exp_mult_e10_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

  This function computes the product y \exp(x) using the gsl_sf_result_e10 type to return a result with extended numeric range.

• .exp_mult_err_e(x, dx, y, dy) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This routine computes the product y \exp(x) for the quantities x, y with associated absolute errors dx, dy.

• .exp_mult_err_e10_e(x, dx, y, dy) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

  This routine computes the product y \exp(x) for the quantities x, y with associated absolute errors dx, dy using the gsl_sf_result_e10 type to return a result with extended range.

• .expint_3(x) ⇒ DFloat

  These routines compute the third-order exponential integral $Ei_3(x) = \int_0^xdt \exp(-t^3)$ Ei_3(x) = \int_0^xdt \exp(-t^3) for $x \ge 0$ x >= 0.

• .expint_3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the third-order exponential integral $Ei_3(x) = \int_0^xdt \exp(-t^3)$ Ei_3(x) = \int_0^xdt \exp(-t^3) for $x \ge 0$ x >= 0.

• .expint_E1(x) ⇒ DFloat

  These routines compute the exponential integral E_1(x),.

• .expint_E1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the exponential integral E_1(x),.

• .expint_E2(x) ⇒ DFloat

  These routines compute the second-order exponential integral E_2(x),.

• .expint_E2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the second-order exponential integral E_2(x),.

• .expint_Ei(x) ⇒ DFloat

  These routines compute the exponential integral $\hboxEi(x)$ Ei(x),.

• .expint_Ei_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the exponential integral $\hboxEi(x)$ Ei(x),.

• .expint_En(n, x) ⇒ DFloat

  These routines compute the exponential integral E_n(x) of order n,.

• .expint_En_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the exponential integral E_n(x) of order n,.

• .expm1(x) ⇒ DFloat

  These routines compute the quantity \exp(x)-1 using an algorithm that is accurate for small x.

• .expm1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the quantity \exp(x)-1 using an algorithm that is accurate for small x.

• .exprel(x) ⇒ DFloat

  These routines compute the quantity (\exp(x)-1)/x using an algorithm that is accurate for small x.

• .exprel_2(x) ⇒ DFloat

  These routines compute the quantity 2(\exp(x)-1-x)/x^2 using an algorithm that is accurate for small x.

• .exprel_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the quantity 2(\exp(x)-1-x)/x^2 using an algorithm that is accurate for small x.

• .exprel_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the quantity (\exp(x)-1)/x using an algorithm that is accurate for small x.

• .exprel_n(n, x) ⇒ DFloat

  These routines compute the N-relative exponential, which is the n-th generalization of the functions gsl_sf_exprel and gsl_sf_exprel_2.

• .exprel_n_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the N-relative exponential, which is the n-th generalization of the functions gsl_sf_exprel and gsl_sf_exprel_2.

• .fact(n) ⇒ DFloat

  These routines compute the factorial n!.

• .fact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the factorial n!.

• .fermi_dirac_0(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral with an index of 0.

• .fermi_dirac_0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral with an index of 0.

• .fermi_dirac_1(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral with an index of 1, F_1(x) = \int_0^\infty dt (t /(\exp(t-x)+1)).

• .fermi_dirac_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral with an index of 1, F_1(x) = \int_0^\infty dt (t /(\exp(t-x)+1)).

• .fermi_dirac_2(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral with an index of 2, F_2(x) = (1/2) \int_0^\infty dt (t^2 /(\exp(t-x)+1)).

• .fermi_dirac_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral with an index of 2, F_2(x) = (1/2) \int_0^\infty dt (t^2 /(\exp(t-x)+1)).

• .fermi_dirac_3half(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral $F_3/2(x)$ F_3/2.

• .fermi_dirac_3half_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral $F_3/2(x)$ F_3/2.

• .fermi_dirac_half(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral $F_1/2(x)$ F_1/2.

• .fermi_dirac_half_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral $F_1/2(x)$ F_1/2.

• .fermi_dirac_inc_0(x, b) ⇒ DFloat

  These routines compute the incomplete Fermi-Dirac integral with an index of zero, $F_0(x,b) = \ln(1 + e^b-x) - (b-x)$ F_0(x,b) = \ln(1 + e^[b-x]) - (b-x).

• .fermi_dirac_inc_0_e(x, b) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the incomplete Fermi-Dirac integral with an index of zero, $F_0(x,b) = \ln(1 + e^b-x) - (b-x)$ F_0(x,b) = \ln(1 + e^[b-x]) - (b-x).

• .fermi_dirac_int(j, x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral with an integer index of j, F_j(x) = (1/\Gamma(j+1)) \int_0^\infty dt (t^j /(\exp(t-x)+1)).

• .fermi_dirac_int_e(j, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral with an integer index of j, F_j(x) = (1/\Gamma(j+1)) \int_0^\infty dt (t^j /(\exp(t-x)+1)).

• .fermi_dirac_m1(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral with an index of -1.

• .fermi_dirac_m1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral with an index of -1.

• .fermi_dirac_mhalf(x) ⇒ DFloat

  These routines compute the complete Fermi-Dirac integral $F_-1/2(x)$ F_-1/2.

• .fermi_dirac_mhalf_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complete Fermi-Dirac integral $F_-1/2(x)$ F_-1/2.

• .gamma(x) ⇒ DFloat

  These routines compute the Gamma function \Gamma(x), subject to x not being a negative integer or zero.

• .gamma_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Gamma function \Gamma(x), subject to x not being a negative integer or zero.

• .gamma_inc(a, x) ⇒ DFloat

  These functions compute the unnormalized incomplete Gamma Function $\Gamma(a,x) = \int_x^\infty dt\, t^(a-1) \exp(-t)$ \Gamma(a,x) = \int_x^\infty dt t^[a-1] \exp(-t) for a real and $x \ge 0$ x >= 0.

• .gamma_inc_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions compute the unnormalized incomplete Gamma Function $\Gamma(a,x) = \int_x^\infty dt\, t^(a-1) \exp(-t)$ \Gamma(a,x) = \int_x^\infty dt t^[a-1] \exp(-t) for a real and $x \ge 0$ x >= 0.

• .gamma_inc_P(a, x) ⇒ DFloat

  These routines compute the complementary normalized incomplete Gamma Function $P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt\, t^(a-1) \exp(-t)$ P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0.

• .gamma_inc_P_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the complementary normalized incomplete Gamma Function $P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt\, t^(a-1) \exp(-t)$ P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0.

• .gamma_inc_Q(a, x) ⇒ DFloat

  These routines compute the normalized incomplete Gamma Function $Q(a,x) = 1/\Gamma(a) \int_x^\infty dt\, t^(a-1) \exp(-t)$ Q(a,x) = 1/\Gamma(a) \int_x^\infty dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0.

• .gamma_inc_Q_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the normalized incomplete Gamma Function $Q(a,x) = 1/\Gamma(a) \int_x^\infty dt\, t^(a-1) \exp(-t)$ Q(a,x) = 1/\Gamma(a) \int_x^\infty dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0.

• .gammainv(x) ⇒ DFloat

  These routines compute the reciprocal of the gamma function, 1/\Gamma(x) using the real Lanczos method.

• .gammainv_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the reciprocal of the gamma function, 1/\Gamma(x) using the real Lanczos method.

• .gammastar(x) ⇒ DFloat

  These routines compute the regulated Gamma Function \Gamma^*(x) for x > 0.

• .gammastar_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the regulated Gamma Function \Gamma^*(x) for x > 0.

• .gegenpoly_1(lambda, x) ⇒ DFloat

  These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3.

• .gegenpoly_1_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3.

• .gegenpoly_2(lambda, x) ⇒ DFloat

  These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3.

• .gegenpoly_2_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3.

• .gegenpoly_3(lambda, x) ⇒ DFloat

  These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3.

• .gegenpoly_3_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3.

• .gegenpoly_array(nmax, lambda, x) ⇒ [Numo::DFloat, Numo::Int]

  This function computes an array of Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) for n = 0, 1, 2, \dots, nmax, subject to \lambda > -1/2, $nmax \ge 0$ nmax >= 0.

• .gegenpoly_n(n, lambda, x) ⇒ Numo::DFloat

  These functions evaluate the Gegenbauer polynomial $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) for a specific value of n, lambda, x subject to \lambda > -1/2, $n \ge 0$ n >= 0.

• .gegenpoly_n_e(n, lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Gegenbauer polynomial $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) for a specific value of n, lambda, x subject to \lambda > -1/2, $n \ge 0$ n >= 0.

• .hazard(x) ⇒ DFloat

  These routines compute the hazard function for the normal distribution.

• .hazard_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the hazard function for the normal distribution.

• .hydrogenicR(n, l, Z, r) ⇒ DFloat

  These routines compute the n-th normalized hydrogenic bound state radial wavefunction,.

• .hydrogenicR_1(Z, r) ⇒ DFloat

  These routines compute the lowest-order normalized hydrogenic bound state radial wavefunction $R_1 := 2Z \sqrtZ \exp(-Z r)$ R_1 := 2Z \sqrt[Z] \exp(-Z r).

• .hydrogenicR_1_e(Z, r) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the lowest-order normalized hydrogenic bound state radial wavefunction $R_1 := 2Z \sqrtZ \exp(-Z r)$ R_1 := 2Z \sqrt[Z] \exp(-Z r).

• .hydrogenicR_e(n, l, Z, r) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the n-th normalized hydrogenic bound state radial wavefunction,.

• .hyperg_0F1(c, x) ⇒ DFloat

  These routines compute the hypergeometric function ${}_0F_1(c,x)$ 0F1(c,x).

• .hyperg_0F1_e(c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the hypergeometric function ${}_0F_1(c,x)$ 0F1(c,x).

• .hyperg_1F1(a, b, x) ⇒ DFloat

  These routines compute the confluent hypergeometric function ${}_1F_1(a,b,x) = M(a,b,x)$ 1F1(a,b,x) = M(a,b,x) for general parameters a, b.

• .hyperg_1F1_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the confluent hypergeometric function ${}_1F_1(a,b,x) = M(a,b,x)$ 1F1(a,b,x) = M(a,b,x) for general parameters a, b.

• .hyperg_1F1_int(m, n, x) ⇒ Numo::DFloat

  These routines compute the confluent hypergeometric function ${}_1F_1(m,n,x) = M(m,n,x)$ 1F1(m,n,x) = M(m,n,x) for integer parameters m, n.

• .hyperg_1F1_int_e(m, n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the confluent hypergeometric function ${}_1F_1(m,n,x) = M(m,n,x)$ 1F1(m,n,x) = M(m,n,x) for integer parameters m, n.

• .hyperg_2F0(a, b, x) ⇒ DFloat

  These routines compute the hypergeometric function ${}_2F_0(a,b,x)$ 2F0(a,b,x).

• .hyperg_2F0_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the hypergeometric function ${}_2F_0(a,b,x)$ 2F0(a,b,x).

• .hyperg_2F1(a, b, c, x) ⇒ Numo::DFloat

  These routines compute the Gauss hypergeometric function ${}_2F_1(a,b,c,x) = F(a,b,c,x)$ 2F1(a,b,c,x) = F(a,b,c,x) for

  x

  < 1.

• .hyperg_2F1_conj(aR, aI, c, x) ⇒ Numo::DFloat

  These routines compute the Gauss hypergeometric function ${}_2F_1(a_R + i a_I, aR - i aI, c, x)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) with complex parameters for

  x

  < 1.

• .hyperg_2F1_conj_e(aR, aI, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Gauss hypergeometric function ${}_2F_1(a_R + i a_I, aR - i aI, c, x)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) with complex parameters for

  x

  < 1.

• .hyperg_2F1_conj_renorm(aR, aI, c, x) ⇒ Numo::DFloat

  These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c) for

  x

  < 1.

• .hyperg_2F1_conj_renorm_e(aR, aI, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c) for

  x

  < 1.

• .hyperg_2F1_e(a, b, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Gauss hypergeometric function ${}_2F_1(a,b,c,x) = F(a,b,c,x)$ 2F1(a,b,c,x) = F(a,b,c,x) for

  x

  < 1.

• .hyperg_2F1_renorm(a, b, c, x) ⇒ Numo::DFloat

  These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a,b,c,x) / \Gamma(c)$ 2F1(a,b,c,x) / \Gamma(c) for

  x

  < 1.

• .hyperg_2F1_renorm_e(a, b, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a,b,c,x) / \Gamma(c)$ 2F1(a,b,c,x) / \Gamma(c) for

  x

  < 1.

• .hyperg_U(a, b, x) ⇒ DFloat

  These routines compute the confluent hypergeometric function U(a,b,x).

• .hyperg_U_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the confluent hypergeometric function U(a,b,x).

• .hyperg_U_e10_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

  This routine computes the confluent hypergeometric function U(a,b,x) using the gsl_sf_result_e10 type to return a result with extended range.

• .hyperg_U_int(m, n, x) ⇒ Numo::DFloat

  These routines compute the confluent hypergeometric function U(m,n,x) for integer parameters m, n.

• .hyperg_U_int_e(m, n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the confluent hypergeometric function U(m,n,x) for integer parameters m, n.

• .hyperg_U_int_e10_e(m, n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

  This routine computes the confluent hypergeometric function U(m,n,x) for integer parameters m, n using the gsl_sf_result_e10 type to return a result with extended range.

• .hypot(x, y) ⇒ DFloat

  These routines compute the hypotenuse function $\sqrt+ y^2$ \sqrt[x^2 + y^2] avoiding overflow and underflow.

• .hypot_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the hypotenuse function $\sqrt+ y^2$ \sqrt[x^2 + y^2] avoiding overflow and underflow.

• .hzeta(s, q) ⇒ DFloat

  These routines compute the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.

• .hzeta_e(s, q) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.

• .laguerre_1(a, x) ⇒ DFloat

  These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.

• .laguerre_1_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.

• .laguerre_2(a, x) ⇒ DFloat

  These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.

• .laguerre_2_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.

• .laguerre_3(a, x) ⇒ DFloat

  These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.

• .laguerre_3_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.

• .laguerre_n(n, a, x) ⇒ Numo::DFloat

  These routines evaluate the generalized Laguerre polynomials L^a_n(x) for a > -1, $n \ge 0$ n >= 0.

• .laguerre_n_e(n, a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines evaluate the generalized Laguerre polynomials L^a_n(x) for a > -1, $n \ge 0$ n >= 0.

• .lambert_W0(x) ⇒ DFloat

  These compute the principal branch of the Lambert W function, W_0(x).

• .lambert_W0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These compute the principal branch of the Lambert W function, W_0(x).

• .lambert_Wm1(x) ⇒ DFloat

  These compute the secondary real-valued branch of the Lambert W function, $W_-1(x)$ W_-1.

• .lambert_Wm1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These compute the secondary real-valued branch of the Lambert W function, $W_-1(x)$ W_-1.

• .legendre_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre polynomials for 0 \le l \le lmax and 0 \le m \le l for $

  x

  \le 1$

  x

  <= 1.

• .legendre_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre polynomials for 0 \le l \le lmax and 0 \le m \le l for $

  x

  \le 1$

  x

  <= 1.

• .legendre_array_index(l, m) ⇒ Integer

  This function returns the index into result_array, result_deriv_array, or result_deriv2_array corresponding to P_l^m(x), P_l^‘m(x), or P_l^‘‘m(x).

• .legendre_array_n(lmax) ⇒ Integer

  This function returns the minimum array size for maximum degree lmax needed for the array versions of the associated Legendre functions.

• .legendre_deriv2_alt_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their (alternate) first and second derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv2_alt_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their (alternate) first and second derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv2_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their first and second derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv2_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their first and second derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv_alt_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their (alternate) first derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv_alt_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their (alternate) first derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their first derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_deriv_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions calculate all normalized associated Legendre functions and their first derivatives up to degree lmax for $

  x

  < 1$

  x

  < 1.

• .legendre_H3d(l, lambda, eta) ⇒ Numo::DFloat

  These routines compute the l-th radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space $\eta \ge 0$ \eta >= 0, $l \ge 0$ l >= 0.

• .legendre_H3d_0(lambda, eta) ⇒ DFloat

  These routines compute the zeroth radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_0(\lambda,\eta) := \over \lambda\sinh(\eta)$ L^[H3d]_0(\lambda,\eta) := \sin(\lambda\eta)/(\lambda\sinh(\eta)) for $\eta \ge 0$ \eta >= 0.

• .legendre_H3d_0_e(lambda, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the zeroth radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_0(\lambda,\eta) := \over \lambda\sinh(\eta)$ L^[H3d]_0(\lambda,\eta) := \sin(\lambda\eta)/(\lambda\sinh(\eta)) for $\eta \ge 0$ \eta >= 0.

• .legendre_H3d_1(lambda, eta) ⇒ DFloat

  These routines compute the first radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_1(\lambda,\eta) := + 1} \eta)\over \lambda \sinh(\eta)\right) \left(\coth(\eta) - \lambda \cot(\lambda\eta)\right)$ L^[H3d]_1(\lambda,\eta) := 1/\sqrt[\lambda^2 + 1] \sin(\lambda \eta)/(\lambda \sinh(\eta)) (\coth(\eta) - \lambda \cot(\lambda\eta)) for $\eta \ge 0$ \eta >= 0.

• .legendre_H3d_1_e(lambda, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the first radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_1(\lambda,\eta) := + 1} \eta)\over \lambda \sinh(\eta)\right) \left(\coth(\eta) - \lambda \cot(\lambda\eta)\right)$ L^[H3d]_1(\lambda,\eta) := 1/\sqrt[\lambda^2 + 1] \sin(\lambda \eta)/(\lambda \sinh(\eta)) (\coth(\eta) - \lambda \cot(\lambda\eta)) for $\eta \ge 0$ \eta >= 0.

• .legendre_H3d_array(lmax, lambda, eta) ⇒ [Numo::DFloat, Numo::Int]

  This function computes an array of radial eigenfunctions $L^H3d_l( \lambda, \eta)$ L^[H3d]_l(\lambda, \eta) for $0 \le l \le lmax$ 0 <= l <= lmax.

• .legendre_H3d_e(l, lambda, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the l-th radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space $\eta \ge 0$ \eta >= 0, $l \ge 0$ l >= 0.

• .legendre_P1(x) ⇒ DFloat

  These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3.

• .legendre_P1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3.

• .legendre_P2(x) ⇒ DFloat

  These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3.

• .legendre_P2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3.

• .legendre_P3(x) ⇒ DFloat

  These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3.

• .legendre_P3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3.

• .legendre_Pl(l, x) ⇒ DFloat

  These functions evaluate the Legendre polynomial $P_l(x)$ P_l(x) for a specific value of l, x subject to $l \ge 0$ l >= 0, $

  x

  \le 1$

  x

  <= 1 Exceptional Return Values: GSL_EDOM.

• .legendre_Pl_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

  These functions compute arrays of Legendre polynomials P_l(x) and derivatives dP_l(x)/dx, for l = 0, \dots, lmax, $

  x

  \le 1$

  x

  <= 1 Exceptional Return Values: GSL_EDOM.

• .legendre_Pl_deriv_array(lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions compute arrays of Legendre polynomials P_l(x) and derivatives dP_l(x)/dx, for l = 0, \dots, lmax, $

  x

  \le 1$

  x

  <= 1 Exceptional Return Values: GSL_EDOM.

• .legendre_Pl_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These functions evaluate the Legendre polynomial $P_l(x)$ P_l(x) for a specific value of l, x subject to $l \ge 0$ l >= 0, $

  x

  \le 1$

  x

  <= 1 Exceptional Return Values: GSL_EDOM.

• .legendre_Plm(l, m, x) ⇒ Numo::DFloat

  These routines compute the associated Legendre polynomial P_l^m(x) for $m \ge 0$ m >= 0, $l \ge m$ l >= m, $

  x

  \le 1$

  x

  <= 1.

• .legendre_Plm_e(l, m, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the associated Legendre polynomial P_l^m(x) for $m \ge 0$ m >= 0, $l \ge m$ l >= m, $

  x

  \le 1$

  x

  <= 1.

• .legendre_Q0(x) ⇒ DFloat

  These routines compute the Legendre function Q_0(x) for x > -1, $x \ne 1$ x != 1.

• .legendre_Q0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Legendre function Q_0(x) for x > -1, $x \ne 1$ x != 1.

• .legendre_Q1(x) ⇒ DFloat

  These routines compute the Legendre function Q_1(x) for x > -1, $x \ne 1$ x != 1.

• .legendre_Q1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Legendre function Q_1(x) for x > -1, $x \ne 1$ x != 1.

• .legendre_Ql(l, x) ⇒ DFloat

  These routines compute the Legendre function Q_l(x) for x > -1, $x \ne 1$ x != 1 and $l \ge 0$ l >= 0.

• .legendre_Ql_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Legendre function Q_l(x) for x > -1, $x \ne 1$ x != 1 and $l \ge 0$ l >= 0.

• .legendre_sphPlm(l, m, x) ⇒ Numo::DFloat

  These routines compute the normalized associated Legendre polynomial $\sqrt(2l+1)/(4\pi) \sqrt(l-m)!/(l+m)! P_l^m(x)$ \sqrt[(2l+1)/(4\pi)] \sqrt[(l-m)!/(l+m)!] P_l^m(x) suitable for use in spherical harmonics.

• .legendre_sphPlm_e(l, m, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the normalized associated Legendre polynomial $\sqrt(2l+1)/(4\pi) \sqrt(l-m)!/(l+m)! P_l^m(x)$ \sqrt[(2l+1)/(4\pi)] \sqrt[(l-m)!/(l+m)!] P_l^m(x) suitable for use in spherical harmonics.

• .lnbeta(a, b) ⇒ DFloat

  These routines compute the logarithm of the Beta Function, \log(B(a,b)) subject to a and b not being negative integers.

• .lnbeta_e(a, b) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the Beta Function, \log(B(a,b)) subject to a and b not being negative integers.

• .lnchoose(n, m) ⇒ Numo::DFloat

  These routines compute the logarithm of n choose m.

• .lnchoose_e(n, m) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of n choose m.

• .lncosh(x) ⇒ DFloat

  These routines compute \log(\cosh(x)) for any x.

• .lncosh_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute \log(\cosh(x)) for any x.

• .lndoublefact(n) ⇒ DFloat

  These routines compute the logarithm of the double factorial of n, \log(n!!).

• .lndoublefact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the double factorial of n, \log(n!!).

• .lnfact(n) ⇒ DFloat

  These routines compute the logarithm of the factorial of n, \log(n!).

• .lnfact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the factorial of n, \log(n!).

• .lngamma(x) ⇒ DFloat

  These routines compute the logarithm of the Gamma function, \log(\Gamma(x)), subject to x not being a negative integer or zero.

• .lngamma_complex_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This routine computes \log(\Gamma(z)) for complex z=z_r+i z_i and z not a negative integer or zero, using the complex Lanczos method.

• .lngamma_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the Gamma function, \log(\Gamma(x)), subject to x not being a negative integer or zero.

• .lngamma_sgn_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This routine computes the sign of the gamma function and the logarithm of its magnitude, subject to x not being a negative integer or zero.

• .lnpoch(a, x) ⇒ DFloat

  These routines compute the logarithm of the Pochhammer symbol, \log((a)_x) = \log(\Gamma(a + x)/\Gamma(a)).

• .lnpoch_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the Pochhammer symbol, \log((a)_x) = \log(\Gamma(a + x)/\Gamma(a)).

• .lnpoch_sgn_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the sign of the Pochhammer symbol and the logarithm of its magnitude.

• .lnsinh(x) ⇒ DFloat

  These routines compute \log(\sinh(x)) for x > 0.

• .lnsinh_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute \log(\sinh(x)) for x > 0.

• .log(x) ⇒ DFloat

  These routines compute the logarithm of x, \log(x), for x > 0.

• .log_1plusx(x) ⇒ DFloat

  These routines compute \log(1 + x) for x > -1 using an algorithm that is accurate for small x.

• .log_1plusx_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute \log(1 + x) for x > -1 using an algorithm that is accurate for small x.

• .log_1plusx_mx(x) ⇒ DFloat

  These routines compute \log(1 + x) - x for x > -1 using an algorithm that is accurate for small x.

• .log_1plusx_mx_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute \log(1 + x) - x for x > -1 using an algorithm that is accurate for small x.

• .log_abs(x) ⇒ DFloat

  These routines compute the logarithm of the magnitude of x, \log(

  x

  ), for x \ne 0.

• .log_abs_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the magnitude of x, \log(

  x

  ), for x \ne 0.

• .log_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of x, \log(x), for x > 0.

• .log_erfc(x) ⇒ DFloat

  These routines compute the logarithm of the complementary error function \log(\erfc(x)).

• .log_erfc_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the logarithm of the complementary error function \log(\erfc(x)).

• .mathieu_a(n, q) ⇒ Int

  These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_a_e(n, q) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_b(n, q) ⇒ Int

  These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_b_e(n, q) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_ce(n, q, x) ⇒ Int

  These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_ce_e(n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_Mc(j, n, q, x) ⇒ Numo::Int

  These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

• .mathieu_Mc_e(j, n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

• .mathieu_Ms(j, n, q, x) ⇒ Numo::Int

  These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

• .mathieu_Ms_e(j, n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

• .mathieu_se(n, q, x) ⇒ Int

  These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .mathieu_se_e(n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

• .multiply_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This function multiplies x and y storing the product and its associated error in result.

• .multiply_err_e(x, dx, y, dy) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This function multiplies x and y with associated absolute errors dx and dy.

• .poch(a, x) ⇒ DFloat

  These routines compute the Pochhammer symbol (a)_x = \Gamma(a + x)/\Gamma(a).

• .poch_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Pochhammer symbol (a)_x = \Gamma(a + x)/\Gamma(a).

• .pochrel(a, x) ⇒ DFloat

  These routines compute the relative Pochhammer symbol ((a)_x - 1)/x where (a)_x = \Gamma(a + x)/\Gamma(a).

• .pochrel_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the relative Pochhammer symbol ((a)_x - 1)/x where (a)_x = \Gamma(a + x)/\Gamma(a).

• .polar_to_rect(r, theta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function converts the polar coordinates (r,theta) to rectilinear coordinates (x,y), x = r\cos(\theta), y = r\sin(\theta).

• .pow_int(x, n) ⇒ DFloat

  These routines compute the power x^n for integer n.

• .pow_int_e(x, n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the power x^n for integer n.

• .psi(x) ⇒ DFloat

  These routines compute the digamma function \psi(x) for general x, x \ne 0.

• .psi_1(x) ⇒ DFloat

  These routines compute the Trigamma function \psi’(x) for general x.

• .psi_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Trigamma function \psi’(x) for general x.

• .psi_1_int(n) ⇒ DFloat

  These routines compute the Trigamma function \psi’(n) for positive integer n.

• .psi_1_int_e(n) ⇒ [Float, Float, Integer]

  These routines compute the Trigamma function \psi’(n) for positive integer n.

• .psi_1piy(y) ⇒ DFloat

  These routines compute the real part of the digamma function on the line 1+i y, \Re[\psi(1 + i y)].

• .psi_1piy_e(y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the real part of the digamma function on the line 1+i y, \Re[\psi(1 + i y)].

• .psi_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the digamma function \psi(x) for general x, x \ne 0.

• .psi_int(n) ⇒ DFloat

  These routines compute the digamma function \psi(n) for positive integer n.

• .psi_int_e(n) ⇒ [Float, Float, Integer]

  These routines compute the digamma function \psi(n) for positive integer n.

• .psi_n(n, x) ⇒ DFloat

  These routines compute the polygamma function $\psi^(n)(x)$ \psi^(n) for $n \ge 0$ n >= 0, x > 0.

• .psi_n_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the polygamma function $\psi^(n)(x)$ \psi^(n) for $n \ge 0$ n >= 0, x > 0.

• .rect_to_polar(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

  This function converts the rectilinear coordinates (x,y) to polar coordinates (r,theta), such that x = r\cos(\theta), y = r\sin(\theta).

• .Shi(x) ⇒ DFloat

  These routines compute the integral $\hboxSf.Shi(x) = \int_0^x dt \sinh(t)/t$ Shi(x) = \int_0^x dt \sinh(t)/t.

• .Shi_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the integral $\hboxSf.Shi(x) = \int_0^x dt \sinh(t)/t$ Shi(x) = \int_0^x dt \sinh(t)/t.

• .Si(x) ⇒ DFloat

  These routines compute the Sine integral $\hboxSf.Si(x) = \int_0^x dt \sin(t)/t$ Si(x) = \int_0^x dt \sin(t)/t.

• .Si_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Sine integral $\hboxSf.Si(x) = \int_0^x dt \sin(t)/t$ Si(x) = \int_0^x dt \sin(t)/t.

• .sin(x) ⇒ DFloat

  These routines compute the sine function \sin(x).

• .sin_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the sine function \sin(x).

• .sin_err_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  This routine computes the sine of an angle x with an associated absolute error dx, $\sin(x \pm dx)$ \sin(x \pm dx).

• .sinc(x) ⇒ DFloat

  These routines compute \sinc(x) = \sin(\pi x) / (\pi x) for any value of x.

• .sinc_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute \sinc(x) = \sin(\pi x) / (\pi x) for any value of x.

• .synchrotron_1(x) ⇒ DFloat

  These routines compute the first synchrotron function $x \int_x^\infty dt K_5/3(t)$ x \int_x^\infty dt K_5/3 for $x \ge 0$ x >= 0.

• .synchrotron_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the first synchrotron function $x \int_x^\infty dt K_5/3(t)$ x \int_x^\infty dt K_5/3 for $x \ge 0$ x >= 0.

• .synchrotron_2(x) ⇒ DFloat

  These routines compute the second synchrotron function $x K_2/3(x)$ x K_2/3 for $x \ge 0$ x >= 0.

• .synchrotron_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the second synchrotron function $x K_2/3(x)$ x K_2/3 for $x \ge 0$ x >= 0.

• .taylorcoeff(n, x) ⇒ DFloat

  These routines compute the Taylor coefficient x^n / n! for $x \ge 0$ x >= 0, $n \ge 0$ n >= 0.

• .taylorcoeff_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Taylor coefficient x^n / n! for $x \ge 0$ x >= 0, $n \ge 0$ n >= 0.

• .transport_2(x) ⇒ DFloat

  These routines compute the transport function J(2,x).

• .transport_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the transport function J(2,x).

• .transport_3(x) ⇒ DFloat

  These routines compute the transport function J(3,x).

• .transport_3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the transport function J(3,x).

• .transport_4(x) ⇒ DFloat

  These routines compute the transport function J(4,x).

• .transport_4_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the transport function J(4,x).

• .transport_5(x) ⇒ DFloat

  These routines compute the transport function J(5,x).

• .transport_5_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the transport function J(5,x).

• .zeta(s) ⇒ DFloat

  These routines compute the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.

• .zeta_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.

• .zeta_int(n) ⇒ DFloat

  These routines compute the Riemann zeta function \zeta(n) for integer n, n \ne 1.

• .zeta_int_e(n) ⇒ [Float, Float, Integer]

  These routines compute the Riemann zeta function \zeta(n) for integer n, n \ne 1.

• .zetam1(s) ⇒ DFloat

  These routines compute \zeta(s) - 1 for arbitrary s, s \ne 1.

• .zetam1_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

  These routines compute \zeta(s) - 1 for arbitrary s, s \ne 1.

• .zetam1_int(n) ⇒ DFloat

  These routines compute \zeta(n) - 1 for integer n, n \ne 1.

• .zetam1_int_e(n) ⇒ [Float, Float, Integer]

  These routines compute \zeta(n) - 1 for integer n, n \ne 1.

Class Method Details

.airy_Ai(x[,mode]) ⇒ DFloat

These routines compute the Airy function Ai(x) with an accuracy specified by mode.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17739

static VALUE
sf_s_airy_Ai(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Ai_deriv(x[,mode]) ⇒ DFloat

These routines compute the Airy function derivative Ai’(x) with an accuracy specified by mode.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18199

static VALUE
sf_s_airy_Ai_deriv(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_deriv, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Ai_deriv_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Airy function derivative Ai’(x) with an accuracy specified by mode.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18252

static VALUE
sf_s_airy_Ai_deriv_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_deriv_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Ai_deriv_scaled(x[,mode]) ⇒ DFloat

These routines compute the scaled Airy function derivative S_A(x) Ai’(x). For x>0 the scaling factor S_A(x) is $\exp(+(2/3) x^3/2)$ \exp(+(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18427

static VALUE
sf_s_airy_Ai_deriv_scaled(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_deriv_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Ai_deriv_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled Airy function derivative S_A(x) Ai’(x). For x>0 the scaling factor S_A(x) is $\exp(+(2/3) x^3/2)$ \exp(+(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18482

static VALUE
sf_s_airy_Ai_deriv_scaled_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_deriv_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Ai_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Airy function Ai(x) with an accuracy specified by mode.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17792

static VALUE
sf_s_airy_Ai_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Ai_scaled(x[,mode]) ⇒ DFloat

These routines compute a scaled version of the Airy function S_A(x) Ai(x). For x>0 the scaling factor S_A(x) is $\exp(+(2/3) x^3/2)$ \exp(+(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17968

static VALUE
sf_s_airy_Ai_scaled(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Ai_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute a scaled version of the Airy function S_A(x) Ai(x). For x>0 the scaling factor S_A(x) is $\exp(+(2/3) x^3/2)$ \exp(+(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18024

static VALUE
sf_s_airy_Ai_scaled_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Ai_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Bi(x[,mode]) ⇒ DFloat

These routines compute the Airy function Bi(x) with an accuracy specified by mode.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17852

static VALUE
sf_s_airy_Bi(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Bi_deriv(x[,mode]) ⇒ DFloat

These routines compute the Airy function derivative Bi’(x) with an accuracy specified by mode.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18312

static VALUE
sf_s_airy_Bi_deriv(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_deriv, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Bi_deriv_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Airy function derivative Bi’(x) with an accuracy specified by mode.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18365

static VALUE
sf_s_airy_Bi_deriv_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_deriv_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Bi_deriv_scaled(x[,mode]) ⇒ DFloat

These routines compute the scaled Airy function derivative S_B(x) Bi’(x). For x>0 the scaling factor S_B(x) is $\exp(-(2/3) x^3/2)$ exp(-(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18544

static VALUE
sf_s_airy_Bi_deriv_scaled(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_deriv_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Bi_deriv_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled Airy function derivative S_B(x) Bi’(x). For x>0 the scaling factor S_B(x) is $\exp(-(2/3) x^3/2)$ exp(-(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18599

static VALUE
sf_s_airy_Bi_deriv_scaled_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_deriv_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Bi_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Airy function Bi(x) with an accuracy specified by mode.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17905

static VALUE
sf_s_airy_Bi_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_Bi_scaled(x[,mode]) ⇒ DFloat

These routines compute a scaled version of the Airy function S_B(x) Bi(x). For x>0 the scaling factor S_B(x) is $\exp(-(2/3) x^3/2)$ exp(-(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18085

static VALUE
sf_s_airy_Bi_scaled(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.airy_Bi_scaled_e(x, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute a scaled version of the Airy function S_B(x) Bi(x). For x>0 the scaling factor S_B(x) is $\exp(-(2/3) x^3/2)$ exp(-(2/3) x^(3/2)), and is 1 for x<0.

Parameters:

• x (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18139

static VALUE
sf_s_airy_Bi_scaled_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_Bi_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.airy_zero_Ai(s) ⇒ DFloat

These routines compute the location of the s-th zero of the Airy function Ai(x).

Parameters:

• s (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18656

static VALUE
sf_s_airy_zero_Ai(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Ai, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.airy_zero_Ai_deriv(s) ⇒ DFloat

These routines compute the location of the s-th zero of the Airy function derivative Ai’(x).

Parameters:

• s (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18828

static VALUE
sf_s_airy_zero_Ai_deriv(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Ai_deriv, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.airy_zero_Ai_deriv_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the location of the s-th zero of the Airy function derivative Ai’(x).

Parameters:

• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18869

static VALUE
sf_s_airy_zero_Ai_deriv_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Ai_deriv_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.airy_zero_Ai_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the location of the s-th zero of the Airy function Ai(x).

Parameters:

• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18697

static VALUE
sf_s_airy_zero_Ai_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Ai_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.airy_zero_Bi(s) ⇒ DFloat

These routines compute the location of the s-th zero of the Airy function Bi(x).

Parameters:

• s (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18742

static VALUE
sf_s_airy_zero_Bi(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Bi, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.airy_zero_Bi_deriv(s) ⇒ DFloat

These routines compute the location of the s-th zero of the Airy function derivative Bi’(x).

Parameters:

• s (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18914

static VALUE
sf_s_airy_zero_Bi_deriv(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Bi_deriv, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.airy_zero_Bi_deriv_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the location of the s-th zero of the Airy function derivative Bi’(x).

Parameters:

• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18955

static VALUE
sf_s_airy_zero_Bi_deriv_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Bi_deriv_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.airy_zero_Bi_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the location of the s-th zero of the Airy function Bi(x).

Parameters:

• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 18783

static VALUE
sf_s_airy_zero_Bi_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_airy_zero_Bi_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.angle_restrict_pos(theta) ⇒ DFloat

These routines force the angle theta to lie in the range [0, 2\pi).

Note that the mathematical value of 2\pi is slightly greater than 2M_PI, so the machine number 2M_PI is included in the range.

Exceptional Return Values: GSL_ELOSS

Parameters:

• theta (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1306

static VALUE
sf_s_angle_restrict_pos(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_angle_restrict_pos, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.angle_restrict_symm(theta) ⇒ DFloat

These routines force the angle theta to lie in the range (-\pi,\pi].

Note that the mathematical value of \pi is slightly greater than M_PI, so the machine numbers M_PI and -M_PI are included in the range. Exceptional Return Values: GSL_ELOSS

Parameters:

• theta (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1261

static VALUE
sf_s_angle_restrict_symm(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_angle_restrict_symm, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.atanint(x) ⇒ DFloat

These routines compute the Arctangent integral, which is defined as $\hboxAtanInt(x) = \int_0^x dt \arctan(t)/t$ AtanInt(x) = \int_0^x dt \arctan(t)/t. Domain: Exceptional Return Values:

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6170

static VALUE
sf_s_atanint(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_atanint, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.atanint_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Arctangent integral, which is defined as $\hboxAtanInt(x) = \int_0^x dt \arctan(t)/t$ AtanInt(x) = \int_0^x dt \arctan(t)/t. Domain: Exceptional Return Values:

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6213

static VALUE
sf_s_atanint_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_atanint_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_I0(x) ⇒ DFloat

These routines compute the regular modified cylindrical Bessel function of zeroth order, I_0(x). Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12856

static VALUE
sf_s_bessel_I0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_I0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular modified cylindrical Bessel function of zeroth order, I_0(x). Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12898

static VALUE
sf_s_bessel_I0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_I0_scaled(x) ⇒ DFloat

These routines compute the scaled regular modified cylindrical Bessel function of zeroth order \exp(-|x|) I_0(x). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13205

static VALUE
sf_s_bessel_I0_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I0_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_i0_scaled(x) ⇒ DFloat

These routines compute the scaled regular modified spherical Bessel function of zeroth order, \exp(-|x|) i_0(x). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15200

static VALUE
sf_s_bessel_i0_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_i0_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_I0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified cylindrical Bessel function of zeroth order \exp(-|x|) I_0(x). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13247

static VALUE
sf_s_bessel_I0_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I0_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_i0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified spherical Bessel function of zeroth order, \exp(-|x|) i_0(x). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15242

static VALUE
sf_s_bessel_i0_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_i0_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_I1(x) ⇒ DFloat

These routines compute the regular modified cylindrical Bessel function of first order, I_1(x). Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12943

static VALUE
sf_s_bessel_I1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_I1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular modified cylindrical Bessel function of first order, I_1(x). Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12985

static VALUE
sf_s_bessel_I1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_I1_scaled(x) ⇒ DFloat

These routines compute the scaled regular modified cylindrical Bessel function of first order \exp(-|x|) I_1(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13292

static VALUE
sf_s_bessel_I1_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I1_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_i1_scaled(x) ⇒ DFloat

These routines compute the scaled regular modified spherical Bessel function of first order, \exp(-|x|) i_1(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15287

static VALUE
sf_s_bessel_i1_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_i1_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_I1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified cylindrical Bessel function of first order \exp(-|x|) I_1(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13334

static VALUE
sf_s_bessel_I1_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_I1_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_i1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified spherical Bessel function of first order, \exp(-|x|) i_1(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15329

static VALUE
sf_s_bessel_i1_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_i1_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_i2_scaled(x) ⇒ DFloat

These routines compute the scaled regular modified spherical Bessel function of second order, \exp(-|x|) i_2(x) Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15374

static VALUE
sf_s_bessel_i2_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_i2_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_i2_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified spherical Bessel function of second order, \exp(-|x|) i_2(x) Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15416

static VALUE
sf_s_bessel_i2_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_i2_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_il_scaled(l, x) ⇒ DFloat

These routines compute the scaled regular modified spherical Bessel function of order l, \exp(-|x|) i_l(x) Domain: l >= 0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15465

static VALUE
sf_s_bessel_il_scaled(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_il_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_il_scaled_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

This routine computes the values of the scaled regular modified spherical 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. Domain: lmax >= 0 Conditions: l=0,1,…,lmax Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15577

static VALUE
sf_s_bessel_il_scaled_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_il_scaled_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    if (c0<0) {
        rb_raise(rb_eArgError,"should be lmax>=0");
    }
    shape[0] = c0+1;
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_il_scaled_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified spherical Bessel function of order l, \exp(-|x|) i_l(x) Domain: l >= 0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15515

static VALUE
sf_s_bessel_il_scaled_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_il_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_In(n, x) ⇒ DFloat

These routines compute the regular modified cylindrical Bessel function of order n, I_n(x). Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13033

static VALUE
sf_s_bessel_In(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_In, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_In_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: nmin >=0, nmax >= nmin Conditions: n=nmin,…,nmax, nmin >=0, nmax >= nmin Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• nmin (Integer)
• nmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13148

static VALUE
sf_s_bessel_In_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_In_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //nmin
    c1 = NUM2INT(v1); opt[1] = &c1; //nmax
    
    if (c0<0 || c1<0 || c0>c1) {
        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
    }
    shape[0] = c1-c0+1;
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.bessel_In_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular modified cylindrical Bessel function of order n, I_n(x). Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13082

static VALUE
sf_s_bessel_In_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_In_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_In_scaled(n, x) ⇒ DFloat

These routines compute the scaled regular modified cylindrical Bessel function of order n, \exp(-|x|) I_n(x) Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13382

static VALUE
sf_s_bessel_In_scaled(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_In_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_In_scaled_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: nmin >=0, nmax >= nmin Conditions: n=nmin,…,nmax Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• nmin (Integer)
• nmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13497

static VALUE
sf_s_bessel_In_scaled_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_In_scaled_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //nmin
    c1 = NUM2INT(v1); opt[1] = &c1; //nmax
    
    if (c0<0 || c1<0 || c0>c1) {
        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
    }
    shape[0] = c1-c0+1;
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.bessel_In_scaled_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified cylindrical Bessel function of order n, \exp(-|x|) I_n(x) Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13431

static VALUE
sf_s_bessel_In_scaled_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_In_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Inu(nu, x) ⇒ DFloat

These routines compute the regular modified Bessel function of fractional order \nu, I_\nu(x) for x>0, \nu>0. Domain: x >= 0, nu >= 0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16259

static VALUE
sf_s_bessel_Inu(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Inu, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_Inu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular modified Bessel function of fractional order \nu, I_\nu(x) for x>0, \nu>0. Domain: x >= 0, nu >= 0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16306

static VALUE
sf_s_bessel_Inu_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Inu_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_Inu_scaled(nu, x) ⇒ DFloat

These routines compute the scaled regular modified Bessel function of fractional order \nu, \exp(-|x|)I_\nu(x) for x>0, \nu>0. \exp(-|x|) I_\nu Domain: x >= 0, nu >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16357

static VALUE
sf_s_bessel_Inu_scaled(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Inu_scaled, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_Inu_scaled_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled regular modified Bessel function of fractional order \nu, \exp(-|x|)I_\nu(x) for x>0, \nu>0. \exp(-|x|) I_\nu Domain: x >= 0, nu >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16405

static VALUE
sf_s_bessel_Inu_scaled_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Inu_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_J0(x) ⇒ DFloat

These routines compute the regular cylindrical Bessel function of zeroth order, J_0(x). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12163

static VALUE
sf_s_bessel_J0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_J0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_j0(x) ⇒ DFloat

These routines compute the regular spherical Bessel function of zeroth order, j_0(x) = \sin(x)/x. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14266

static VALUE
sf_s_bessel_j0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_j0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_J0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular cylindrical Bessel function of zeroth order, J_0(x). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12205

static VALUE
sf_s_bessel_J0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_J0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_j0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular spherical Bessel function of zeroth order, j_0(x) = \sin(x)/x. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14308

static VALUE
sf_s_bessel_j0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_j0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_J1(x) ⇒ DFloat

These routines compute the regular cylindrical Bessel function of first order, J_1(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12250

static VALUE
sf_s_bessel_J1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_J1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_j1(x) ⇒ DFloat

These routines compute the regular spherical Bessel function of first order, j_1(x) = (\sin(x)/x - \cos(x))/x. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14353

static VALUE
sf_s_bessel_j1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_j1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_J1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular cylindrical Bessel function of first order, J_1(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12292

static VALUE
sf_s_bessel_J1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_J1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_j1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular spherical Bessel function of first order, j_1(x) = (\sin(x)/x - \cos(x))/x. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14395

static VALUE
sf_s_bessel_j1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_j1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_j2(x) ⇒ DFloat

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. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14440

static VALUE
sf_s_bessel_j2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_j2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_j2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

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. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14482

static VALUE
sf_s_bessel_j2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_j2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_jl(l, x) ⇒ DFloat

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. Domain: l >= 0, x >= 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14533

static VALUE
sf_s_bessel_jl(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_jl, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_jl_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: lmax >= 0 Conditions: l=0,1,…,lmax Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14647

static VALUE
sf_s_bessel_jl_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_jl_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    if (c0<0) {
        rb_raise(rb_eArgError,"should be lmax>=0");
    }
    shape[0] = c0+1;
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_jl_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

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. Domain: l >= 0, x >= 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14585

static VALUE
sf_s_bessel_jl_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_jl_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_jl_steed_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: lmax >= 0 Conditions: l=0,1,…,lmax Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14716

static VALUE
sf_s_bessel_jl_steed_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_jl_steed_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    if (c0<0) {
        rb_raise(rb_eArgError,"should be lmax>=0");
    }
    shape[0] = c0+1;
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Jn(n, x) ⇒ DFloat

These routines compute the regular cylindrical Bessel function of order n, J_n(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12340

static VALUE
sf_s_bessel_Jn(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Jn, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_Jn_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• nmin (Integer)
• nmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12452

static VALUE
sf_s_bessel_Jn_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Jn_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //nmin
    c1 = NUM2INT(v1); opt[1] = &c1; //nmax
    
    if (c0<0 || c1<0 || c0>c1) {
        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
    }
    shape[0] = c1-c0+1;
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.bessel_Jn_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular cylindrical Bessel function of order n, J_n(x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12389

static VALUE
sf_s_bessel_Jn_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Jn_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Jnu(nu, x) ⇒ DFloat

These routines compute the regular cylindrical Bessel function of fractional order \nu, J_\nu(x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16071

static VALUE
sf_s_bessel_Jnu(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Jnu, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_Jnu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular cylindrical Bessel function of fractional order \nu, J_\nu(x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16116

static VALUE
sf_s_bessel_Jnu_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Jnu_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_K0(x) ⇒ DFloat

These routines compute the irregular modified cylindrical Bessel function of zeroth order, K_0(x), for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13555

static VALUE
sf_s_bessel_K0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_K0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular modified cylindrical Bessel function of zeroth order, K_0(x), for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13598

static VALUE
sf_s_bessel_K0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_K0_scaled(x) ⇒ DFloat

These routines compute the scaled irregular modified cylindrical Bessel function of zeroth order \exp(x) K_0(x) for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13911

static VALUE
sf_s_bessel_K0_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K0_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_k0_scaled(x) ⇒ DFloat

These routines compute the scaled irregular modified spherical Bessel function of zeroth order, \exp(x) k_0(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15632

static VALUE
sf_s_bessel_k0_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_k0_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_K0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified cylindrical Bessel function of zeroth order \exp(x) K_0(x) for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13954

static VALUE
sf_s_bessel_K0_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K0_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_k0_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified spherical Bessel function of zeroth order, \exp(x) k_0(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15675

static VALUE
sf_s_bessel_k0_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_k0_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_K1(x) ⇒ DFloat

These routines compute the irregular modified cylindrical Bessel function of first order, K_1(x), for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13644

static VALUE
sf_s_bessel_K1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_K1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular modified cylindrical Bessel function of first order, K_1(x), for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13687

static VALUE
sf_s_bessel_K1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_K1_scaled(x) ⇒ DFloat

These routines compute the scaled irregular modified cylindrical Bessel function of first order \exp(x) K_1(x) for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14000

static VALUE
sf_s_bessel_K1_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K1_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_k1_scaled(x) ⇒ DFloat

These routines compute the scaled irregular modified spherical Bessel function of first order, \exp(x) k_1(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15721

static VALUE
sf_s_bessel_k1_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_k1_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_K1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified cylindrical Bessel function of first order \exp(x) K_1(x) for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14043

static VALUE
sf_s_bessel_K1_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_K1_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_k1_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified spherical Bessel function of first order, \exp(x) k_1(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15764

static VALUE
sf_s_bessel_k1_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_k1_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_k2_scaled(x) ⇒ DFloat

These routines compute the scaled irregular modified spherical Bessel function of second order, \exp(x) k_2(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15810

static VALUE
sf_s_bessel_k2_scaled(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_k2_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_k2_scaled_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified spherical Bessel function of second order, \exp(x) k_2(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15853

static VALUE
sf_s_bessel_k2_scaled_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_k2_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_kl_scaled(l, x) ⇒ DFloat

These routines compute the scaled irregular modified spherical Bessel function of order l, \exp(x) k_l(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15902

static VALUE
sf_s_bessel_kl_scaled(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_kl_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_kl_scaled_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: lmax >= 0 Conditions: l=0,1,…,lmax Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16014

static VALUE
sf_s_bessel_kl_scaled_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_kl_scaled_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    if (c0<0) {
        rb_raise(rb_eArgError,"should be lmax>=0");
    }
    shape[0] = c0+1;
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_kl_scaled_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified spherical Bessel function of order l, \exp(x) k_l(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15952

static VALUE
sf_s_bessel_kl_scaled_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_kl_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Kn(n, x) ⇒ DFloat

These routines compute the irregular modified cylindrical Bessel function of order n, K_n(x), for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13736

static VALUE
sf_s_bessel_Kn(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Kn, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_Kn_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Conditions: n=nmin,…,nmax Domain: x > 0.0, nmin>=0, nmax >= nmin Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• nmin (Integer)
• nmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13853

static VALUE
sf_s_bessel_Kn_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Kn_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //nmin
    c1 = NUM2INT(v1); opt[1] = &c1; //nmax
    
    if (c0<0 || c1<0 || c0>c1) {
        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
    }
    shape[0] = c1-c0+1;
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.bessel_Kn_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular modified cylindrical Bessel function of order n, K_n(x), for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 13786

static VALUE
sf_s_bessel_Kn_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Kn_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Kn_scaled(n, x) ⇒ DFloat

These routines compute the scaled irregular modified cylindrical Bessel function of order n, \exp(x) K_n(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14092

static VALUE
sf_s_bessel_Kn_scaled(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Kn_scaled, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_Kn_scaled_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: x > 0.0, nmin >=0, nmax >= nmin Conditions: n=nmin,…,nmax Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• nmin (Integer)
• nmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14209

static VALUE
sf_s_bessel_Kn_scaled_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Kn_scaled_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //nmin
    c1 = NUM2INT(v1); opt[1] = &c1; //nmax
    
    if (c0<0 || c1<0 || c0>c1) {
        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
    }
    shape[0] = c1-c0+1;
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.bessel_Kn_scaled_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified cylindrical Bessel function of order n, \exp(x) K_n(x), for x>0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14142

static VALUE
sf_s_bessel_Kn_scaled_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Kn_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Knu(nu, x) ⇒ DFloat

These routines compute the irregular modified Bessel function of fractional order \nu, K_\nu(x) for x>0, \nu>0. Domain: x > 0, nu >= 0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16455

static VALUE
sf_s_bessel_Knu(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Knu, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_Knu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular modified Bessel function of fractional order \nu, K_\nu(x) for x>0, \nu>0. Domain: x > 0, nu >= 0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16502

static VALUE
sf_s_bessel_Knu_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Knu_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_Knu_scaled(nu, x) ⇒ DFloat

These routines compute the scaled irregular modified Bessel function of fractional order \nu, \exp(+|x|) K_\nu(x) for x>0, \nu>0. Domain: x > 0, nu >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16649

static VALUE
sf_s_bessel_Knu_scaled(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Knu_scaled, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_Knu_scaled_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the scaled irregular modified Bessel function of fractional order \nu, \exp(+|x|) K_\nu(x) for x>0, \nu>0. Domain: x > 0, nu >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16696

static VALUE
sf_s_bessel_Knu_scaled_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Knu_scaled_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_lnKnu(nu, x) ⇒ DFloat

These routines compute the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0. Domain: x > 0, nu >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16552

static VALUE
sf_s_bessel_lnKnu(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_lnKnu, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_lnKnu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0. Domain: x > 0, nu >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16599

static VALUE
sf_s_bessel_lnKnu_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_lnKnu_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_Y0(x) ⇒ DFloat

These routines compute the irregular cylindrical Bessel function of zeroth order, Y_0(x), for x>0. Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12509

static VALUE
sf_s_bessel_Y0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Y0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_y0(x) ⇒ DFloat

These routines compute the irregular spherical Bessel function of zeroth order, y_0(x) = -\cos(x)/x. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14770

static VALUE
sf_s_bessel_y0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_y0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_Y0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular cylindrical Bessel function of zeroth order, Y_0(x), for x>0. Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12551

static VALUE
sf_s_bessel_Y0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Y0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_y0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular spherical Bessel function of zeroth order, y_0(x) = -\cos(x)/x. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14812

static VALUE
sf_s_bessel_y0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_y0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_Y1(x) ⇒ DFloat

These routines compute the irregular cylindrical Bessel function of first order, Y_1(x), for x>0. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12596

static VALUE
sf_s_bessel_Y1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Y1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_y1(x) ⇒ DFloat

These routines compute the irregular spherical Bessel function of first order, y_1(x) = -(\cos(x)/x + \sin(x))/x. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14857

static VALUE
sf_s_bessel_y1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_y1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_Y1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular cylindrical Bessel function of first order, Y_1(x), for x>0. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12638

static VALUE
sf_s_bessel_Y1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Y1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_y1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular spherical Bessel function of first order, y_1(x) = -(\cos(x)/x + \sin(x))/x. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14899

static VALUE
sf_s_bessel_y1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_y1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_y2(x) ⇒ DFloat

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). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14944

static VALUE
sf_s_bessel_y2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_y2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_y2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

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). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 14986

static VALUE
sf_s_bessel_y2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_y2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_yl(l, x) ⇒ DFloat

These routines compute the irregular spherical Bessel function of order l, y_l(x), for $l \geq 0$ l >= 0. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15035

static VALUE
sf_s_bessel_yl(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_yl, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_yl_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Domain: lmax >= 0 Conditions: l=0,1,…,lmax Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15146

static VALUE
sf_s_bessel_yl_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_yl_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    if (c0<0) {
        rb_raise(rb_eArgError,"should be lmax>=0");
    }
    shape[0] = c0+1;
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_yl_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular spherical Bessel function of order l, y_l(x), for $l \geq 0$ l >= 0. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• l (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 15085

static VALUE
sf_s_bessel_yl_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_yl_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Yn(n, x) ⇒ DFloat

These routines compute the irregular cylindrical Bessel function of order n, Y_n(x), for x>0. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12686

static VALUE
sf_s_bessel_Yn(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Yn, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.bessel_Yn_array(nmin, nmax, x) ⇒ [Numo::DFloat, Numo::Int]

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. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• nmin (Integer)
• nmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12799

static VALUE
sf_s_bessel_Yn_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Yn_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //nmin
    c1 = NUM2INT(v1); opt[1] = &c1; //nmax
    
    if (c0<0 || c1<0 || c0>c1) {
        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
    }
    shape[0] = c1-c0+1;
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.bessel_Yn_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular cylindrical Bessel function of order n, Y_n(x), for x>0. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12735

static VALUE
sf_s_bessel_Yn_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Yn_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.bessel_Ynu(nu, x) ⇒ DFloat

These routines compute the irregular cylindrical Bessel function of fractional order \nu, Y_\nu(x). Exceptional Return Values:

Parameters:

• nu (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16164

static VALUE
sf_s_bessel_Ynu(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Ynu, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_Ynu_e(nu, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular cylindrical Bessel function of fractional order \nu, Y_\nu(x). Exceptional Return Values:

Parameters:

• nu (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16209

static VALUE
sf_s_bessel_Ynu_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_Ynu_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.bessel_zero_J0(s) ⇒ DFloat

These routines compute the location of the s-th positive zero of the Bessel function J_0(x). Exceptional Return Values:

Parameters:

• s (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16742

static VALUE
sf_s_bessel_zero_J0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_zero_J0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_zero_J0_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the location of the s-th positive zero of the Bessel function J_0(x). Exceptional Return Values:

Parameters:

• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16784

static VALUE
sf_s_bessel_zero_J0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_zero_J0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_zero_J1(s) ⇒ DFloat

These routines compute the location of the s-th positive zero of the Bessel function J_1(x). Exceptional Return Values:

Parameters:

• s (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16830

static VALUE
sf_s_bessel_zero_J1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_zero_J1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.bessel_zero_J1_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the location of the s-th positive zero of the Bessel function J_1(x). Exceptional Return Values:

Parameters:

• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16872

static VALUE
sf_s_bessel_zero_J1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_zero_J1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.bessel_zero_Jnu(nu, s) ⇒ DFloat

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. Exceptional Return Values:

Parameters:

• nu (DFloat)
• s (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16922

static VALUE
sf_s_bessel_zero_Jnu(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cUInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_zero_Jnu, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.bessel_zero_Jnu_e(nu, s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

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. Exceptional Return Values:

Parameters:

• nu (Numo::DFloat)
• s (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 16968

static VALUE
sf_s_bessel_zero_Jnu_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_bessel_zero_Jnu_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.beta(a, b) ⇒ DFloat

These routines compute the Beta Function, B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b) subject to a and b not being negative integers. exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• a (DFloat)
• b (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3244

static VALUE
sf_s_beta(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_beta, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.beta_e(a, b) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Beta Function, B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b) subject to a and b not being negative integers. exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3290

static VALUE
sf_s_beta_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_beta_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.beta_inc(a, b, x) ⇒ DFloat

These routines compute the normalized incomplete Beta function I_x(a,b)=B_x(a,b)/B(a,b) where $B_x(a,b) = \int_0^x t^a-1 (1-t)^b-1 dt$ B_x(a,b) = \int_0^x t^[a-1] (1-t)^[b-1] dt for $0 \le x \le 1$ 0 <= x <= 1. For a > 0, b > 0 the value is computed using a continued fraction expansion. For all other values it is computed using the relation $I_x(a,b,x) = (1/a) x^a {}_2F_1(a,1-b,a+1,x)/B(a,b)$ I_x(a,b,x) = (1/a) x^a 2F1(a,1-b,a+1,x)/B(a,b).

Parameters:

• a (DFloat)
• b (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3441

static VALUE
sf_s_beta_inc(VALUE mod, VALUE v0, VALUE v1, VALUE v2)
{
    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_beta_inc, STRIDE_LOOP|NDF_EXTRACT, 3,1, ain,aout};

    return na_ndloop(&ndf, 3, v0, v1, v2);
}

.beta_inc_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the normalized incomplete Beta function I_x(a,b)=B_x(a,b)/B(a,b) where $B_x(a,b) = \int_0^x t^a-1 (1-t)^b-1 dt$ B_x(a,b) = \int_0^x t^[a-1] (1-t)^[b-1] dt for $0 \le x \le 1$ 0 <= x <= 1. For a > 0, b > 0 the value is computed using a continued fraction expansion. For all other values it is computed using the relation $I_x(a,b,x) = (1/a) x^a {}_2F_1(a,1-b,a+1,x)/B(a,b)$ I_x(a,b,x) = (1/a) x^a 2F1(a,1-b,a+1,x)/B(a,b).

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3494

static VALUE
sf_s_beta_inc_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_beta_inc_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    
    return na_ndloop(&ndf,3,v0,v1,v2); 
}

.Chi(x) ⇒ DFloat

These routines compute the integral $\hboxChi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t]$ Chi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t] , where \gamma_E is the Euler constant (available as the macro M_EULER). Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5815

static VALUE
sf_s_Chi(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_Chi, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.Chi_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the integral $\hboxChi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t]$ Chi(x) := \Re[ \gamma_E + \log(x) + \int_0^x dt (\cosh(t)-1)/t] , where \gamma_E is the Euler constant (available as the macro M_EULER). Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5859

static VALUE
sf_s_Chi_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_Chi_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.choose(n, m) ⇒ Numo::DFloat

These routines compute the combinatorial factor n choose m = n!/(m!(n-m)!) exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Numo::UInt)
• m (Numo::UInt)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2299

static VALUE
sf_s_choose(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cUI,0},{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_choose,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.choose_e(n, m) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the combinatorial factor n choose m = n!/(m!(n-m)!) exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Numo::UInt)
• m (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2349

static VALUE
sf_s_choose_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cUI,0},{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_choose_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.Ci(x) ⇒ DFloat

These routines compute the Cosine integral $\hboxCi(x) = -\int_x^\infty dt \cos(t)/t$ Ci(x) = -\int_x^\infty dt \cos(t)/t for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6081

static VALUE
sf_s_Ci(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_Ci, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.Ci_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Cosine integral $\hboxCi(x) = -\int_x^\infty dt \cos(t)/t$ Ci(x) = -\int_x^\infty dt \cos(t)/t for x > 0. Domain: x > 0.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6124

static VALUE
sf_s_Ci_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_Ci_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.clausen(x) ⇒ DFloat

These routines compute the Clausen integral Cl_2(x).

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23732

static VALUE
sf_s_clausen(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_clausen, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.clausen_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Clausen integral Cl_2(x).

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23772

static VALUE
sf_s_clausen_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_clausen_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.complex_cos_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the complex cosine, \cos(z_r + i z_i) storing the real and imaginary parts in czr, czi. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• zr (Numo::DFloat)
• zi (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [czr.val, czr.err, czi.val, czi.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 877

static VALUE
sf_s_complex_cos_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_complex_cos_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.complex_dilog_e(r, theta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the full complex-valued dilogarithm for the complex argument z = r \exp(i \theta). The real and imaginary parts of the result are returned in result_re, result_im.

Parameters:

• r (Numo::DFloat)
• theta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_re.val, result_re.err, result_im.val, result_im.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12118

static VALUE
sf_s_complex_dilog_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_complex_dilog_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.complex_log_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This routine computes the complex logarithm of z = z_r + i z_i. The results are returned as lnr, theta such that \exp(lnr + i \theta) = z_r + i z_i, where \theta lies in the range [-\pi,\pi]. Exceptional Return Values: GSL_EDOM

Parameters:

• zr (Numo::DFloat)
• zi (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [lnr.val, lnr.err, theta.val, theta.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 243

static VALUE
sf_s_complex_log_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_complex_log_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.complex_logsin_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the logarithm of the complex sine, \log(\sin(z_r + i z_i)) storing the real and imaginary parts in lszr, lszi. Exceptional Return Values: GSL_EDOM, GSL_ELOSS

Parameters:

• zr (Numo::DFloat)
• zi (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [lszr.val, lszr.err, lszi.val, lszi.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 931

static VALUE
sf_s_complex_logsin_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_complex_logsin_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.complex_sin_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the complex sine, \sin(z_r + i z_i) storing the real and imaginary parts in szr, szi. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• zr (Numo::DFloat)
• zi (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [szr.val, szr.err, szi.val, szi.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 824

static VALUE
sf_s_complex_sin_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_complex_sin_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.conicalP_0(lambda, x) ⇒ DFloat

These routines compute the conical function $P^0+ i \lambda(x)$ P^0-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21691

static VALUE
sf_s_conicalP_0(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_0, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.conicalP_0_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the conical function $P^0+ i \lambda(x)$ P^0-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21738

static VALUE
sf_s_conicalP_0_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.conicalP_1(lambda, x) ⇒ DFloat

These routines compute the conical function $P^1+ i \lambda(x)$ P^1-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21787

static VALUE
sf_s_conicalP_1(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_1, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.conicalP_1_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the conical function $P^1+ i \lambda(x)$ P^1-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21833

static VALUE
sf_s_conicalP_1_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.conicalP_cyl_reg(m, lambda, x) ⇒ Numo::DFloat

These routines compute the Regular Cylindrical Conical Function $P^-m+ i \lambda(x)$ P^[-m]-1/2 + i \lambda for x > -1, $m \ge -1$ m >= -1. Exceptional Return Values: GSL_EDOM

Parameters:

• m (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22003

static VALUE
sf_s_conicalP_cyl_reg(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_cyl_reg,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //m
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.conicalP_cyl_reg_e(m, lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Regular Cylindrical Conical Function $P^-m+ i \lambda(x)$ P^[-m]-1/2 + i \lambda for x > -1, $m \ge -1$ m >= -1. Exceptional Return Values: GSL_EDOM

Parameters:

• m (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22063

static VALUE
sf_s_conicalP_cyl_reg_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_cyl_reg_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //m
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.conicalP_half(lambda, x) ⇒ DFloat

These routines compute the irregular Spherical Conical Function $P^1/2+ i \lambda(x)$ P^[1/2]-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21500

static VALUE
sf_s_conicalP_half(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_half, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.conicalP_half_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the irregular Spherical Conical Function $P^1/2+ i \lambda(x)$ P^[1/2]-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21546

static VALUE
sf_s_conicalP_half_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_half_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.conicalP_mhalf(lambda, x) ⇒ DFloat

These routines compute the regular Spherical Conical Function $P^-1/2+ i \lambda(x)$ P^[-1/2]-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21595

static VALUE
sf_s_conicalP_mhalf(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_mhalf, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.conicalP_mhalf_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regular Spherical Conical Function $P^-1/2+ i \lambda(x)$ P^[-1/2]-1/2 + i \lambda for x > -1. Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21641

static VALUE
sf_s_conicalP_mhalf_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_mhalf_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.conicalP_sph_reg(l, lambda, x) ⇒ Numo::DFloat

These routines compute the Regular Spherical Conical Function $P^-1/2-l+ i \lambda(x)$ P^[-1/2-l]-1/2 + i \lambda for x > -1, $l \ge -1$ l >= -1. Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21886

static VALUE
sf_s_conicalP_sph_reg(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_sph_reg,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.conicalP_sph_reg_e(l, lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Regular Spherical Conical Function $P^-1/2-l+ i \lambda(x)$ P^[-1/2-l]-1/2 + i \lambda for x > -1, $l \ge -1$ l >= -1. Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21946

static VALUE
sf_s_conicalP_sph_reg_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_conicalP_sph_reg_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.cos(x) ⇒ DFloat

These routines compute the cosine function \cos(x). Exceptional Return Values:

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 550

static VALUE
sf_s_cos(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_cos, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.cos_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the cosine function \cos(x). Exceptional Return Values:

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 591

static VALUE
sf_s_cos_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_cos_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.cos_err_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This routine computes the cosine of an angle x with an associated absolute error dx, $\cos(x \pm dx)$ \cos(x \pm dx). Note that this function is provided in the error-handling form only since its purpose is to compute the propagated error.

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1405

static VALUE
sf_s_cos_err_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_cos_err_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.coulomb_CL_array(Lmin, kmax, eta) ⇒ [Numo::DFloat, Numo::Int]

This function computes the Coulomb wave function normalization constant C_L(\eta) for L = Lmin \dots Lmin + kmax, Lmin > -1.

Parameters:

• Lmin (Numo::DFloat)
• kmax (Integer)
• eta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [cl[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17682

static VALUE
sf_s_coulomb_CL_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_CL_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,2,ain,aout};
    
    void *opt;
    c1 = NUM2INT(v1); opt = &c1; //kmax
    
    if (c1<0) {
        rb_raise(rb_eArgError,"should be kmax>=0");
    }
    shape[0] = c1+1;
    
    return na_ndloop3(&ndf,opt,2,v0,v2); 
}

.coulomb_CL_e(L, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the Coulomb wave function normalization constant C_L(\eta) for L > -1.

Parameters:

• L (Numo::DFloat)
• eta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17629

static VALUE
sf_s_coulomb_CL_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_CL_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.coulomb_wave_F_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the Coulomb wave function F_L(\eta,x) for L = Lmin \dots Lmin + kmax, storing the results in fc_array. In the case of overflow the exponent is stored in F_exponent.

Parameters:

• L_min (Numo::DFloat)
• kmax (Integer)
• eta (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [fc_array[], F_exponent, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17340

static VALUE
sf_s_coulomb_wave_F_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_wave_F_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    void *opt;
    c1 = NUM2INT(v1); opt = &c1; //kmax
    
    if (c1<0) {
        rb_raise(rb_eArgError,"should be kmax>=0");
    }
    shape[0] = c1+1;
    
    return na_ndloop3(&ndf,opt,3,v0,v2,v3); 
}

.coulomb_wave_FG_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the functions F_L(\eta,x), G_L(\eta,x) for L = Lmin \dots Lmin + kmax storing the results in fc_array and gc_array. In the case of overflow the exponents are stored in F_exponent and G_exponent.

Parameters:

• L_min (Numo::DFloat)
• kmax (Integer)
• eta (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [fc_array[], gc_array[], F_exponent, G_exponent, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17416

static VALUE
sf_s_coulomb_wave_FG_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,1,shape},{cDF,1,shape},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_wave_FG_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,5,ain,aout};
    
    void *opt;
    c1 = NUM2INT(v1); opt = &c1; //kmax
    
    if (c1<0) {
        rb_raise(rb_eArgError,"should be kmax>=0");
    }
    shape[0] = c1+1;
    
    return na_ndloop3(&ndf,opt,3,v0,v2,v3); 
}

.coulomb_wave_FG_e(eta, x, L_F, k) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the Coulomb wave functions F_L(\eta,x), $G_L-k(\eta,x)$ G_L-k and their derivatives F’L(\eta,x), $G’L-k(\eta,x)$ G’_L-k with respect to x. The parameters are restricted to L, L-k > -1/2, x > 0 and integer k. Note that L itself is not restricted to being an integer. The results are stored in the parameters F, G for the function values and Fp, Gp for the derivative values. If an overflow occurs, GSL_EOVRFLW is returned and scaling exponents are stored in the modifiable parameters exp_F, exp_G.

Parameters:

• eta (Numo::DFloat)
• x (Numo::DFloat)
• L_F (Numo::DFloat)
• k (Integer)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [F.val, F.err, Fp.val, Fp.err, G.val, G.err, Gp.val, Gp.err, exp_F, exp_G, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17276

static VALUE
sf_s_coulomb_wave_FG_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[11] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_wave_FG_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,11,ain,aout};
    
    void *opt;
    c3 = NUM2INT(v3); opt = &c3; //k
    
    
    return na_ndloop3(&ndf,opt,3,v0,v1,v2); 
}

.coulomb_wave_FGp_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the functions F_L(\eta,x), G_L(\eta,x) and their derivatives F’_L(\eta,x), G’_L(\eta,x) for L = Lmin \dots Lmin + kmax storing the results in fc_array, gc_array, fcp_array and gcp_array. In the case of overflow the exponents are stored in F_exponent and G_exponent.

Parameters:

• L_min (Numo::DFloat)
• kmax (Integer)
• eta (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [fc_array[], fcp_array[], gc_array[], gcp_array[], F_exponent, G_exponent, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17500

static VALUE
sf_s_coulomb_wave_FGp_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[7] = {{cDF,1,shape},{cDF,1,shape},{cDF,1,shape},{cDF,1,shape},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_wave_FGp_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,7,ain,aout};
    
    void *opt;
    c1 = NUM2INT(v1); opt = &c1; //kmax
    
    if (c1<0) {
        rb_raise(rb_eArgError,"should be kmax>=0");
    }
    shape[0] = c1+1;
    
    return na_ndloop3(&ndf,opt,3,v0,v2,v3); 
}

.coulomb_wave_sphF_array(L_min, kmax, eta, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the Coulomb wave function divided by the argument F_L(\eta, x)/x for L = Lmin \dots Lmin + kmax, storing the results in fc_array. In the case of overflow the exponent is stored in F_exponent. This function reduces to spherical Bessel functions in the limit \eta \to 0.

Parameters:

• L_min (Numo::DFloat)
• kmax (Integer)
• eta (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [fc_array[], F_exponent[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17571

static VALUE
sf_s_coulomb_wave_sphF_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_coulomb_wave_sphF_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    void *opt;
    c1 = NUM2INT(v1); opt = &c1; //kmax
    
    if (c1<0) {
        rb_raise(rb_eArgError,"should be kmax>=0");
    }
    shape[0] = c1+1;
    
    return na_ndloop3(&ndf,opt,3,v0,v2,v3); 
}

.coupling_3j(two_ja, two_jb, two_jc, two_ma, two_mb, two_mc) ⇒ Float

These routines compute the Wigner 3-j coefficient,

(ja jb jc ma mb mc)

where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• two_ja (Integer)
• two_jb (Integer)
• two_jc (Integer)
• two_ma (Integer)
• two_mb (Integer)
• two_mc (Integer)

Returns:

• (Float) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7193

static VALUE
sf_s_coupling_3j(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3,VALUE v4,VALUE v5)
{
    
    int c0;
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    double c6;
    
    c0 = NUM2INT(v0);
    c1 = NUM2INT(v1);
    c2 = NUM2INT(v2);
    c3 = NUM2INT(v3);
    c4 = NUM2INT(v4);
    c5 = NUM2INT(v5);
    c6 = gsl_sf_coupling_3j(c0,c1,c2,c3,c4,c5);
    
    return DBL2NUM(c6);
    
}

.coupling_3j_e(two_ja, two_jb, two_jc, two_ma, two_mb, two_mc) ⇒ [Float, Float, Integer]

These routines compute the Wigner 3-j coefficient,

(ja jb jc ma mb mc)

where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• two_ja (Integer)
• two_jb (Integer)
• two_jc (Integer)
• two_ma (Integer)
• two_mb (Integer)
• two_mc (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7239

static VALUE
sf_s_coupling_3j_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3,VALUE v4,VALUE v5)
{
    
    int c0;
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    gsl_sf_result c6;
    int c7;
    
    c0 = NUM2INT(v0);
    c1 = NUM2INT(v1);
    c2 = NUM2INT(v2);
    c3 = NUM2INT(v3);
    c4 = NUM2INT(v4);
    c5 = NUM2INT(v5);
    c7 = gsl_sf_coupling_3j_e(c0,c1,c2,c3,c4,c5,&c6);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c6.val));
        rb_ary_push(va,DBL2NUM(c6.err));
        rb_ary_push(va,INT2NUM(c7));
        return va;
    }
    
}

.coupling_6j(two_ja, two_jb, two_jc, two_jd, two_je, two_jf) ⇒ Float

These routines compute the Wigner 6-j coefficient,

[ja jb jc jd je jf]

where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• two_ja (Integer)
• two_jb (Integer)
• two_jc (Integer)
• two_jd (Integer)
• two_je (Integer)
• two_jf (Integer)

Returns:

• (Float) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7293

static VALUE
sf_s_coupling_6j(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3,VALUE v4,VALUE v5)
{
    
    int c0;
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    double c6;
    
    c0 = NUM2INT(v0);
    c1 = NUM2INT(v1);
    c2 = NUM2INT(v2);
    c3 = NUM2INT(v3);
    c4 = NUM2INT(v4);
    c5 = NUM2INT(v5);
    c6 = gsl_sf_coupling_6j(c0,c1,c2,c3,c4,c5);
    
    return DBL2NUM(c6);
    
}

.coupling_6j_e(two_ja, two_jb, two_jc, two_jd, two_je, two_jf) ⇒ [Float, Float, Integer]

These routines compute the Wigner 6-j coefficient,

[ja jb jc jd je jf]

where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• two_ja (Integer)
• two_jb (Integer)
• two_jc (Integer)
• two_jd (Integer)
• two_je (Integer)
• two_jf (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7339

static VALUE
sf_s_coupling_6j_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3,VALUE v4,VALUE v5)
{
    
    int c0;
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    gsl_sf_result c6;
    int c7;
    
    c0 = NUM2INT(v0);
    c1 = NUM2INT(v1);
    c2 = NUM2INT(v2);
    c3 = NUM2INT(v3);
    c4 = NUM2INT(v4);
    c5 = NUM2INT(v5);
    c7 = gsl_sf_coupling_6j_e(c0,c1,c2,c3,c4,c5,&c6);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c6.val));
        rb_ary_push(va,DBL2NUM(c6.err));
        rb_ary_push(va,INT2NUM(c7));
        return va;
    }
    
}

.coupling_9j(two_ja, two_jb, two_jc, two_jd, two_je, two_jf, two_jg, two_jh, two_ji) ⇒ Float

These routines compute the Wigner 9-j coefficient,

[ja jb jc jd je jf jg jh ji]

where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• two_ja (Integer)
• two_jb (Integer)
• two_jc (Integer)
• two_jd (Integer)
• two_je (Integer)
• two_jf (Integer)
• two_jg (Integer)
• two_jh (Integer)
• two_ji (Integer)

Returns:

• (Float) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7397

static VALUE
sf_s_coupling_9j(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3,VALUE v4,VALUE v5,VALUE v6,VALUE v7,VALUE v8)
{
    
    int c0;
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    int c6;
    int c7;
    int c8;
    double c9;
    
    c0 = NUM2INT(v0);
    c1 = NUM2INT(v1);
    c2 = NUM2INT(v2);
    c3 = NUM2INT(v3);
    c4 = NUM2INT(v4);
    c5 = NUM2INT(v5);
    c6 = NUM2INT(v6);
    c7 = NUM2INT(v7);
    c8 = NUM2INT(v8);
    c9 = gsl_sf_coupling_9j(c0,c1,c2,c3,c4,c5,c6,c7,c8);
    
    return DBL2NUM(c9);
    
}

.coupling_9j_e(two_ja, two_jb, two_jc, two_jd, two_je, two_jf, two_jg, two_jh, two_ji) ⇒ [Float, Float, Integer]

These routines compute the Wigner 9-j coefficient,

[ja jb jc jd je jf jg jh ji]

where the arguments are given in half-integer units, ja = two_ja/2, ma = two_ma/2, etc. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• two_ja (Integer)
• two_jb (Integer)
• two_jc (Integer)
• two_jd (Integer)
• two_je (Integer)
• two_jf (Integer)
• two_jg (Integer)
• two_jh (Integer)
• two_ji (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7453

static VALUE
sf_s_coupling_9j_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3,VALUE v4,VALUE v5,VALUE v6,VALUE v7,VALUE v8)
{
    
    int c0;
    int c1;
    int c2;
    int c3;
    int c4;
    int c5;
    int c6;
    int c7;
    int c8;
    gsl_sf_result c9;
    int c10;
    
    c0 = NUM2INT(v0);
    c1 = NUM2INT(v1);
    c2 = NUM2INT(v2);
    c3 = NUM2INT(v3);
    c4 = NUM2INT(v4);
    c5 = NUM2INT(v5);
    c6 = NUM2INT(v6);
    c7 = NUM2INT(v7);
    c8 = NUM2INT(v8);
    c10 = gsl_sf_coupling_9j_e(c0,c1,c2,c3,c4,c5,c6,c7,c8,&c9);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c9.val));
        rb_ary_push(va,DBL2NUM(c9.err));
        rb_ary_push(va,INT2NUM(c10));
        return va;
    }
    
}

.dawson(x) ⇒ DFloat

These routines compute the value of Dawson’s integral for x. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10083

static VALUE
sf_s_dawson(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_dawson, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.dawson_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the value of Dawson’s integral for x. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10124

static VALUE
sf_s_dawson_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_dawson_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.debye_1(x) ⇒ DFloat

These routines compute the first-order Debye function D_1(x) = (1/x) \int_0^x dt (t/(e^t - 1)). Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8049

static VALUE
sf_s_debye_1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_debye_1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.debye_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the first-order Debye function D_1(x) = (1/x) \int_0^x dt (t/(e^t - 1)). Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8091

static VALUE
sf_s_debye_1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_debye_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.debye_2(x) ⇒ DFloat

These routines compute the second-order Debye function D_2(x) = (2/x^2) \int_0^x dt (t^2/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8136

static VALUE
sf_s_debye_2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_debye_2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.debye_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the second-order Debye function D_2(x) = (2/x^2) \int_0^x dt (t^2/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8178

static VALUE
sf_s_debye_2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_debye_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.debye_3(x) ⇒ DFloat

These routines compute the third-order Debye function D_3(x) = (3/x^3) \int_0^x dt (t^3/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8223

static VALUE
sf_s_debye_3(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_debye_3, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.debye_3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the third-order Debye function D_3(x) = (3/x^3) \int_0^x dt (t^3/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8265

static VALUE
sf_s_debye_3_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_debye_3_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.debye_4(x) ⇒ DFloat

These routines compute the fourth-order Debye function D_4(x) = (4/x^4) \int_0^x dt (t^4/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8310

static VALUE
sf_s_debye_4(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_debye_4, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.debye_4_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the fourth-order Debye function D_4(x) = (4/x^4) \int_0^x dt (t^4/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8352

static VALUE
sf_s_debye_4_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_debye_4_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.debye_5(x) ⇒ DFloat

These routines compute the fifth-order Debye function D_5(x) = (5/x^5) \int_0^x dt (t^5/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8397

static VALUE
sf_s_debye_5(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_debye_5, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.debye_5_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the fifth-order Debye function D_5(x) = (5/x^5) \int_0^x dt (t^5/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8439

static VALUE
sf_s_debye_5_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_debye_5_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.debye_6(x) ⇒ DFloat

These routines compute the sixth-order Debye function D_6(x) = (6/x^6) \int_0^x dt (t^6/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8484

static VALUE
sf_s_debye_6(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_debye_6, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.debye_6_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the sixth-order Debye function D_6(x) = (6/x^6) \int_0^x dt (t^6/(e^t - 1)). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8526

static VALUE
sf_s_debye_6_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_debye_6_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.dilog(x) ⇒ DFloat

These routines compute the dilogarithm for a real argument. In Lewin’s notation this is Li_2(x), the real part of the dilogarithm of a real x. It is defined by the integral representation Li_2(x) = - \Re \int_0^x ds \log(1-s) / s. Note that \Im(Li_2(x)) = 0 for $x \le 1$ x <= 1, and -\pi\log(x) for x > 1.

Note that Abramowitz & Stegun refer to the Spence integral S(x)=Li_2(1-x) as the dilogarithm rather than Li_2(x).

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12017

static VALUE
sf_s_dilog(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_dilog, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.dilog_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the dilogarithm for a real argument. In Lewin’s notation this is Li_2(x), the real part of the dilogarithm of a real x. It is defined by the integral representation Li_2(x) = - \Re \int_0^x ds \log(1-s) / s. Note that \Im(Li_2(x)) = 0 for $x \le 1$ x <= 1, and -\pi\log(x) for x > 1.

Note that Abramowitz & Stegun refer to the Spence integral S(x)=Li_2(1-x) as the dilogarithm rather than Li_2(x).

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 12065

static VALUE
sf_s_dilog_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_dilog_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.doublefact(n) ⇒ DFloat

These routines compute the double factorial n!! = n(n-2)(n-4) \dots. The maximum value of n such that n!! is not considered an overflow is given by the macro GSL_SF_DOUBLEFACT_NMAX and is 297. exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2028

static VALUE
sf_s_doublefact(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_doublefact, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.doublefact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the double factorial n!! = n(n-2)(n-4) \dots. The maximum value of n such that n!! is not considered an overflow is given by the macro GSL_SF_DOUBLEFACT_NMAX and is 297. exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2072

static VALUE
sf_s_doublefact_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_doublefact_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.ellint_D(phi, k, [mode]) ⇒ Numo::DFloat

These functions compute the incomplete elliptic integral D(\phi,k) which is defined through the Carlson form RD(x,y,z) by the following relation,

D(\phi,k) = (1/3)(\sin(\phi))^3 RD (1-\sin^2(\phi), 1-k^2 \sin^2(\phi), 1).

Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4669

static VALUE
sf_s_ellint_D(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_D,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_D_e(phi, k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions compute the incomplete elliptic integral D(\phi,k) which is defined through the Carlson form RD(x,y,z) by the following relation,

D(\phi,k) = (1/3)(\sin(\phi))^3 RD (1-\sin^2(\phi), 1-k^2 \sin^2(\phi), 1).

Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4739

static VALUE
sf_s_ellint_D_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_D_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_E(phi, k, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral E(\phi,k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4393

static VALUE
sf_s_ellint_E(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_E,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_E_e(phi, k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral E(\phi,k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4461

static VALUE
sf_s_ellint_E_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_E_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_Ecomp(k[,mode]) ⇒ DFloat

These routines compute the complete elliptic integral E(k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• k (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4004

static VALUE
sf_s_ellint_Ecomp(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_Ecomp, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.ellint_Ecomp_e(k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete elliptic integral E(k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4060

static VALUE
sf_s_ellint_Ecomp_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_Ecomp_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.ellint_F(phi, k, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral F(\phi,k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4260

static VALUE
sf_s_ellint_F(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_F,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_F_e(phi, k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral F(\phi,k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4328

static VALUE
sf_s_ellint_F_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_F_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_Kcomp(k[,mode]) ⇒ DFloat

These routines compute the complete elliptic integral K(k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• k (DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3885

static VALUE
sf_s_ellint_Kcomp(int argc, VALUE *v, VALUE mod)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_Kcomp, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    gsl_mode_t c1;

    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
    }
    return na_ndloop3(&ndf, &c1, 1, v[0]);
}

.ellint_Kcomp_e(k, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete elliptic integral K(k) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameter m = k^2. Exceptional Return Values: GSL_EDOM

Parameters:

• k (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3941

static VALUE
sf_s_ellint_Kcomp_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_Kcomp_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    if (argc==1) {
        c1 = GSL_MODE_DEFAULT;
    } else if (argc==2) {
        c1 = NUM2INT(v[1]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 1 or 2",argc);
    }
    opt = &c1; //mode

    
    
    return na_ndloop3(&ndf,opt,1,v[0]); 
}

.ellint_P(phi, k, n, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral \Pi(\phi,k,n) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameters m = k^2 and \sin^2(\alpha) = k^2, with the change of sign n \to -n. Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• n (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4530

static VALUE
sf_s_ellint_P(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_P,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,1,ain,aout};
    
    void *opt;
    if (argc==3) {
        c3 = GSL_MODE_DEFAULT;
    } else if (argc==4) {
        c3 = NUM2INT(v[3]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 3 or 4",argc);
    }
    opt = &c3; //mode

    
    
    return na_ndloop3(&ndf,opt,3,v[0],v[1],v[2]); 
}

.ellint_P_e(phi, k, n, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral \Pi(\phi,k,n) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameters m = k^2 and \sin^2(\alpha) = k^2, with the change of sign n \to -n. Exceptional Return Values: GSL_EDOM

Parameters:

• phi (Numo::DFloat)
• k (Numo::DFloat)
• n (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4602

static VALUE
sf_s_ellint_P_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_P_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    void *opt;
    if (argc==3) {
        c3 = GSL_MODE_DEFAULT;
    } else if (argc==4) {
        c3 = NUM2INT(v[3]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 3 or 4",argc);
    }
    opt = &c3; //mode

    
    
    return na_ndloop3(&ndf,opt,3,v[0],v[1],v[2]); 
}

.ellint_Pcomp(k, n, [mode]) ⇒ Numo::DFloat

These routines compute the complete elliptic integral \Pi(k,n) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameters m = k^2 and \sin^2(\alpha) = k^2, with the change of sign n \to -n. Exceptional Return Values: GSL_EDOM

Parameters:

• k (Numo::DFloat)
• n (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4126

static VALUE
sf_s_ellint_Pcomp(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_Pcomp,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_Pcomp_e(k, n, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete elliptic integral \Pi(k,n) to the accuracy specified by the mode variable mode. Note that Abramowitz & Stegun define this function in terms of the parameters m = k^2 and \sin^2(\alpha) = k^2, with the change of sign n \to -n. Exceptional Return Values: GSL_EDOM

Parameters:

• k (Numo::DFloat)
• n (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4195

static VALUE
sf_s_ellint_Pcomp_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_Pcomp_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_RC(x, y, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral RC(x,y) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4802

static VALUE
sf_s_ellint_RC(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RC,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_RC_e(x, y, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral RC(x,y) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4868

static VALUE
sf_s_ellint_RC_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c2;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RC_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    if (argc==2) {
        c2 = GSL_MODE_DEFAULT;
    } else if (argc==3) {
        c2 = NUM2INT(v[2]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 2 or 3",argc);
    }
    opt = &c2; //mode

    
    
    return na_ndloop3(&ndf,opt,2,v[0],v[1]); 
}

.ellint_RD(x, y, z, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral RD(x,y,z) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• z (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 4934

static VALUE
sf_s_ellint_RD(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RD,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,1,ain,aout};
    
    void *opt;
    if (argc==3) {
        c3 = GSL_MODE_DEFAULT;
    } else if (argc==4) {
        c3 = NUM2INT(v[3]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 3 or 4",argc);
    }
    opt = &c3; //mode

    
    
    return na_ndloop3(&ndf,opt,3,v[0],v[1],v[2]); 
}

.ellint_RD_e(x, y, z, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral RD(x,y,z) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• z (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5003

static VALUE
sf_s_ellint_RD_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RD_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    void *opt;
    if (argc==3) {
        c3 = GSL_MODE_DEFAULT;
    } else if (argc==4) {
        c3 = NUM2INT(v[3]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 3 or 4",argc);
    }
    opt = &c3; //mode

    
    
    return na_ndloop3(&ndf,opt,3,v[0],v[1],v[2]); 
}

.ellint_RF(x, y, z, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral RF(x,y,z) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• z (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5069

static VALUE
sf_s_ellint_RF(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RF,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,1,ain,aout};
    
    void *opt;
    if (argc==3) {
        c3 = GSL_MODE_DEFAULT;
    } else if (argc==4) {
        c3 = NUM2INT(v[3]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 3 or 4",argc);
    }
    opt = &c3; //mode

    
    
    return na_ndloop3(&ndf,opt,3,v[0],v[1],v[2]); 
}

.ellint_RF_e(x, y, z, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral RF(x,y,z) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• z (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5138

static VALUE
sf_s_ellint_RF_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c3;
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RF_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    void *opt;
    if (argc==3) {
        c3 = GSL_MODE_DEFAULT;
    } else if (argc==4) {
        c3 = NUM2INT(v[3]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 3 or 4",argc);
    }
    opt = &c3; //mode

    
    
    return na_ndloop3(&ndf,opt,3,v[0],v[1],v[2]); 
}

.ellint_RJ(x, y, z, p, [mode]) ⇒ Numo::DFloat

These routines compute the incomplete elliptic integral RJ(x,y,z,p) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• z (Numo::DFloat)
• p (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5207

static VALUE
sf_s_ellint_RJ(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c4;
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RJ,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,1,ain,aout};
    
    void *opt;
    if (argc==4) {
        c4 = GSL_MODE_DEFAULT;
    } else if (argc==5) {
        c4 = NUM2INT(v[4]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 4 or 5",argc);
    }
    opt = &c4; //mode

    
    
    return na_ndloop3(&ndf,opt,4,v[0],v[1],v[2],v[3]); 
}

.ellint_RJ_e(x, y, z, p, [mode]) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete elliptic integral RJ(x,y,z,p) to the accuracy specified by the mode variable mode. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)
• z (Numo::DFloat)
• p (Numo::DFloat)
• mode (Integer) —

  The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5279

static VALUE
sf_s_ellint_RJ_e(int argc, VALUE *v, VALUE mod)
{
    
    gsl_mode_t c4;
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_ellint_RJ_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    void *opt;
    if (argc==4) {
        c4 = GSL_MODE_DEFAULT;
    } else if (argc==5) {
        c4 = NUM2INT(v[4]);
    } else {
        rb_raise(rb_eArgError,"invalid number of argument: %d for 4 or 5",argc);
    }
    opt = &c4; //mode

    
    
    return na_ndloop3(&ndf,opt,4,v[0],v[1],v[2],v[3]); 
}

.elljac_e(u, m) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function computes the Jacobian elliptic functions sn(u|m), cn(u|m), dn(u|m) by descending Landen transformations. Exceptional Return Values: GSL_EDOM

Parameters:

• u (Numo::DFloat)
• m (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [sn, cn, dn, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7156

static VALUE
sf_s_elljac_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_elljac_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,4,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.erf(x) ⇒ DFloat

These routines compute the error function $\erf(x)$ erf(x), where $\erf(x) = (2/\sqrt\pi) \int_0^x dt \exp(-t^2)$ erf(x) = (2/\sqrt(\pi)) \int_0^x dt \exp(-t^2). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8573

static VALUE
sf_s_erf(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_erf, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.erf_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the error function $\erf(x)$ erf(x), where $\erf(x) = (2/\sqrt\pi) \int_0^x dt \exp(-t^2)$ erf(x) = (2/\sqrt(\pi)) \int_0^x dt \exp(-t^2). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8617

static VALUE
sf_s_erf_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_erf_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.erf_Q(x) ⇒ DFloat

These routines compute the upper tail of the Gaussian probability function $Q(x) = (1/\sqrt2\pi) \int_x^\infty dt \exp(-t^2/2)$ Q(x) = (1/\sqrt[2\pi]) \int_x^\infty dt \exp(-t^2/2). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8927

static VALUE
sf_s_erf_Q(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_erf_Q, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.erf_Q_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the upper tail of the Gaussian probability function $Q(x) = (1/\sqrt2\pi) \int_x^\infty dt \exp(-t^2/2)$ Q(x) = (1/\sqrt[2\pi]) \int_x^\infty dt \exp(-t^2/2). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8971

static VALUE
sf_s_erf_Q_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_erf_Q_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.erf_Z(x) ⇒ DFloat

These routines compute the Gaussian probability density function $Z(x) = (1/\sqrt2\pi) \exp(-x^2/2)$ Z(x) = (1/\sqrt[2\pi]) \exp(-x^2/2).

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8838

static VALUE
sf_s_erf_Z(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_erf_Z, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.erf_Z_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Gaussian probability density function $Z(x) = (1/\sqrt2\pi) \exp(-x^2/2)$ Z(x) = (1/\sqrt[2\pi]) \exp(-x^2/2).

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8880

static VALUE
sf_s_erf_Z_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_erf_Z_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.erfc(x) ⇒ DFloat

These routines compute the complementary error function $\erfc(x) = 1 - \erf(x) = (2/\sqrt\pi) \int_x^\infty \exp(-t^2)$ erfc(x) = 1 - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8663

static VALUE
sf_s_erfc(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_erfc, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.erfc_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complementary error function $\erfc(x) = 1 - \erf(x) = (2/\sqrt\pi) \int_x^\infty \exp(-t^2)$ erfc(x) = 1 - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8706

static VALUE
sf_s_erfc_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_erfc_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.eta(s) ⇒ DFloat

These routines compute the eta function \eta(s) for arbitrary s. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• s (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19503

static VALUE
sf_s_eta(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_eta, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.eta_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the eta function \eta(s) for arbitrary s. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• s (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19544

static VALUE
sf_s_eta_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_eta_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.eta_int(n) ⇒ DFloat

These routines compute the eta function \eta(n) for integer n. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• n (Int)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19431

static VALUE
sf_s_eta_int(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_eta_int, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.eta_int_e(n) ⇒ [Float, Float, Integer]

These routines compute the eta function \eta(n) for integer n. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• n (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19452

static VALUE
sf_s_eta_int_e(VALUE mod,VALUE v0)
{
    
    int c0;
    gsl_sf_result c1;
    int c2;
    
    c0 = NUM2INT(v0);
    c2 = gsl_sf_eta_int_e(c0,&c1);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c1.val));
        rb_ary_push(va,DBL2NUM(c1.err));
        rb_ary_push(va,INT2NUM(c2));
        return va;
    }
    
}

.exp(x) ⇒ DFloat

These routines provide an exponential function \exp(x) using GSL semantics and error checking. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9210

static VALUE
sf_s_exp(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_exp, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.exp_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines provide an exponential function \exp(x) using GSL semantics and error checking. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9252

static VALUE
sf_s_exp_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.exp_e10_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

This function computes the exponential \exp(x) using the gsl_sf_result_e10 type to return a result with extended range. This function may be useful if the value of \exp(x) would overflow the numeric range of double. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]) —

  array of [result.val, result.err, result.e10, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9301

static VALUE
sf_s_exp_e10_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cI,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_e10_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.exp_err_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This function exponentiates x with an associated absolute error dx. Exceptional Return Values:

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9875

static VALUE
sf_s_exp_err_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_err_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.exp_err_e10_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

This function exponentiates a quantity x with an associated absolute error dx using the gsl_sf_result_e10 type to return a result with extended range. Exceptional Return Values:

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]) —

  array of [result.val, result.err, result.e10, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9926

static VALUE
sf_s_exp_err_e10_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cI,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_err_e10_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,4,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.exp_mult(x, y) ⇒ DFloat

These routines exponentiate x and multiply by the factor y to return the product y \exp(x). Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)
• y (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9349

static VALUE
sf_s_exp_mult(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_exp_mult, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.exp_mult_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines exponentiate x and multiply by the factor y to return the product y \exp(x). Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9394

static VALUE
sf_s_exp_mult_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_mult_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.exp_mult_e10_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

This function computes the product y \exp(x) using the gsl_sf_result_e10 type to return a result with extended numeric range. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]) —

  array of [result.val, result.err, result.e10, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9445

static VALUE
sf_s_exp_mult_e10_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cI,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_mult_e10_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,4,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.exp_mult_err_e(x, dx, y, dy) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This routine computes the product y \exp(x) for the quantities x, y with associated absolute errors dx, dy. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)
• y (Numo::DFloat)
• dy (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9982

static VALUE
sf_s_exp_mult_err_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_mult_err_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.exp_mult_err_e10_e(x, dx, y, dy) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

This routine computes the product y \exp(x) for the quantities x, y with associated absolute errors dx, dy using the gsl_sf_result_e10 type to return a result with extended range. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)
• y (Numo::DFloat)
• dy (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]) —

  array of [result.val, result.err, result.e10, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10039

static VALUE
sf_s_exp_mult_err_e10_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cI,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exp_mult_err_e10_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,4,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.expint_3(x) ⇒ DFloat

These routines compute the third-order exponential integral $Ei_3(x) = \int_0^xdt \exp(-t^3)$ Ei_3(x) = \int_0^xdt \exp(-t^3) for $x \ge 0$ x >= 0. Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5905

static VALUE
sf_s_expint_3(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_expint_3, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.expint_3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the third-order exponential integral $Ei_3(x) = \int_0^xdt \exp(-t^3)$ Ei_3(x) = \int_0^xdt \exp(-t^3) for $x \ge 0$ x >= 0. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5948

static VALUE
sf_s_expint_3_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_expint_3_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.expint_E1(x) ⇒ DFloat

These routines compute the exponential integral E_1(x),

E_1(x) := \Re \int_1^\infty dt \exp(-xt)/t.

Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5339

static VALUE
sf_s_expint_E1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_expint_E1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.expint_E1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the exponential integral E_1(x),

E_1(x) := \Re \int_1^\infty dt \exp(-xt)/t.

Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5384

static VALUE
sf_s_expint_E1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_expint_E1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.expint_E2(x) ⇒ DFloat

These routines compute the second-order exponential integral E_2(x),

E_2(x) := \Re \int_1^\infty dt \exp(-xt)/t^2.

Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5432

static VALUE
sf_s_expint_E2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_expint_E2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.expint_E2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the second-order exponential integral E_2(x),

E_2(x) := \Re \int_1^\infty dt \exp(-xt)/t^2.

Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5477

static VALUE
sf_s_expint_E2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_expint_E2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.expint_Ei(x) ⇒ DFloat

These routines compute the exponential integral $\hboxEi(x)$ Ei(x),

Ei(x) := - PV(\int_[-x]^\infty dt \exp(-t)/t)

where PV denotes the principal value of the integral. Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5634

static VALUE
sf_s_expint_Ei(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_expint_Ei, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.expint_Ei_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the exponential integral $\hboxEi(x)$ Ei(x),

Ei(x) := - PV(\int_[-x]^\infty dt \exp(-t)/t)

where PV denotes the principal value of the integral. Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5681

static VALUE
sf_s_expint_Ei_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_expint_Ei_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.expint_En(n, x) ⇒ DFloat

These routines compute the exponential integral E_n(x) of order n,

E_n(x) := \Re \int_1^\infty dt \exp(-xt)/t^n.

Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5528

static VALUE
sf_s_expint_En(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_expint_En, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.expint_En_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the exponential integral E_n(x) of order n,

E_n(x) := \Re \int_1^\infty dt \exp(-xt)/t^n.

Domain: x != 0.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5580

static VALUE
sf_s_expint_En_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_expint_En_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.expm1(x) ⇒ DFloat

These routines compute the quantity \exp(x)-1 using an algorithm that is accurate for small x. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9490

static VALUE
sf_s_expm1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_expm1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.expm1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the quantity \exp(x)-1 using an algorithm that is accurate for small x. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9532

static VALUE
sf_s_expm1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_expm1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.exprel(x) ⇒ DFloat

These routines compute the quantity (\exp(x)-1)/x using an algorithm that is accurate for small x. For small x the algorithm is based on the expansion (\exp(x)-1)/x = 1 + x/2 + x^2/(23) + x^3/(23*4) + \dots. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9579

static VALUE
sf_s_exprel(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_exprel, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.exprel_2(x) ⇒ DFloat

These routines compute the quantity 2(\exp(x)-1-x)/x^2 using an algorithm that is accurate for small x. For small x the algorithm is based on the expansion 2(\exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(34) + x^3/(34*5) + \dots. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9670

static VALUE
sf_s_exprel_2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_exprel_2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.exprel_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the quantity 2(\exp(x)-1-x)/x^2 using an algorithm that is accurate for small x. For small x the algorithm is based on the expansion 2(\exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(34) + x^3/(34*5) + \dots. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9714

static VALUE
sf_s_exprel_2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exprel_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.exprel_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the quantity (\exp(x)-1)/x using an algorithm that is accurate for small x. For small x the algorithm is based on the expansion (\exp(x)-1)/x = 1 + x/2 + x^2/(23) + x^3/(23*4) + \dots. Exceptional Return Values: GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9623

static VALUE
sf_s_exprel_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exprel_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.exprel_n(n, x) ⇒ DFloat

These routines compute the N-relative exponential, which is the n-th generalization of the functions gsl_sf_exprel and gsl_sf_exprel_2. The N-relative exponential is given by,

exprel_N(x) = N!/x^N (\exp(x) - \sum_[k=0]^[N-1] x^k/k!) = 1 + x/(N+1) + x^2/((N+1)(N+2)) + … = 1F1 (1,1+N,x) Exceptional Return Values:

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9767

static VALUE
sf_s_exprel_n(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_exprel_n, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.exprel_n_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the N-relative exponential, which is the n-th generalization of the functions gsl_sf_exprel and gsl_sf_exprel_2. The N-relative exponential is given by,

exprel_N(x) = N!/x^N (\exp(x) - \sum_[k=0]^[N-1] x^k/k!) = 1 + x/(N+1) + x^2/((N+1)(N+2)) + … = 1F1 (1,1+N,x) Exceptional Return Values:

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9821

static VALUE
sf_s_exprel_n_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_exprel_n_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.fact(n) ⇒ DFloat

These routines compute the factorial n!. The factorial is related to the Gamma function by n! = \Gamma(n+1). The maximum value of n such that n! is not considered an overflow is given by the macro GSL_SF_FACT_NMAX and is 170. exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1935

static VALUE
sf_s_fact(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fact, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the factorial n!. The factorial is related to the Gamma function by n! = \Gamma(n+1). The maximum value of n such that n! is not considered an overflow is given by the macro GSL_SF_FACT_NMAX and is 170. exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1980

static VALUE
sf_s_fact_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fact_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_0(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral with an index of 0. This integral is given by F_0(x) = \ln(1 + e^x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11279

static VALUE
sf_s_fermi_dirac_0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral with an index of 0. This integral is given by F_0(x) = \ln(1 + e^x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11321

static VALUE
sf_s_fermi_dirac_0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_1(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral with an index of 1, F_1(x) = \int_0^\infty dt (t /(\exp(t-x)+1)). Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11366

static VALUE
sf_s_fermi_dirac_1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral with an index of 1, F_1(x) = \int_0^\infty dt (t /(\exp(t-x)+1)). Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11408

static VALUE
sf_s_fermi_dirac_1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_2(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral with an index of 2, F_2(x) = (1/2) \int_0^\infty dt (t^2 /(\exp(t-x)+1)). Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11454

static VALUE
sf_s_fermi_dirac_2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral with an index of 2, F_2(x) = (1/2) \int_0^\infty dt (t^2 /(\exp(t-x)+1)). Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11497

static VALUE
sf_s_fermi_dirac_2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_3half(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral $F_3/2(x)$ F_3/2. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11826

static VALUE
sf_s_fermi_dirac_3half(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_3half, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_3half_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral $F_3/2(x)$ F_3/2. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11869

static VALUE
sf_s_fermi_dirac_3half_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_3half_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_half(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral $F_1/2(x)$ F_1/2. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11737

static VALUE
sf_s_fermi_dirac_half(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_half, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_half_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral $F_1/2(x)$ F_1/2. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11780

static VALUE
sf_s_fermi_dirac_half_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_half_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_inc_0(x, b) ⇒ DFloat

These routines compute the incomplete Fermi-Dirac integral with an index of zero, $F_0(x,b) = \ln(1 + e^b-x) - (b-x)$ F_0(x,b) = \ln(1 + e^[b-x]) - (b-x). Exceptional Return Values: GSL_EUNDRFLW, GSL_EDOM

Parameters:

• x (DFloat)
• b (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11919

static VALUE
sf_s_fermi_dirac_inc_0(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_inc_0, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.fermi_dirac_inc_0_e(x, b) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the incomplete Fermi-Dirac integral with an index of zero, $F_0(x,b) = \ln(1 + e^b-x) - (b-x)$ F_0(x,b) = \ln(1 + e^[b-x]) - (b-x). Exceptional Return Values: GSL_EUNDRFLW, GSL_EDOM

Parameters:

• x (Numo::DFloat)
• b (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11966

static VALUE
sf_s_fermi_dirac_inc_0_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_inc_0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.fermi_dirac_int(j, x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral with an integer index of j, F_j(x) = (1/\Gamma(j+1)) \int_0^\infty dt (t^j /(\exp(t-x)+1)). Complete integral F_j(x) for integer j Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• j (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11547

static VALUE
sf_s_fermi_dirac_int(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_int, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.fermi_dirac_int_e(j, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral with an integer index of j, F_j(x) = (1/\Gamma(j+1)) \int_0^\infty dt (t^j /(\exp(t-x)+1)). Complete integral F_j(x) for integer j Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• j (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11598

static VALUE
sf_s_fermi_dirac_int_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_int_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //j
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.fermi_dirac_m1(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral with an index of -1. This integral is given by $F_-1(x) = e^x / (1 + e^x)$ F_-1 = e^x / (1 + e^x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11190

static VALUE
sf_s_fermi_dirac_m1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_m1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_m1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral with an index of -1. This integral is given by $F_-1(x) = e^x / (1 + e^x)$ F_-1 = e^x / (1 + e^x). Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11234

static VALUE
sf_s_fermi_dirac_m1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_m1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.fermi_dirac_mhalf(x) ⇒ DFloat

These routines compute the complete Fermi-Dirac integral $F_-1/2(x)$ F_-1/2. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11648

static VALUE
sf_s_fermi_dirac_mhalf(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_mhalf, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.fermi_dirac_mhalf_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complete Fermi-Dirac integral $F_-1/2(x)$ F_-1/2. Exceptional Return Values: GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11691

static VALUE
sf_s_fermi_dirac_mhalf_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_fermi_dirac_mhalf_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.gamma(x) ⇒ DFloat

These routines compute the Gamma function \Gamma(x), subject to x not being a negative integer or zero. The function is computed using the real Lanczos method. The maximum value of x such that \Gamma(x) is not considered an overflow is given by the macro GSL_SF_GAMMA_XMAX and is 171.0. exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EROUND

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1453

static VALUE
sf_s_gamma(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gamma, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.gamma_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Gamma function \Gamma(x), subject to x not being a negative integer or zero. The function is computed using the real Lanczos method. The maximum value of x such that \Gamma(x) is not considered an overflow is given by the macro GSL_SF_GAMMA_XMAX and is 171.0. exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EROUND

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1498

static VALUE
sf_s_gamma_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.gamma_inc(a, x) ⇒ DFloat

These functions compute the unnormalized incomplete Gamma Function $\Gamma(a,x) = \int_x^\infty dt\, t^(a-1) \exp(-t)$ \Gamma(a,x) = \int_x^\infty dt t^[a-1] \exp(-t) for a real and $x \ge 0$ x >= 0. exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2943

static VALUE
sf_s_gamma_inc(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_inc, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.gamma_inc_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions compute the unnormalized incomplete Gamma Function $\Gamma(a,x) = \int_x^\infty dt\, t^(a-1) \exp(-t)$ \Gamma(a,x) = \int_x^\infty dt t^[a-1] \exp(-t) for a real and $x \ge 0$ x >= 0. exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2991

static VALUE
sf_s_gamma_inc_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_inc_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.gamma_inc_P(a, x) ⇒ DFloat

These routines compute the complementary normalized incomplete Gamma Function $P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt\, t^(a-1) \exp(-t)$ P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0.

Note that Abramowitz & Stegun call P(a,x) the incomplete gamma function (section 6.5). exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3144

static VALUE
sf_s_gamma_inc_P(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_inc_P, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.gamma_inc_P_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the complementary normalized incomplete Gamma Function $P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt\, t^(a-1) \exp(-t)$ P(a,x) = 1 - Q(a,x) = 1/\Gamma(a) \int_0^x dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0.

Note that Abramowitz & Stegun call P(a,x) the incomplete gamma function (section 6.5). exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3195

static VALUE
sf_s_gamma_inc_P_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_inc_P_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.gamma_inc_Q(a, x) ⇒ DFloat

These routines compute the normalized incomplete Gamma Function $Q(a,x) = 1/\Gamma(a) \int_x^\infty dt\, t^(a-1) \exp(-t)$ Q(a,x) = 1/\Gamma(a) \int_x^\infty dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0. exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3042

static VALUE
sf_s_gamma_inc_Q(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_inc_Q, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.gamma_inc_Q_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the normalized incomplete Gamma Function $Q(a,x) = 1/\Gamma(a) \int_x^\infty dt\, t^(a-1) \exp(-t)$ Q(a,x) = 1/\Gamma(a) \int_x^\infty dt t^[a-1] \exp(-t) for a > 0, $x \ge 0$ x >= 0. exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3090

static VALUE
sf_s_gamma_inc_Q_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gamma_inc_Q_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.gammainv(x) ⇒ DFloat

These routines compute the reciprocal of the gamma function, 1/\Gamma(x) using the real Lanczos method. exceptions: GSL_EUNDRFLW, GSL_EROUND

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1785

static VALUE
sf_s_gammainv(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gammainv, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.gammainv_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the reciprocal of the gamma function, 1/\Gamma(x) using the real Lanczos method. exceptions: GSL_EUNDRFLW, GSL_EROUND

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1827

static VALUE
sf_s_gammainv_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gammainv_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.gammastar(x) ⇒ DFloat

These routines compute the regulated Gamma Function \Gamma^*(x) for x > 0. The regulated gamma function is given by,

\Gamma^*(x) = \Gamma(x)/(\sqrt[2\pi] x^[(x-1/2)] \exp(-x)) = (1 + (1/12x) + …) for x \to \infty and is a useful suggestion of Temme. exceptions: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1694

static VALUE
sf_s_gammastar(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gammastar, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.gammastar_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the regulated Gamma Function \Gamma^*(x) for x > 0. The regulated gamma function is given by,

\Gamma^*(x) = \Gamma(x)/(\sqrt[2\pi] x^[(x-1/2)] \exp(-x)) = (1 + (1/12x) + …) for x \to \infty and is a useful suggestion of Temme. exceptions: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1740

static VALUE
sf_s_gammastar_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gammastar_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.gegenpoly_1(lambda, x) ⇒ DFloat

These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3. Exceptional Return Values: none

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6671

static VALUE
sf_s_gegenpoly_1(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_1, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.gegenpoly_1_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3. Exceptional Return Values: none

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6808

static VALUE
sf_s_gegenpoly_1_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.gegenpoly_2(lambda, x) ⇒ DFloat

These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3. Exceptional Return Values: none

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6716

static VALUE
sf_s_gegenpoly_2(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_2, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.gegenpoly_2_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3. Exceptional Return Values: none

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6860

static VALUE
sf_s_gegenpoly_2_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.gegenpoly_3(lambda, x) ⇒ DFloat

These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3. Exceptional Return Values: none

Parameters:

• lambda (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6761

static VALUE
sf_s_gegenpoly_3(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_3, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.gegenpoly_3_e(lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) using explicit representations for n =1, 2, 3. Exceptional Return Values: none

Parameters:

• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6912

static VALUE
sf_s_gegenpoly_3_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_3_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.gegenpoly_array(nmax, lambda, x) ⇒ [Numo::DFloat, Numo::Int]

This function computes an array of Gegenbauer polynomials $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) for n = 0, 1, 2, \dots, nmax, subject to \lambda > -1/2, $nmax \ge 0$ nmax >= 0. Conditions: n = 0, 1, 2, … nmax Domain: lambda > -1/2, nmax >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• nmax (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7090

static VALUE
sf_s_gegenpoly_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //nmax
    
    if (c0<0) {
        rb_raise(rb_eArgError,"should be kmax>=0");
    }
    shape[0] = c0+1;
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.gegenpoly_n(n, lambda, x) ⇒ Numo::DFloat

These functions evaluate the Gegenbauer polynomial $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) for a specific value of n, lambda, x subject to \lambda > -1/2, $n \ge 0$ n >= 0. Domain: lambda > -1/2, n >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6966

static VALUE
sf_s_gegenpoly_n(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_n,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.gegenpoly_n_e(n, lambda, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Gegenbauer polynomial $C^(\lambda)_n(x)$ C^[(\lambda)]_n(x) for a specific value of n, lambda, x subject to \lambda > -1/2, $n \ge 0$ n >= 0. Domain: lambda > -1/2, n >= 0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)
• lambda (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7027

static VALUE
sf_s_gegenpoly_n_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_gegenpoly_n_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.hazard(x) ⇒ DFloat

These routines compute the hazard function for the normal distribution. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9015

static VALUE
sf_s_hazard(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hazard, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.hazard_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the hazard function for the normal distribution. Exceptional Return Values: GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9056

static VALUE
sf_s_hazard_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hazard_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.hydrogenicR(n, l, Z, r) ⇒ DFloat

These routines compute the n-th normalized hydrogenic bound state radial wavefunction,

R_n := 2 (Z^[3/2]/n^2) \sqrt[(n-l-1)!/(n+l)!] \exp(-Z r/n) (2Zr/n)^l L^[2l+1]_n-l-1.

where L^a_b(x) is the generalized Laguerre polynomial (Laguerre Functions). The normalization is chosen such that the wavefunction \psi is given by $\psi(n,l,r) = R_n Y_lm$ \psi(n,l,r) = R_n Y_[lm].

Parameters:

• n (Integer) —

  parameter

• l (Integer) —

  parameter

• Z (DFloat)
• r (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17121

static VALUE
sf_s_hydrogenicR(VALUE mod, VALUE v0, VALUE v1, VALUE v2, VALUE v3)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hydrogenicR, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};
    int opts[2];

    opts[0] = NUM2INT(v0);
    opts[1] = NUM2INT(v1);

    return na_ndloop3(&ndf, opts, 2, v2, v3);
}

.hydrogenicR_1(Z, r) ⇒ DFloat

These routines compute the lowest-order normalized hydrogenic bound state radial wavefunction $R_1 := 2Z \sqrtZ \exp(-Z r)$ R_1 := 2Z \sqrt[Z] \exp(-Z r).

Parameters:

• Z (DFloat)
• r (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17016

static VALUE
sf_s_hydrogenicR_1(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hydrogenicR_1, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.hydrogenicR_1_e(Z, r) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the lowest-order normalized hydrogenic bound state radial wavefunction $R_1 := 2Z \sqrtZ \exp(-Z r)$ R_1 := 2Z \sqrt[Z] \exp(-Z r).

Parameters:

• Z (Numo::DFloat)
• r (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17061

static VALUE
sf_s_hydrogenicR_1_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hydrogenicR_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.hydrogenicR_e(n, l, Z, r) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the n-th normalized hydrogenic bound state radial wavefunction,

R_n := 2 (Z^[3/2]/n^2) \sqrt[(n-l-1)!/(n+l)!] \exp(-Z r/n) (2Zr/n)^l L^[2l+1]_n-l-1.

where L^a_b(x) is the generalized Laguerre polynomial (Laguerre Functions). The normalization is chosen such that the wavefunction \psi is given by $\psi(n,l,r) = R_n Y_lm$ \psi(n,l,r) = R_n Y_[lm].

Parameters:

• n (Integer)
• l (Integer)
• Z (Numo::DFloat)
• r (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 17187

static VALUE
sf_s_hydrogenicR_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hydrogenicR_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //n
    c1 = NUM2INT(v1); opt[1] = &c1; //l
    
    
    return na_ndloop3(&ndf,opt,2,v2,v3); 
}

.hyperg_0F1(c, x) ⇒ DFloat

These routines compute the hypergeometric function ${}0F_1(c,x)$ 0F1(c,x). It is related to Bessel functions 0F1[c,x] = Gamma[c] x^(1/2(1-c)) I(c-1)(2 Sqrt[x]) Gamma[c] (-x)^(1/2(1-c)) J_(c-1)(2 Sqrt[-x]) exceptions: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• c (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22516

static VALUE
sf_s_hyperg_0F1(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_0F1, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.hyperg_0F1_e(c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the hypergeometric function ${}0F_1(c,x)$ 0F1(c,x). It is related to Bessel functions 0F1[c,x] = Gamma[c] x^(1/2(1-c)) I(c-1)(2 Sqrt[x]) Gamma[c] (-x)^(1/2(1-c)) J_(c-1)(2 Sqrt[-x]) exceptions: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22565

static VALUE
sf_s_hyperg_0F1_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_0F1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.hyperg_1F1(a, b, x) ⇒ DFloat

These routines compute the confluent hypergeometric function ${}_1F_1(a,b,x) = M(a,b,x)$ 1F1(a,b,x) = M(a,b,x) for general parameters a, b. exceptions:

Parameters:

• a (DFloat)
• b (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22742

static VALUE
sf_s_hyperg_1F1(VALUE mod, VALUE v0, VALUE v1, VALUE v2)
{
    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_1F1, STRIDE_LOOP|NDF_EXTRACT, 3,1, ain,aout};

    return na_ndloop(&ndf, 3, v0, v1, v2);
}

.hyperg_1F1_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the confluent hypergeometric function ${}_1F_1(a,b,x) = M(a,b,x)$ 1F1(a,b,x) = M(a,b,x) for general parameters a, b. exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22791

static VALUE
sf_s_hyperg_1F1_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_1F1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    
    return na_ndloop(&ndf,3,v0,v1,v2); 
}

.hyperg_1F1_int(m, n, x) ⇒ Numo::DFloat

These routines compute the confluent hypergeometric function ${}_1F_1(m,n,x) = M(m,n,x)$ 1F1(m,n,x) = M(m,n,x) for integer parameters m, n. exceptions:

Parameters:

• m (Integer)
• n (Integer)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22619

static VALUE
sf_s_hyperg_1F1_int(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_1F1_int,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,1,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //m
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.hyperg_1F1_int_e(m, n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the confluent hypergeometric function ${}_1F_1(m,n,x) = M(m,n,x)$ 1F1(m,n,x) = M(m,n,x) for integer parameters m, n. exceptions:

Parameters:

• m (Integer)
• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22683

static VALUE
sf_s_hyperg_1F1_int_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_1F1_int_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //m
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.hyperg_2F0(a, b, x) ⇒ DFloat

These routines compute the hypergeometric function ${}_2F_0(a,b,x)$ 2F0(a,b,x). The series representation is a divergent hypergeometric series. However, for x < 0 we have ${}_2F_0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x)$ 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x) exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• b (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23637

static VALUE
sf_s_hyperg_2F0(VALUE mod, VALUE v0, VALUE v1, VALUE v2)
{
    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F0, STRIDE_LOOP|NDF_EXTRACT, 3,1, ain,aout};

    return na_ndloop(&ndf, 3, v0, v1, v2);
}

.hyperg_2F0_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the hypergeometric function ${}_2F_0(a,b,x)$ 2F0(a,b,x). The series representation is a divergent hypergeometric series. However, for x < 0 we have ${}_2F_0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x)$ 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x) exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23689

static VALUE
sf_s_hyperg_2F0_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    
    return na_ndloop(&ndf,3,v0,v1,v2); 
}

.hyperg_2F1(a, b, c, x) ⇒ Numo::DFloat

These routines compute the Gauss hypergeometric function ${}_2F_1(a,b,c,x) = F(a,b,c,x)$ 2F1(a,b,c,x) = F(a,b,c,x) for |x| < 1.

If the arguments (a,b,c,x) are too close to a singularity then the function can return the error code GSL_EMAXITER when the series approximation converges too slowly. This occurs in the region of x=1, c - a - b = m for integer m. exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23187

static VALUE
sf_s_hyperg_2F1(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,1,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_conj(aR, aI, c, x) ⇒ Numo::DFloat

These routines compute the Gauss hypergeometric function ${}_2F_1(a_R + i a_I, aR - i aI, c, x)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) with complex parameters for |x| < 1.

Parameters:

• aR (Numo::DFloat)
• aI (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23303

static VALUE
sf_s_hyperg_2F1_conj(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_conj,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,1,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_conj_e(aR, aI, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Gauss hypergeometric function ${}_2F_1(a_R + i a_I, aR - i aI, c, x)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) with complex parameters for |x| < 1.

Parameters:

• aR (Numo::DFloat)
• aI (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23360

static VALUE
sf_s_hyperg_2F1_conj_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_conj_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_conj_renorm(aR, aI, c, x) ⇒ Numo::DFloat

These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c) for |x| < 1. exceptions:

Parameters:

• aR (Numo::DFloat)
• aI (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23525

static VALUE
sf_s_hyperg_2F1_conj_renorm(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_conj_renorm,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,1,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_conj_renorm_e(aR, aI, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c)$ 2F1(a_R + i a_I, a_R - i a_I, c, x) / \Gamma(c) for |x| < 1. exceptions:

Parameters:

• aR (Numo::DFloat)
• aI (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23582

static VALUE
sf_s_hyperg_2F1_conj_renorm_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_conj_renorm_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_e(a, b, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Gauss hypergeometric function ${}_2F_1(a,b,c,x) = F(a,b,c,x)$ 2F1(a,b,c,x) = F(a,b,c,x) for |x| < 1.

If the arguments (a,b,c,x) are too close to a singularity then the function can return the error code GSL_EMAXITER when the series approximation converges too slowly. This occurs in the region of x=1, c - a - b = m for integer m. exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23249

static VALUE
sf_s_hyperg_2F1_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_renorm(a, b, c, x) ⇒ Numo::DFloat

These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a,b,c,x) / \Gamma(c)$ 2F1(a,b,c,x) / \Gamma(c) for |x| < 1. exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23414

static VALUE
sf_s_hyperg_2F1_renorm(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_renorm,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,1,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_2F1_renorm_e(a, b, c, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the renormalized Gauss hypergeometric function ${}_2F_1(a,b,c,x) / \Gamma(c)$ 2F1(a,b,c,x) / \Gamma(c) for |x| < 1. exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• c (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23471

static VALUE
sf_s_hyperg_2F1_renorm_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_2F1_renorm_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.hyperg_U(a, b, x) ⇒ DFloat

These routines compute the confluent hypergeometric function U(a,b,x). exceptions:

Parameters:

• a (DFloat)
• b (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23027

static VALUE
sf_s_hyperg_U(VALUE mod, VALUE v0, VALUE v1, VALUE v2)
{
    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_U, STRIDE_LOOP|NDF_EXTRACT, 3,1, ain,aout};

    return na_ndloop(&ndf, 3, v0, v1, v2);
}

.hyperg_U_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the confluent hypergeometric function U(a,b,x). exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23074

static VALUE
sf_s_hyperg_U_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_U_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,3,ain,aout};
    
    
    return na_ndloop(&ndf,3,v0,v1,v2); 
}

.hyperg_U_e10_e(a, b, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

This routine computes the confluent hypergeometric function U(a,b,x) using the gsl_sf_result_e10 type to return a result with extended range. exceptions:

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]) —

  array of [result.val, result.err, result.e10, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23128

static VALUE
sf_s_hyperg_U_e10_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    

    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cI,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_U_e10_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    3,4,ain,aout};
    
    
    return na_ndloop(&ndf,3,v0,v1,v2); 
}

.hyperg_U_int(m, n, x) ⇒ Numo::DFloat

These routines compute the confluent hypergeometric function U(m,n,x) for integer parameters m, n. exceptions:

Parameters:

• m (Integer)
• n (Integer)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22844

static VALUE
sf_s_hyperg_U_int(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_U_int,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,1,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //m
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.hyperg_U_int_e(m, n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the confluent hypergeometric function U(m,n,x) for integer parameters m, n. exceptions:

Parameters:

• m (Integer)
• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22907

static VALUE
sf_s_hyperg_U_int_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_U_int_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //m
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.hyperg_U_int_e10_e(m, n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]

This routine computes the confluent hypergeometric function U(m,n,x) for integer parameters m, n using the gsl_sf_result_e10 type to return a result with extended range.

Parameters:

• m (Integer)
• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int, Numo::Int]) —

  array of [result.val, result.err, result.e10, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22970

static VALUE
sf_s_hyperg_U_int_e10_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cI,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hyperg_U_int_e10_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //m
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.hypot(x, y) ⇒ DFloat

These routines compute the hypotenuse function $\sqrt+ y^2$ \sqrt[x^2 + y^2] avoiding overflow and underflow. Exceptional Return Values:

Parameters:

• x (DFloat)
• y (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 639

static VALUE
sf_s_hypot(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hypot, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.hypot_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the hypotenuse function $\sqrt+ y^2$ \sqrt[x^2 + y^2] avoiding overflow and underflow. Exceptional Return Values:

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 684

static VALUE
sf_s_hypot_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hypot_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.hzeta(s, q) ⇒ DFloat

These routines compute the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0. Domain: s > 1.0, q > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• s (DFloat)
• q (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19340

static VALUE
sf_s_hzeta(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_hzeta, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.hzeta_e(s, q) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0. Domain: s > 1.0, q > 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW

Parameters:

• s (Numo::DFloat)
• q (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19386

static VALUE
sf_s_hzeta_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_hzeta_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.laguerre_1(a, x) ⇒ DFloat

These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations. Exceptional Return Values: none

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6262

static VALUE
sf_s_laguerre_1(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_1, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.laguerre_1_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations. Exceptional Return Values: none

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6396

static VALUE
sf_s_laguerre_1_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.laguerre_2(a, x) ⇒ DFloat

These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations. Exceptional Return Values: none

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6306

static VALUE
sf_s_laguerre_2(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_2, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.laguerre_2_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations. Exceptional Return Values: none

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6447

static VALUE
sf_s_laguerre_2_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.laguerre_3(a, x) ⇒ DFloat

These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations. Exceptional Return Values: none

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6350

static VALUE
sf_s_laguerre_3(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_3, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.laguerre_3_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines evaluate the generalized Laguerre polynomials L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations. Exceptional Return Values: none

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6498

static VALUE
sf_s_laguerre_3_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_3_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.laguerre_n(n, a, x) ⇒ Numo::DFloat

These routines evaluate the generalized Laguerre polynomials L^a_n(x) for a > -1, $n \ge 0$ n >= 0.

Domain: a > -1.0, n >= 0 Evaluate generalized Laguerre polynomials. Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)
• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6554

static VALUE
sf_s_laguerre_n(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_n,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.laguerre_n_e(n, a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines evaluate the generalized Laguerre polynomials L^a_n(x) for a > -1, $n \ge 0$ n >= 0.

Domain: a > -1.0, n >= 0 Evaluate generalized Laguerre polynomials. Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)
• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6617

static VALUE
sf_s_laguerre_n_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_laguerre_n_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.lambert_W0(x) ⇒ DFloat

These compute the principal branch of the Lambert W function, W_0(x). exceptions: GSL_EDOM, GSL_EMAXITER

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23816

static VALUE
sf_s_lambert_W0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lambert_W0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lambert_W0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These compute the principal branch of the Lambert W function, W_0(x). exceptions: GSL_EDOM, GSL_EMAXITER

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23857

static VALUE
sf_s_lambert_W0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lambert_W0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.lambert_Wm1(x) ⇒ DFloat

These compute the secondary real-valued branch of the Lambert W function, $W_-1(x)$ W_-1. exceptions: GSL_EDOM, GSL_EMAXITER

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23903

static VALUE
sf_s_lambert_Wm1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lambert_Wm1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lambert_Wm1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These compute the secondary real-valued branch of the Lambert W function, $W_-1(x)$ W_-1. exceptions: GSL_EDOM, GSL_EMAXITER

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 23946

static VALUE
sf_s_lambert_Wm1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lambert_Wm1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.legendre_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre polynomials for 0 \le l \le lmax and 0 \le m \le l for $|x| \le 1$ |x| <= 1. The norm parameter specifies which normalization is used. The normalized P_l^m(x) values are stored in result_array, whose minimum size can be obtained from calling gsl_sf_legendre_array_n. The array index of P_l^m(x) is obtained from calling gsl_sf_legendre_array_index(l, m). To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20398

static VALUE
sf_s_legendre_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre polynomials for 0 \le l \le lmax and 0 \le m \le l for $|x| \le 1$ |x| <= 1. The norm parameter specifies which normalization is used. The normalized P_l^m(x) values are stored in result_array, whose minimum size can be obtained from calling gsl_sf_legendre_array_n. The array index of P_l^m(x) is obtained from calling gsl_sf_legendre_array_index(l, m). To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)
• csphase (Float) —

  To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively.

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20475

static VALUE
sf_s_legendre_array_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    double c3;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_array_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt[3];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    c3 = NUM2DBL(v3); opt[2] = &c3; //csphase
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_array_index(l, m) ⇒ Integer

This function returns the index into result_array, result_deriv_array, or result_deriv2_array corresponding to P_l^m(x), P_l^‘m(x), or P_l^‘‘m(x). The index is given by l(l+1)/2 + m.

Parameters:

• l (Integer)
• m (Integer)

Returns:

• (Integer) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21186

static VALUE
sf_s_legendre_array_index(VALUE mod,VALUE v0,VALUE v1)
{
    
    size_t c0;
    size_t c1;
    size_t c2;
    
    c0 = NUM2SIZET(v0);
    c1 = NUM2SIZET(v1);
    c2 = gsl_sf_legendre_array_index(c0,c1);
    
    return SIZET2NUM(c2);
    
}

.legendre_array_n(lmax) ⇒ Integer

This function returns the minimum array size for maximum degree lmax needed for the array versions of the associated Legendre functions. Size is calculated as the total number of P_l^m(x) functions, plus extra space for precomputing multiplicative factors used in the recurrence relations.

Parameters:

• lmax (Integer)

Returns:

• (Integer) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21158

static VALUE
sf_s_legendre_array_n(VALUE mod,VALUE v0)
{
    
    size_t c0;
    size_t c1;
    
    c0 = NUM2SIZET(v0);
    c1 = gsl_sf_legendre_array_n(c0);
    
    return SIZET2NUM(c1);
    
}

.legendre_deriv2_alt_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their (alternate) first and second derivatives up to degree lmax for $|x| < 1$ |x| < 1. The parameter norm specifies the normalization used. The normalized P_l^m(x), their first derivatives dP_l^m(\cos\theta)/d\theta, and their second derivatives d^2 P_l^m(\cos\theta)/d\theta^2 are stored in result_array, result_deriv_array, and result_deriv2_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], result_deriv2_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21035

static VALUE
sf_s_legendre_deriv2_alt_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,1,shape},{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv2_alt_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv2_alt_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their (alternate) first and second derivatives up to degree lmax for $|x| < 1$ |x| < 1. The parameter norm specifies the normalization used. The normalized P_l^m(x), their first derivatives dP_l^m(\cos\theta)/d\theta, and their second derivatives d^2 P_l^m(\cos\theta)/d\theta^2 are stored in result_array, result_deriv_array, and result_deriv2_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)
• csphase (Float) —

  To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], result_deriv2_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21119

static VALUE
sf_s_legendre_deriv2_alt_array_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    double c3;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,1,shape},{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv2_alt_array_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    void *opt[3];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    c3 = NUM2DBL(v3); opt[2] = &c3; //csphase
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv2_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their first and second derivatives up to degree lmax for $|x| < 1$ |x| < 1. The parameter norm specifies the normalization used. The normalized P_l^m(x), their first derivatives dP_l^m(x)/dx, and their second derivatives d^2 P_l^m(x)/dx^2 are stored in result_array, result_deriv_array, and result_deriv2_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], result_deriv2_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20869

static VALUE
sf_s_legendre_deriv2_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,1,shape},{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv2_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv2_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their first and second derivatives up to degree lmax for $|x| < 1$ |x| < 1. The parameter norm specifies the normalization used. The normalized P_l^m(x), their first derivatives dP_l^m(x)/dx, and their second derivatives d^2 P_l^m(x)/dx^2 are stored in result_array, result_deriv_array, and result_deriv2_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)
• csphase (Float) —

  To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], result_deriv2_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20952

static VALUE
sf_s_legendre_deriv2_array_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    double c3;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,1,shape},{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv2_array_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    void *opt[3];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    c3 = NUM2DBL(v3); opt[2] = &c3; //csphase
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv_alt_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their (alternate) first derivatives up to degree lmax for $|x| < 1$ |x| < 1. The normalized P_l^m(x) values and their derivatives dP_l^m(\cos\theta)/d\theta are stored in result_array and result_deriv_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20709

static VALUE
sf_s_legendre_deriv_alt_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv_alt_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv_alt_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their (alternate) first derivatives up to degree lmax for $|x| < 1$ |x| < 1. The normalized P_l^m(x) values and their derivatives dP_l^m(\cos\theta)/d\theta are stored in result_array and result_deriv_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)
• csphase (Float) —

  To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20787

static VALUE
sf_s_legendre_deriv_alt_array_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    double c3;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv_alt_array_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[3];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    c3 = NUM2DBL(v3); opt[2] = &c3; //csphase
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv_array(norm, lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their first derivatives up to degree lmax for $|x| < 1$ |x| < 1. The parameter norm specifies the normalization used. The normalized P_l^m(x) values and their derivatives dP_l^m(x)/dx are stored in result_array and result_deriv_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20553

static VALUE
sf_s_legendre_deriv_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_deriv_array_e(norm, lmax, x, csphase) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions calculate all normalized associated Legendre functions and their first derivatives up to degree lmax for $|x| < 1$ |x| < 1. The parameter norm specifies the normalization used. The normalized P_l^m(x) values and their derivatives dP_l^m(x)/dx are stored in result_array and result_deriv_array respectively. To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Parameters:

• norm (Integer) —

  Type of normalization to use. The possible values are: Numo::GSL::Sf::Legendre::NONE, Numo::GSL::Sf::Legendre::SCHMIDT, Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL

• lmax (Integer)
• x (Numo::DFloat)
• csphase (Float) —

  To include or exclude the Condon-Shortley phase factor of (-1)^m, set the parameter csphase to either -1 or 1 respectively.

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20632

static VALUE
sf_s_legendre_deriv_array_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    gsl_sf_legendre_t c0;
    size_t c1;
    double c3;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_deriv_array_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[3];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //norm
    c1 = NUM2SIZET(v1); opt[1] = &c1; //lmax
    c3 = NUM2DBL(v3); opt[2] = &c3; //csphase
    
    shape[0] = gsl_sf_legendre_array_n(c1);    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_H3d(l, lambda, eta) ⇒ Numo::DFloat

These routines compute the l-th radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space $\eta \ge 0$ \eta >= 0, $l \ge 0$ l >= 0. In the flat limit this takes the form $L^H3d_l(\lambda,\eta) = j_l(\lambda\eta)$ L^[H3d]_l(\lambda,\eta) = j_l(\lambda\eta). Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• lambda (Numo::DFloat)
• eta (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22336

static VALUE
sf_s_legendre_H3d(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.legendre_H3d_0(lambda, eta) ⇒ DFloat

These routines compute the zeroth radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_0(\lambda,\eta) := \over \lambda\sinh(\eta)$ L^[H3d]_0(\lambda,\eta) := \sin(\lambda\eta)/(\lambda\sinh(\eta)) for $\eta \ge 0$ \eta >= 0. In the flat limit this takes the form $L^H3d_0(\lambda,\eta) = j_0(\lambda\eta)$ L^[H3d]_0(\lambda,\eta) = j_0(\lambda\eta). Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (DFloat)
• eta (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22122

static VALUE
sf_s_legendre_H3d_0(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d_0, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.legendre_H3d_0_e(lambda, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the zeroth radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_0(\lambda,\eta) := \over \lambda\sinh(\eta)$ L^[H3d]_0(\lambda,\eta) := \sin(\lambda\eta)/(\lambda\sinh(\eta)) for $\eta \ge 0$ \eta >= 0. In the flat limit this takes the form $L^H3d_0(\lambda,\eta) = j_0(\lambda\eta)$ L^[H3d]_0(\lambda,\eta) = j_0(\lambda\eta). Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (Numo::DFloat)
• eta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22174

static VALUE
sf_s_legendre_H3d_0_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d_0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.legendre_H3d_1(lambda, eta) ⇒ DFloat

These routines compute the first radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_1(\lambda,\eta) := + 1} \eta)\over \lambda \sinh(\eta)\right) \left(\coth(\eta) - \lambda \cot(\lambda\eta)\right)$ L^[H3d]_1(\lambda,\eta) := 1/\sqrt[\lambda^2 + 1] \sin(\lambda \eta)/(\lambda \sinh(\eta)) (\coth(\eta) - \lambda \cot(\lambda\eta)) for $\eta \ge 0$ \eta >= 0. In the flat limit this takes the form $L^H3d_1(\lambda,\eta) = j_1(\lambda\eta)$ L^[H3d]_1(\lambda,\eta) = j_1(\lambda\eta). Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (DFloat)
• eta (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22229

static VALUE
sf_s_legendre_H3d_1(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d_1, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.legendre_H3d_1_e(lambda, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the first radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space, $L^H3d_1(\lambda,\eta) := + 1} \eta)\over \lambda \sinh(\eta)\right) \left(\coth(\eta) - \lambda \cot(\lambda\eta)\right)$ L^[H3d]_1(\lambda,\eta) := 1/\sqrt[\lambda^2 + 1] \sin(\lambda \eta)/(\lambda \sinh(\eta)) (\coth(\eta) - \lambda \cot(\lambda\eta)) for $\eta \ge 0$ \eta >= 0. In the flat limit this takes the form $L^H3d_1(\lambda,\eta) = j_1(\lambda\eta)$ L^[H3d]_1(\lambda,\eta) = j_1(\lambda\eta). Exceptional Return Values: GSL_EDOM

Parameters:

• lambda (Numo::DFloat)
• eta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22281

static VALUE
sf_s_legendre_H3d_1_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.legendre_H3d_array(lmax, lambda, eta) ⇒ [Numo::DFloat, Numo::Int]

This function computes an array of radial eigenfunctions $L^H3d_l( \lambda, \eta)$ L^[H3d]_l(\lambda, \eta) for $0 \le l \le lmax$ 0 <= l <= lmax. Exceptional Return Values:

Parameters:

• lmax (Integer)
• lambda (Numo::DFloat)
• eta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22459

static VALUE
sf_s_legendre_H3d_array(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c0);    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.legendre_H3d_e(l, lambda, eta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the l-th radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space $\eta \ge 0$ \eta >= 0, $l \ge 0$ l >= 0. In the flat limit this takes the form $L^H3d_l(\lambda,\eta) = j_l(\lambda\eta)$ L^[H3d]_l(\lambda,\eta) = j_l(\lambda\eta). Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• lambda (Numo::DFloat)
• eta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 22398

static VALUE
sf_s_legendre_H3d_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_H3d_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.legendre_P1(x) ⇒ DFloat

These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19591

static VALUE
sf_s_legendre_P1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_P1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.legendre_P1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19719

static VALUE
sf_s_legendre_P1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_P1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.legendre_P2(x) ⇒ DFloat

These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19633

static VALUE
sf_s_legendre_P2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_P2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.legendre_P2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19768

static VALUE
sf_s_legendre_P2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_P2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.legendre_P3(x) ⇒ DFloat

These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19675

static VALUE
sf_s_legendre_P3(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_P3, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.legendre_P3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Legendre polynomials $P_l(x)$ P_l(x) using explicit representations for l=1, 2, 3. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19817

static VALUE
sf_s_legendre_P3_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_P3_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.legendre_Pl(l, x) ⇒ DFloat

These functions evaluate the Legendre polynomial $P_l(x)$ P_l(x) for a specific value of l, x subject to $l \ge 0$ l >= 0, $|x| \le 1$ |x| <= 1 Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19869

static VALUE
sf_s_legendre_Pl(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Pl, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.legendre_Pl_array(lmax, x) ⇒ [Numo::DFloat, Numo::Int]

These functions compute arrays of Legendre polynomials P_l(x) and derivatives dP_l(x)/dx, for l = 0, \dots, lmax, $|x| \le 1$ |x| <= 1 Exceptional Return Values: GSL_EDOM

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::Int]) —

  array of [result_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19981

static VALUE
sf_s_legendre_Pl_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[2] = {{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Pl_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,2,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c0);    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.legendre_Pl_deriv_array(lmax, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions compute arrays of Legendre polynomials P_l(x) and derivatives dP_l(x)/dx, for l = 0, \dots, lmax, $|x| \le 1$ |x| <= 1 Exceptional Return Values: GSL_EDOM

Parameters:

• lmax (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_array[], result_deriv_array[], return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20044

static VALUE
sf_s_legendre_Pl_deriv_array(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    
    size_t shape[1]; 

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,1,shape},{cDF,1,shape},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Pl_deriv_array,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //lmax
    
    shape[0] = gsl_sf_legendre_array_n(c0);    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.legendre_Pl_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These functions evaluate the Legendre polynomial $P_l(x)$ P_l(x) for a specific value of l, x subject to $l \ge 0$ l >= 0, $|x| \le 1$ |x| <= 1 Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19922

static VALUE
sf_s_legendre_Pl_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Pl_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.legendre_Plm(l, m, x) ⇒ Numo::DFloat

These routines compute the associated Legendre polynomial P_l^m(x) for $m \ge 0$ m >= 0, $l \ge m$ l >= m, $|x| \le 1$ |x| <= 1. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• l (Integer)
• m (Integer)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21243

static VALUE
sf_s_legendre_Plm(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Plm,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,1,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //l
    c1 = NUM2INT(v1); opt[1] = &c1; //m
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_Plm_e(l, m, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the associated Legendre polynomial P_l^m(x) for $m \ge 0$ m >= 0, $l \ge m$ l >= m, $|x| \le 1$ |x| <= 1. Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• l (Integer)
• m (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21309

static VALUE
sf_s_legendre_Plm_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Plm_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //l
    c1 = NUM2INT(v1); opt[1] = &c1; //m
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_Q0(x) ⇒ DFloat

These routines compute the Legendre function Q_0(x) for x > -1, $x \ne 1$ x != 1. Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20095

static VALUE
sf_s_legendre_Q0(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Q0, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.legendre_Q0_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Legendre function Q_0(x) for x > -1, $x \ne 1$ x != 1. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20138

static VALUE
sf_s_legendre_Q0_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Q0_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.legendre_Q1(x) ⇒ DFloat

These routines compute the Legendre function Q_1(x) for x > -1, $x \ne 1$ x != 1. Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20184

static VALUE
sf_s_legendre_Q1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Q1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.legendre_Q1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Legendre function Q_1(x) for x > -1, $x \ne 1$ x != 1. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20227

static VALUE
sf_s_legendre_Q1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Q1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.legendre_Ql(l, x) ⇒ DFloat

These routines compute the Legendre function Q_l(x) for x > -1, $x \ne 1$ x != 1 and $l \ge 0$ l >= 0. Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20277

static VALUE
sf_s_legendre_Ql(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Ql, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.legendre_Ql_e(l, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Legendre function Q_l(x) for x > -1, $x \ne 1$ x != 1 and $l \ge 0$ l >= 0. Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 20328

static VALUE
sf_s_legendre_Ql_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_Ql_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //l
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.legendre_sphPlm(l, m, x) ⇒ Numo::DFloat

These routines compute the normalized associated Legendre polynomial $\sqrt(2l+1)/(4\pi) \sqrt(l-m)!/(l+m)! P_l^m(x)$ \sqrt[(2l+1)/(4\pi)] \sqrt[(l-m)!/(l+m)!] P_l^m(x) suitable for use in spherical harmonics. The parameters must satisfy $m \ge 0$ m >= 0, $l \ge m$ l >= m, $|x| \le 1$ |x| <= 1. Theses routines avoid the overflows that occur for the standard normalization of P_l^m(x). Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• m (Integer)
• x (Numo::DFloat)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21375

static VALUE
sf_s_legendre_sphPlm(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_sphPlm,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,1,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //l
    c1 = NUM2INT(v1); opt[1] = &c1; //m
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.legendre_sphPlm_e(l, m, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the normalized associated Legendre polynomial $\sqrt(2l+1)/(4\pi) \sqrt(l-m)!/(l+m)! P_l^m(x)$ \sqrt[(2l+1)/(4\pi)] \sqrt[(l-m)!/(l+m)!] P_l^m(x) suitable for use in spherical harmonics. The parameters must satisfy $m \ge 0$ m >= 0, $l \ge m$ l >= m, $|x| \le 1$ |x| <= 1. Theses routines avoid the overflows that occur for the standard normalization of P_l^m(x). Exceptional Return Values: GSL_EDOM

Parameters:

• l (Integer)
• m (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 21444

static VALUE
sf_s_legendre_sphPlm_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_legendre_sphPlm_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //l
    c1 = NUM2INT(v1); opt[1] = &c1; //m
    
    
    return na_ndloop3(&ndf,opt,1,v2); 
}

.lnbeta(a, b) ⇒ DFloat

These routines compute the logarithm of the Beta Function, \log(B(a,b)) subject to a and b not being negative integers. exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• b (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3339

static VALUE
sf_s_lnbeta(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lnbeta, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.lnbeta_e(a, b) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the Beta Function, \log(B(a,b)) subject to a and b not being negative integers. exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• b (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3385

static VALUE
sf_s_lnbeta_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lnbeta_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.lnchoose(n, m) ⇒ Numo::DFloat

These routines compute the logarithm of n choose m. This is equivalent to the sum \log(n!) - \log(m!) - \log((n-m)!). exceptions: GSL_EDOM

Parameters:

• n (Numo::UInt)
• m (Numo::UInt)

Returns:

• (Numo::DFloat) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2396

static VALUE
sf_s_lnchoose(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cUI,0},{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lnchoose,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.lnchoose_e(n, m) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of n choose m. This is equivalent to the sum \log(n!) - \log(m!) - \log((n-m)!). exceptions: GSL_EDOM

Parameters:

• n (Numo::UInt)
• m (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2446

static VALUE
sf_s_lnchoose_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cUI,0},{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lnchoose_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.lncosh(x) ⇒ DFloat

These routines compute \log(\cosh(x)) for any x. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1062

static VALUE
sf_s_lncosh(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lncosh, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lncosh_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute \log(\cosh(x)) for any x. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1103

static VALUE
sf_s_lncosh_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lncosh_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.lndoublefact(n) ⇒ DFloat

These routines compute the logarithm of the double factorial of n, \log(n!!). exceptions: none

Parameters:

• n (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2210

static VALUE
sf_s_lndoublefact(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lndoublefact, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lndoublefact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the double factorial of n, \log(n!!). exceptions: none

Parameters:

• n (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2252

static VALUE
sf_s_lndoublefact_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lndoublefact_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.lnfact(n) ⇒ DFloat

These routines compute the logarithm of the factorial of n, \log(n!). The algorithm is faster than computing \ln(\Gamma(n+1)) via gsl_sf_lngamma for n < 170, but defers for larger n. exceptions: none

Parameters:

• n (UInt)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2120

static VALUE
sf_s_lnfact(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lnfact, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lnfact_e(n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the factorial of n, \log(n!). The algorithm is faster than computing \ln(\Gamma(n+1)) via gsl_sf_lngamma for n < 170, but defers for larger n. exceptions: none

Parameters:

• n (Numo::UInt)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2164

static VALUE
sf_s_lnfact_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cUI,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lnfact_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.lngamma(x) ⇒ DFloat

These routines compute the logarithm of the Gamma function, \log(\Gamma(x)), subject to x not being a negative integer or zero. For x<0 the real part of \log(\Gamma(x)) is returned, which is equivalent to \log(|\Gamma(x)|). The function is computed using the real Lanczos method. exceptions: GSL_EDOM, GSL_EROUND

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1546

static VALUE
sf_s_lngamma(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lngamma, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lngamma_complex_e(zr, zi) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This routine computes \log(\Gamma(z)) for complex z=z_r+i z_i and z not a negative integer or zero, using the complex Lanczos method. The returned parameters are lnr = \log|\Gamma(z)| and arg = \arg(\Gamma(z)) in (-\pi,\pi]. Note that the phase part (arg) is not well-determined when |z| is very large, due to inevitable roundoff in restricting to (-\pi,\pi]. This will result in a GSL_ELOSS error when it occurs. The absolute value part (lnr), however, never suffers from loss of precision. exceptions: GSL_EDOM, GSL_ELOSS

Parameters:

• zr (Numo::DFloat)
• zi (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [lnr.val, lnr.err, arg.val, arg.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1886

static VALUE
sf_s_lngamma_complex_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lngamma_complex_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.lngamma_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the Gamma function, \log(\Gamma(x)), subject to x not being a negative integer or zero. For x<0 the real part of \log(\Gamma(x)) is returned, which is equivalent to \log(|\Gamma(x)|). The function is computed using the real Lanczos method. exceptions: GSL_EDOM, GSL_EROUND

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1591

static VALUE
sf_s_lngamma_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lngamma_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.lngamma_sgn_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This routine computes the sign of the gamma function and the logarithm of its magnitude, subject to x not being a negative integer or zero. The function is computed using the real Lanczos method. The value of the gamma function and its error can be reconstructed using the relation \Gamma(x) = sgn * \exp(result_lg), taking into account the two components of result_lg. exceptions: GSL_EDOM, GSL_EROUND

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result_lg.val, result_lg.err, sgn, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1645

static VALUE
sf_s_lngamma_sgn_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lngamma_sgn_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,4,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.lnpoch(a, x) ⇒ DFloat

These routines compute the logarithm of the Pochhammer symbol, \log((a)_x) = \log(\Gamma(a + x)/\Gamma(a)). exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2698

static VALUE
sf_s_lnpoch(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lnpoch, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.lnpoch_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the Pochhammer symbol, \log((a)_x) = \log(\Gamma(a + x)/\Gamma(a)). exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2743

static VALUE
sf_s_lnpoch_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lnpoch_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.lnpoch_sgn_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the sign of the Pochhammer symbol and the logarithm of its magnitude. The computed parameters are result = \log(|(a)_x|) with a corresponding error term, and sgn = \sgn((a)_x) where (a)_x = \Gamma(a + x)/\Gamma(a). exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, sgn, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2799

static VALUE
sf_s_lnpoch_sgn_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[4] = {{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lnpoch_sgn_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,4,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.lnsinh(x) ⇒ DFloat

These routines compute \log(\sinh(x)) for x > 0. Domain: x > 0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 976

static VALUE
sf_s_lnsinh(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_lnsinh, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.lnsinh_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute \log(\sinh(x)) for x > 0. Domain: x > 0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1018

static VALUE
sf_s_lnsinh_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_lnsinh_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.log(x) ⇒ DFloat

These routines compute the logarithm of x, \log(x), for x > 0. Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 59

static VALUE
sf_s_log(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_log, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.log_1plusx(x) ⇒ DFloat

These routines compute \log(1 + x) for x > -1 using an algorithm that is accurate for small x. Domain: x > -1.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 289

static VALUE
sf_s_log_1plusx(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_log_1plusx, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.log_1plusx_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute \log(1 + x) for x > -1 using an algorithm that is accurate for small x. Domain: x > -1.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 332

static VALUE
sf_s_log_1plusx_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_log_1plusx_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.log_1plusx_mx(x) ⇒ DFloat

These routines compute \log(1 + x) - x for x > -1 using an algorithm that is accurate for small x. Domain: x > -1.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 378

static VALUE
sf_s_log_1plusx_mx(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_log_1plusx_mx, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.log_1plusx_mx_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute \log(1 + x) - x for x > -1 using an algorithm that is accurate for small x. Domain: x > -1.0 Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 421

static VALUE
sf_s_log_1plusx_mx_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_log_1plusx_mx_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.log_abs(x) ⇒ DFloat

These routines compute the logarithm of the magnitude of x, \log(|x|), for x \ne 0. Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 146

static VALUE
sf_s_log_abs(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_log_abs, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.log_abs_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the magnitude of x, \log(|x|), for x \ne 0. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 188

static VALUE
sf_s_log_abs_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_log_abs_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.log_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of x, \log(x), for x > 0. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 101

static VALUE
sf_s_log_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_log_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.log_erfc(x) ⇒ DFloat

These routines compute the logarithm of the complementary error function \log(\erfc(x)). Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8751

static VALUE
sf_s_log_erfc(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_log_erfc, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.log_erfc_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the logarithm of the complementary error function \log(\erfc(x)). Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8793

static VALUE
sf_s_log_erfc_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_log_erfc_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.mathieu_a(n, q) ⇒ Int

These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer) —

  parameter

• q (DFloat)

Returns:

• (Int) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10462

static VALUE
sf_s_mathieu_a(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_a, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.mathieu_a_e(n, q) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer)
• q (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10511

static VALUE
sf_s_mathieu_a_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_a_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.mathieu_b(n, q) ⇒ Int

These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer) —

  parameter

• q (DFloat)

Returns:

• (Int) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10564

static VALUE
sf_s_mathieu_b(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_b, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.mathieu_b_e(n, q) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer)
• q (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10613

static VALUE
sf_s_mathieu_b_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_b_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.mathieu_ce(n, q, x) ⇒ Int

These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer) —

  parameter

• q (DFloat)
• x (DFloat)

Returns:

• (Int) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10668

static VALUE
sf_s_mathieu_ce(VALUE mod, VALUE v0, VALUE v1, VALUE v2)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_ce, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};
    int opts[1];

    opts[0] = NUM2INT(v0);

    return na_ndloop3(&ndf, opts, 2, v1, v2);
}

.mathieu_ce_e(n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer)
• q (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10719

static VALUE
sf_s_mathieu_ce_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_ce_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.mathieu_Mc(j, n, q, x) ⇒ Numo::Int

These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

The allowed values of j are 1 and 2. The functions for j = 3,4 can be computed as $M_n^(3) = M_n^(1) + iM_n^(2)$ M_n^[(3)] = M_n^[(1)] + iM_n^[(2)] and $M_n^(4) = M_n^(1) - iM_n^(2)$ M_n^[(4)] = M_n^[(1)] - iM_n^[(2)], where $M_n^(j) = Mc_n^(j)$ M_n^[(j)] = Mc_n^[(j)] or $Ms_n^(j)$ Ms_n^[(j)].

Parameters:

• j (Integer)
• n (Integer)
• q (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::Int) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10899

static VALUE
sf_s_mathieu_Mc(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_Mc,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //j
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,2,v2,v3); 
}

.mathieu_Mc_e(j, n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

The allowed values of j are 1 and 2. The functions for j = 3,4 can be computed as $M_n^(3) = M_n^(1) + iM_n^(2)$ M_n^[(3)] = M_n^[(1)] + iM_n^[(2)] and $M_n^(4) = M_n^(1) - iM_n^(2)$ M_n^[(4)] = M_n^[(1)] - iM_n^[(2)], where $M_n^(j) = Mc_n^(j)$ M_n^[(j)] = Mc_n^[(j)] or $Ms_n^(j)$ Ms_n^[(j)].

Parameters:

• j (Integer)
• n (Integer)
• q (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10979

static VALUE
sf_s_mathieu_Mc_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_Mc_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //j
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,2,v2,v3); 
}

.mathieu_Ms(j, n, q, x) ⇒ Numo::Int

These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

The allowed values of j are 1 and 2. The functions for j = 3,4 can be computed as $M_n^(3) = M_n^(1) + iM_n^(2)$ M_n^[(3)] = M_n^[(1)] + iM_n^[(2)] and $M_n^(4) = M_n^(1) - iM_n^(2)$ M_n^[(4)] = M_n^[(1)] - iM_n^[(2)], where $M_n^(j) = Mc_n^(j)$ M_n^[(j)] = Mc_n^[(j)] or $Ms_n^(j)$ Ms_n^[(j)].

Parameters:

• j (Integer)
• n (Integer)
• q (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• (Numo::Int) —

  return

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11056

static VALUE
sf_s_mathieu_Ms(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_Ms,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,1,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //j
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,2,v2,v3); 
}

.mathieu_Ms_e(j, n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the radial j-th kind Mathieu functions $Mc_n^(j)(q,x)$ Mc_n^(j) and $Ms_n^(j)(q,x)$ Ms_n^(j) of order n.

The allowed values of j are 1 and 2. The functions for j = 3,4 can be computed as $M_n^(3) = M_n^(1) + iM_n^(2)$ M_n^[(3)] = M_n^[(1)] + iM_n^[(2)] and $M_n^(4) = M_n^(1) - iM_n^(2)$ M_n^[(4)] = M_n^[(1)] - iM_n^[(2)], where $M_n^(j) = Mc_n^(j)$ M_n^[(j)] = Mc_n^[(j)] or $Ms_n^(j)$ Ms_n^[(j)].

Parameters:

• j (Integer)
• n (Integer)
• q (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 11136

static VALUE
sf_s_mathieu_Ms_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    int c0;
    int c1;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_Ms_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt[2];
    
    c0 = NUM2INT(v0); opt[0] = &c0; //j
    c1 = NUM2INT(v1); opt[1] = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,2,v2,v3); 
}

.mathieu_se(n, q, x) ⇒ Int

These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer) —

  parameter

• q (DFloat)
• x (DFloat)

Returns:

• (Int) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10774

static VALUE
sf_s_mathieu_se(VALUE mod, VALUE v0, VALUE v1, VALUE v2)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_se, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};
    int opts[1];

    opts[0] = NUM2INT(v0);

    return na_ndloop3(&ndf, opts, 2, v1, v2);
}

.mathieu_se_e(n, q, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.

Parameters:

• n (Integer)
• q (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10825

static VALUE
sf_s_mathieu_se_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_mathieu_se_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,2,v1,v2); 
}

.multiply_e(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This function multiplies x and y storing the product and its associated error in result. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9106

static VALUE
sf_s_multiply_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_multiply_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.multiply_err_e(x, dx, y, dy) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This function multiplies x and y with associated absolute errors dx and dy. The product $xy \pm xy \sqrt+(dy/y)^2$ xy +/- xy \sqrt((dx/x)^2 +(dy/y)^2) is stored in result. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)
• y (Numo::DFloat)
• dy (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 9165

static VALUE
sf_s_multiply_err_e(VALUE mod,VALUE v0,VALUE v1,VALUE v2,VALUE v3)
{
    
    

    ndfunc_arg_in_t ain[4] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_multiply_err_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    4,3,ain,aout};
    
    
    return na_ndloop(&ndf,4,v0,v1,v2,v3); 
}

.poch(a, x) ⇒ DFloat

These routines compute the Pochhammer symbol (a)_x = \Gamma(a + x)/\Gamma(a). The Pochhammer symbol is also known as the Apell symbol and sometimes written as (a,x). When a and a+x are negative integers or zero, the limiting value of the ratio is returned. exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2603

static VALUE
sf_s_poch(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_poch, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.poch_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Pochhammer symbol (a)_x = \Gamma(a + x)/\Gamma(a). The Pochhammer symbol is also known as the Apell symbol and sometimes written as (a,x). When a and a+x are negative integers or zero, the limiting value of the ratio is returned. exceptions: GSL_EDOM, GSL_EOVRFLW

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2650

static VALUE
sf_s_poch_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_poch_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.pochrel(a, x) ⇒ DFloat

These routines compute the relative Pochhammer symbol ((a)_x - 1)/x where (a)_x = \Gamma(a + x)/\Gamma(a). exceptions: GSL_EDOM

Parameters:

• a (DFloat)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2847

static VALUE
sf_s_pochrel(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_pochrel, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.pochrel_e(a, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the relative Pochhammer symbol ((a)_x - 1)/x where (a)_x = \Gamma(a + x)/\Gamma(a). exceptions: GSL_EDOM

Parameters:

• a (Numo::DFloat)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2892

static VALUE
sf_s_pochrel_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_pochrel_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.polar_to_rect(r, theta) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function converts the polar coordinates (r,theta) to rectilinear coordinates (x,y), x = r\cos(\theta), y = r\sin(\theta). Exceptional Return Values: GSL_ELOSS

Parameters:

• r (Numo::DFloat)
• theta (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [x.val, x.err, y.val, y.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1157

static VALUE
sf_s_polar_to_rect(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_polar_to_rect,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.pow_int(x, n) ⇒ DFloat

These routines compute the power x^n for integer n. The power is computed using the minimum number of multiplications. For example, x^8 is computed as ((x^2)^2)^2, requiring only 3 multiplications. For reasons of efficiency, these functions do not check for overflow or underflow conditions.

Parameters:

• x (DFloat)
• n (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10175

static VALUE
sf_s_pow_int(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[2] = {{cDF,0},{cInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_pow_int, STRIDE_LOOP|NDF_EXTRACT, 2,1, ain,aout};

    return na_ndloop(&ndf, 2, v0, v1);
}

.pow_int_e(x, n) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the power x^n for integer n. The power is computed using the minimum number of multiplications. For example, x^8 is computed as ((x^2)^2)^2, requiring only 3 multiplications. For reasons of efficiency, these functions do not check for overflow or underflow conditions.

Parameters:

• x (Numo::DFloat)
• n (Integer)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10223

static VALUE
sf_s_pow_int_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c1;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_pow_int_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c1 = NUM2INT(v1); opt = &c1; //n
    
    
    return na_ndloop3(&ndf,opt,1,v0); 
}

.psi(x) ⇒ DFloat

These routines compute the digamma function \psi(x) for general x, x \ne 0. Domain: x != 0.0, -1.0, -2.0, … Exceptional Return Values: GSL_EDOM, GSL_ELOSS

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7599

static VALUE
sf_s_psi(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_psi, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.psi_1(x) ⇒ DFloat

These routines compute the Trigamma function \psi’(x) for general x. Domain: x != 0.0, -1.0, -2.0, … Exceptional Return Values: GSL_EDOM, GSL_ELOSS

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7854

static VALUE
sf_s_psi_1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_psi_1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.psi_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Trigamma function \psi’(x) for general x. Domain: x != 0.0, -1.0, -2.0, … Exceptional Return Values: GSL_EDOM, GSL_ELOSS

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7897

static VALUE
sf_s_psi_1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_psi_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.psi_1_int(n) ⇒ DFloat

These routines compute the Trigamma function \psi’(n) for positive integer n. Domain: n integer, n > 0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Int)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7778

static VALUE
sf_s_psi_1_int(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_psi_1_int, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.psi_1_int_e(n) ⇒ [Float, Float, Integer]

These routines compute the Trigamma function \psi’(n) for positive integer n. Domain: n integer, n > 0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7801

static VALUE
sf_s_psi_1_int_e(VALUE mod,VALUE v0)
{
    
    int c0;
    gsl_sf_result c1;
    int c2;
    
    c0 = NUM2INT(v0);
    c2 = gsl_sf_psi_1_int_e(c0,&c1);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c1.val));
        rb_ary_push(va,DBL2NUM(c1.err));
        rb_ary_push(va,INT2NUM(c2));
        return va;
    }
    
}

.psi_1piy(y) ⇒ DFloat

These routines compute the real part of the digamma function on the line 1+i y, \Re[\psi(1 + i y)]. exceptions: none Exceptional Return Values: none

Parameters:

• y (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7688

static VALUE
sf_s_psi_1piy(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_psi_1piy, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.psi_1piy_e(y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the real part of the digamma function on the line 1+i y, \Re[\psi(1 + i y)]. exceptions: none Exceptional Return Values: none

Parameters:

• y (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7731

static VALUE
sf_s_psi_1piy_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_psi_1piy_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.psi_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the digamma function \psi(x) for general x, x \ne 0. Domain: x != 0.0, -1.0, -2.0, … Exceptional Return Values: GSL_EDOM, GSL_ELOSS

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7642

static VALUE
sf_s_psi_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_psi_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.psi_int(n) ⇒ DFloat

These routines compute the digamma function \psi(n) for positive integer n. The digamma function is also called the Psi function. Domain: n integer, n > 0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Int)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7523

static VALUE
sf_s_psi_int(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_psi_int, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.psi_int_e(n) ⇒ [Float, Float, Integer]

These routines compute the digamma function \psi(n) for positive integer n. The digamma function is also called the Psi function. Domain: n integer, n > 0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7546

static VALUE
sf_s_psi_int_e(VALUE mod,VALUE v0)
{
    
    int c0;
    gsl_sf_result c1;
    int c2;
    
    c0 = NUM2INT(v0);
    c2 = gsl_sf_psi_int_e(c0,&c1);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c1.val));
        rb_ary_push(va,DBL2NUM(c1.err));
        rb_ary_push(va,INT2NUM(c2));
        return va;
    }
    
}

.psi_n(n, x) ⇒ DFloat

These routines compute the polygamma function $\psi^(n)(x)$ \psi^(n) for $n \ge 0$ n >= 0, x > 0. Domain: n >= 0, x > 0.0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 7948

static VALUE
sf_s_psi_n(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_psi_n, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.psi_n_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the polygamma function $\psi^(n)(x)$ \psi^(n) for $n \ge 0$ n >= 0, x > 0. Domain: n >= 0, x > 0.0 Exceptional Return Values: GSL_EDOM

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 8000

static VALUE
sf_s_psi_n_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_psi_n_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.rect_to_polar(x, y) ⇒ [Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]

This function converts the rectilinear coordinates (x,y) to polar coordinates (r,theta), such that x = r\cos(\theta), y = r\sin(\theta). The argument theta lies in the range [-\pi, \pi]. Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)
• y (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [r.val, r.err, theta.val, theta.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1212

static VALUE
sf_s_rect_to_polar(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[5] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_rect_to_polar,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,5,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.Shi(x) ⇒ DFloat

These routines compute the integral $\hboxShi(x) = \int_0^x dt \sinh(t)/t$ Shi(x) = \int_0^x dt \sinh(t)/t. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5726

static VALUE
sf_s_Shi(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_Shi, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.Shi_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the integral $\hboxShi(x) = \int_0^x dt \sinh(t)/t$ Shi(x) = \int_0^x dt \sinh(t)/t. Exceptional Return Values: GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5768

static VALUE
sf_s_Shi_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_Shi_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.Si(x) ⇒ DFloat

These routines compute the Sine integral $\hboxSi(x) = \int_0^x dt \sin(t)/t$ Si(x) = \int_0^x dt \sin(t)/t. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 5993

static VALUE
sf_s_Si(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_Si, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.Si_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Sine integral $\hboxSi(x) = \int_0^x dt \sin(t)/t$ Si(x) = \int_0^x dt \sin(t)/t. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 6035

static VALUE
sf_s_Si_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_Si_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.sin(x) ⇒ DFloat

These routines compute the sine function \sin(x). Exceptional Return Values:

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 465

static VALUE
sf_s_sin(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_sin, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.sin_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the sine function \sin(x). Exceptional Return Values:

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 506

static VALUE
sf_s_sin_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_sin_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.sin_err_e(x, dx) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

This routine computes the sine of an angle x with an associated absolute error dx, $\sin(x \pm dx)$ \sin(x \pm dx). Note that this function is provided in the error-handling form only since its purpose is to compute the propagated error.

Parameters:

• x (Numo::DFloat)
• dx (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 1353

static VALUE
sf_s_sin_err_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    

    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_sin_err_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    2,3,ain,aout};
    
    
    return na_ndloop(&ndf,2,v0,v1); 
}

.sinc(x) ⇒ DFloat

These routines compute \sinc(x) = \sin(\pi x) / (\pi x) for any value of x. Exceptional Return Values: none

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 729

static VALUE
sf_s_sinc(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_sinc, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.sinc_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute \sinc(x) = \sin(\pi x) / (\pi x) for any value of x. Exceptional Return Values: none

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 771

static VALUE
sf_s_sinc_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_sinc_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.synchrotron_1(x) ⇒ DFloat

These routines compute the first synchrotron function $x \int_x^\infty dt K_5/3(t)$ x \int_x^\infty dt K_5/3 for $x \ge 0$ x >= 0. Domain: x >= 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10275

static VALUE
sf_s_synchrotron_1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_synchrotron_1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.synchrotron_1_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the first synchrotron function $x \int_x^\infty dt K_5/3(t)$ x \int_x^\infty dt K_5/3 for $x \ge 0$ x >= 0. Domain: x >= 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10320

static VALUE
sf_s_synchrotron_1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_synchrotron_1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.synchrotron_2(x) ⇒ DFloat

These routines compute the second synchrotron function $x K_2/3(x)$ x K_2/3 for $x \ge 0$ x >= 0. Domain: x >= 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10368

static VALUE
sf_s_synchrotron_2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_synchrotron_2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.synchrotron_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the second synchrotron function $x K_2/3(x)$ x K_2/3 for $x \ge 0$ x >= 0. Domain: x >= 0.0 Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 10413

static VALUE
sf_s_synchrotron_2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_synchrotron_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.taylorcoeff(n, x) ⇒ DFloat

These routines compute the Taylor coefficient x^n / n! for $x \ge 0$ x >= 0, $n \ge 0$ n >= 0. exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2497

static VALUE
sf_s_taylorcoeff(VALUE mod, VALUE v0, VALUE v1)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_taylorcoeff, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
    int c0;

    c0 = NUM2INT(v0);

    return na_ndloop3(&ndf, &c0, 1, v1);
}

.taylorcoeff_e(n, x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Taylor coefficient x^n / n! for $x \ge 0$ x >= 0, $n \ge 0$ n >= 0. exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW

Parameters:

• n (Integer)
• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 2549

static VALUE
sf_s_taylorcoeff_e(VALUE mod,VALUE v0,VALUE v1)
{
    
    int c0;
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_taylorcoeff_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    void *opt;
    c0 = NUM2INT(v0); opt = &c0; //n
    
    
    return na_ndloop3(&ndf,opt,1,v1); 
}

.transport_2(x) ⇒ DFloat

These routines compute the transport function J(2,x). Exceptional Return Values: GSL_EDOM

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3538

static VALUE
sf_s_transport_2(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_transport_2, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.transport_2_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the transport function J(2,x). Exceptional Return Values: GSL_EDOM

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3579

static VALUE
sf_s_transport_2_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_transport_2_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.transport_3(x) ⇒ DFloat

These routines compute the transport function J(3,x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3623

static VALUE
sf_s_transport_3(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_transport_3, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.transport_3_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the transport function J(3,x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3664

static VALUE
sf_s_transport_3_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_transport_3_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.transport_4(x) ⇒ DFloat

These routines compute the transport function J(4,x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3708

static VALUE
sf_s_transport_4(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_transport_4, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.transport_4_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the transport function J(4,x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3749

static VALUE
sf_s_transport_4_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_transport_4_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.transport_5(x) ⇒ DFloat

These routines compute the transport function J(5,x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3793

static VALUE
sf_s_transport_5(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_transport_5, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.transport_5_e(x) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the transport function J(5,x). Exceptional Return Values: GSL_EDOM, GSL_EUNDRFLW

Parameters:

• x (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 3834

static VALUE
sf_s_transport_5_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_transport_5_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.zeta(s) ⇒ DFloat

These routines compute the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1. Domain: s != 1.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• s (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19081

static VALUE
sf_s_zeta(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_zeta, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.zeta_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1. Domain: s != 1.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• s (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19125

static VALUE
sf_s_zeta_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_zeta_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.zeta_int(n) ⇒ DFloat

These routines compute the Riemann zeta function \zeta(n) for integer n, n \ne 1. Domain: n integer, n != 1 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Int)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19003

static VALUE
sf_s_zeta_int(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_zeta_int, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.zeta_int_e(n) ⇒ [Float, Float, Integer]

These routines compute the Riemann zeta function \zeta(n) for integer n, n \ne 1. Domain: n integer, n != 1 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19027

static VALUE
sf_s_zeta_int_e(VALUE mod,VALUE v0)
{
    
    int c0;
    gsl_sf_result c1;
    int c2;
    
    c0 = NUM2INT(v0);
    c2 = gsl_sf_zeta_int_e(c0,&c1);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c1.val));
        rb_ary_push(va,DBL2NUM(c1.err));
        rb_ary_push(va,INT2NUM(c2));
        return va;
    }
    
}

.zetam1(s) ⇒ DFloat

These routines compute \zeta(s) - 1 for arbitrary s, s \ne 1. Domain: s != 1.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• s (DFloat)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19248

static VALUE
sf_s_zetam1(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_zetam1, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.zetam1_e(s) ⇒ [Numo::DFloat, Numo::DFloat, Numo::Int]

These routines compute \zeta(s) - 1 for arbitrary s, s \ne 1. Domain: s != 1.0 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• s (Numo::DFloat)

Returns:

• ([Numo::DFloat, Numo::DFloat, Numo::Int]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19291

static VALUE
sf_s_zetam1_e(VALUE mod,VALUE v0)
{
    
    

    ndfunc_arg_in_t ain[1] = {{cDF,0}};
    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cI,0}};
    ndfunc_t ndf = {iter_sf_s_zetam1_e,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,
                    1,3,ain,aout};
    
    
    return na_ndloop(&ndf,1,v0); 
}

.zetam1_int(n) ⇒ DFloat

These routines compute \zeta(n) - 1 for integer n, n \ne 1. Domain: n integer, n != 1 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Int)

Returns:

• (DFloat) —

  result

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19172

static VALUE
sf_s_zetam1_int(VALUE mod, VALUE v0)
{
    ndfunc_arg_in_t ain[1] = {{cInt,0}};
    ndfunc_arg_out_t aout[1] = {{cDF,0}};
    ndfunc_t ndf = {iter_sf_s_zetam1_int, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};

    return na_ndloop(&ndf, 1, v0);
}

.zetam1_int_e(n) ⇒ [Float, Float, Integer]

These routines compute \zeta(n) - 1 for integer n, n \ne 1. Domain: n integer, n != 1 Exceptional Return Values: GSL_EDOM, GSL_EOVRFLW

Parameters:

• n (Integer)

Returns:

• ([Float, Float, Integer]) —

  array of [result.val, result.err, return]

# File 'ext/numo/gsl/sf/gsl_sf.c', line 19195

static VALUE
sf_s_zetam1_int_e(VALUE mod,VALUE v0)
{
    
    int c0;
    gsl_sf_result c1;
    int c2;
    
    c0 = NUM2INT(v0);
    c2 = gsl_sf_zetam1_int_e(c0,&c1);
    
    {
        VALUE va = rb_ary_new();
        
        rb_ary_push(va,DBL2NUM(c1.val));
        rb_ary_push(va,DBL2NUM(c1.err));
        rb_ary_push(va,INT2NUM(c2));
        return va;
    }
    
}