package gsl

  1. Overview
  2. Docs

Module Gsl.SfSource

Special functions

The library includes routines for calculating the values of Airy functions, Bessel functions, Clausen functions, Coulomb functions, Coupling coefficients, The Dawson function, Debye functions, Dilogarithms, Elliptic integrals, Error, Exponential functions, Exponential integrals, Fermi-Dirac function, Gamma function, Gegenbauer functions aka Ultraspherical polynomials, Hypergeometric functions, Laguerre functions, Lambert W functions, Legendre functions and Associated Legendre functions and Spherical Harmonics, log, Power function, Psi (Digamma) function, Synchrotron functions, Transport functions, Trigonometric functions, and Zeta functions.

Each routine also computes an estimate of the numerical error in the calculated value of the function.

Airy functions

Sourceval airy_Ai : float -> Fun.mode -> float
Sourceval airy_Ai_e : float -> Fun.mode -> Fun.result
Sourceval airy_Bi : float -> Fun.mode -> float
Sourceval airy_Bi_e : float -> Fun.mode -> Fun.result
Sourceval airy_Ai_scaled : float -> Fun.mode -> float
Sourceval airy_Ai_scaled_e : float -> Fun.mode -> Fun.result
Sourceval airy_Bi_scaled : float -> Fun.mode -> float
Sourceval airy_Bi_scaled_e : float -> Fun.mode -> Fun.result
Sourceval airy_Ai_deriv : float -> Fun.mode -> float
Sourceval airy_Ai_deriv_e : float -> Fun.mode -> Fun.result
Sourceval airy_Bi_deriv : float -> Fun.mode -> float
Sourceval airy_Bi_deriv_e : float -> Fun.mode -> Fun.result
Sourceval airy_Ai_deriv_scaled : float -> Fun.mode -> float
Sourceval airy_Ai_deriv_scaled_e : float -> Fun.mode -> Fun.result
Sourceval airy_Bi_deriv_scaled : float -> Fun.mode -> float
Sourceval airy_Bi_deriv_scaled_e : float -> Fun.mode -> Fun.result
Sourceval airy_zero_Ai : int -> float
Sourceval airy_zero_Ai_e : int -> Fun.result
Sourceval airy_zero_Bi : int -> float
Sourceval airy_zero_Bi_e : int -> Fun.result

Bessel functions

Sourceval bessel_J0 : float -> float
Sourceval bessel_J0_e : float -> Fun.result
Sourceval bessel_J1 : float -> float
Sourceval bessel_J1_e : float -> Fun.result
Sourceval bessel_Jn : int -> float -> float
Sourceval bessel_Jn_e : int -> float -> Fun.result
Sourceval bessel_Jn_array : int -> float -> float array -> unit
Sourceval bessel_Y0 : float -> float
Sourceval bessel_Y0_e : float -> Fun.result
Sourceval bessel_Y1 : float -> float
Sourceval bessel_Y1_e : float -> Fun.result
Sourceval bessel_Yn : int -> float -> float
Sourceval bessel_Yn_e : int -> float -> Fun.result
Sourceval bessel_Yn_array : int -> float -> float array -> unit
Sourceval bessel_I0 : float -> float
Sourceval bessel_I0_e : float -> Fun.result
Sourceval bessel_I1 : float -> float
Sourceval bessel_I1_e : float -> Fun.result
Sourceval bessel_In : int -> float -> float
Sourceval bessel_In_e : int -> float -> Fun.result
Sourceval bessel_In_array : int -> float -> float array -> unit
Sourceval bessel_K0 : float -> float
Sourceval bessel_K0_e : float -> Fun.result
Sourceval bessel_K1 : float -> float
Sourceval bessel_K1_e : float -> Fun.result
Sourceval bessel_Kn : int -> float -> float
Sourceval bessel_Kn_e : int -> float -> Fun.result
Sourceval bessel_Kn_array : int -> float -> float array -> unit
Sourceval bessel_I0_scaled : float -> float
Sourceval bessel_I0_scaled_e : float -> Fun.result
Sourceval bessel_I1_scaled : float -> float
Sourceval bessel_I1_scaled_e : float -> Fun.result
Sourceval bessel_In_scaled : int -> float -> float
Sourceval bessel_In_scaled_e : int -> float -> Fun.result
Sourceval bessel_In_scaled_array : int -> float -> float array -> unit
Sourceval bessel_K0_scaled : float -> float
Sourceval bessel_K0_scaled_e : float -> Fun.result
Sourceval bessel_K1_scaled : float -> float
Sourceval bessel_K1_scaled_e : float -> Fun.result
Sourceval bessel_Kn_scaled : int -> float -> float
Sourceval bessel_Kn_scaled_e : int -> float -> Fun.result
Sourceval bessel_Kn_scaled_array : int -> float -> float array -> unit
Sourceval bessel_j0 : float -> float
Sourceval bessel_j0_e : float -> Fun.result
Sourceval bessel_j1 : float -> float
Sourceval bessel_j1_e : float -> Fun.result
Sourceval bessel_j2 : float -> float
Sourceval bessel_j2_e : float -> Fun.result
Sourceval bessel_jl : int -> float -> float
Sourceval bessel_jl_e : int -> float -> Fun.result
Sourceval bessel_jl_array : int -> float -> float array -> unit
Sourceval bessel_jl_steed_array : float -> float array -> unit
Sourceval bessel_y0 : float -> float
Sourceval bessel_y0_e : float -> Fun.result
Sourceval bessel_y1 : float -> float
Sourceval bessel_y1_e : float -> Fun.result
Sourceval bessel_y2 : float -> float
Sourceval bessel_y2_e : float -> Fun.result
Sourceval bessel_yl : int -> float -> float
Sourceval bessel_yl_e : int -> float -> Fun.result
Sourceval bessel_yl_array : int -> float -> float array -> unit
Sourceval bessel_i0_scaled : float -> float
Sourceval bessel_i0_scaled_e : float -> Fun.result
Sourceval bessel_i1_scaled : float -> float
Sourceval bessel_i1_scaled_e : float -> Fun.result
Sourceval bessel_il_scaled : int -> float -> float
Sourceval bessel_il_scaled_e : int -> float -> Fun.result
Sourceval bessel_il_scaled_array : int -> float -> float array -> unit
Sourceval bessel_k0_scaled : float -> float
Sourceval bessel_k0_scaled_e : float -> Fun.result
Sourceval bessel_k1_scaled : float -> float
Sourceval bessel_k1_scaled_e : float -> Fun.result
Sourceval bessel_kl_scaled : int -> float -> float
Sourceval bessel_kl_scaled_e : int -> float -> Fun.result
Sourceval bessel_kl_scaled_array : int -> float -> float array -> unit
Sourceval bessel_Jnu : float -> float -> float
Sourceval bessel_Jnu_e : float -> float -> Fun.result
Sourceval bessel_sequence_Jnu_e : float -> Fun.mode -> float array -> unit
Sourceval bessel_Ynu : float -> float -> float
Sourceval bessel_Ynu_e : float -> float -> Fun.result
Sourceval bessel_Inu : float -> float -> float
Sourceval bessel_Inu_e : float -> float -> Fun.result
Sourceval bessel_Inu_scaled : float -> float -> float
Sourceval bessel_Inu_scaled_e : float -> float -> Fun.result
Sourceval bessel_Knu : float -> float -> float
Sourceval bessel_Knu_e : float -> float -> Fun.result
Sourceval bessel_lnKnu : float -> float -> float
Sourceval bessel_lnKnu_e : float -> float -> Fun.result
Sourceval bessel_Knu_scaled : float -> float -> float
Sourceval bessel_Knu_scaled_e : float -> float -> Fun.result
Sourceval bessel_zero_J0 : int -> float
Sourceval bessel_zero_J0_e : int -> Fun.result
Sourceval bessel_zero_J1 : int -> float
Sourceval bessel_zero_J1_e : int -> Fun.result
Sourceval bessel_zero_Jnu : float -> int -> float
Sourceval bessel_zero_Jnu_e : float -> int -> Fun.result

Clausen functions

Sourceval clausen : float -> float
Sourceval clausen_e : float -> Fun.result

Coulomb functions

Sourceval hydrogenicR_1 : float -> float -> float
Sourceval hydrogenicR_1_e : float -> float -> Fun.result
Sourceval hydrogenicR : int -> int -> float -> float -> float
Sourceval hydrogenicR_e : int -> int -> float -> float -> Fun.result
Sourceval coulomb_CL_e : float -> float -> Fun.result
Sourceval coulomb_CL_array : float -> float -> float array -> unit

Coupling coefficients

The Dawson function

Sourceval dawson : float -> float
Sourceval dawson_e : float -> Fun.result

Debye functions

Sourceval debye_1 : float -> float
Sourceval debye_1_e : float -> Fun.result
Sourceval debye_2 : float -> float
Sourceval debye_2_e : float -> Fun.result
Sourceval debye_3 : float -> float
Sourceval debye_3_e : float -> Fun.result
Sourceval debye_4 : float -> float
Sourceval debye_4_e : float -> Fun.result
Sourceval debye_5 : float -> float
Sourceval debye_5_e : float -> Fun.result
Sourceval debye_6 : float -> float
Sourceval debye_6_e : float -> Fun.result

Dilogarithms

Sourceval dilog : float -> float
Sourceval dilog_e : float -> Fun.result
Sourceval complex_dilog_xy_e : float -> float -> Fun.result * Fun.result
Sourceval complex_dilog_e : float -> float -> Fun.result * Fun.result
Sourceval complex_spence_xy_e : float -> float -> Fun.result * Fun.result

Elementary operations

Sourceval multiply_e : float -> float -> Fun.result
Sourceval multiply_err_e : x:float -> dx:float -> y:float -> dy:float -> Fun.result

Elliptic integrals

Sourceval ellint_Kcomp : float -> Fun.mode -> float
Sourceval ellint_Kcomp_e : float -> Fun.mode -> Fun.result
Sourceval ellint_Ecomp : float -> Fun.mode -> float
Sourceval ellint_Ecomp_e : float -> Fun.mode -> Fun.result
Sourceval ellint_Pcomp : float -> float -> Fun.mode -> float
Sourceval ellint_Pcomp_e : float -> float -> Fun.mode -> Fun.result
Sourceval ellint_Dcomp : float -> Fun.mode -> float
Sourceval ellint_Dcomp_e : float -> Fun.mode -> Fun.result
Sourceval ellint_F : float -> float -> Fun.mode -> float
Sourceval ellint_F_e : float -> float -> Fun.mode -> Fun.result
Sourceval ellint_E : float -> float -> Fun.mode -> float
Sourceval ellint_E_e : float -> float -> Fun.mode -> Fun.result
Sourceval ellint_P : float -> float -> float -> Fun.mode -> float
Sourceval ellint_P_e : float -> float -> float -> Fun.mode -> Fun.result
Sourceval ellint_D : float -> float -> Fun.mode -> float
Sourceval ellint_D_e : float -> float -> Fun.mode -> Fun.result
Sourceval ellint_RC : float -> float -> Fun.mode -> float
Sourceval ellint_RC_e : float -> float -> Fun.mode -> Fun.result
Sourceval ellint_RD : float -> float -> float -> Fun.mode -> float
Sourceval ellint_RD_e : float -> float -> float -> Fun.mode -> Fun.result
Sourceval ellint_RF : float -> float -> float -> Fun.mode -> float
Sourceval ellint_RF_e : float -> float -> float -> Fun.mode -> Fun.result
Sourceval ellint_RJ : float -> float -> float -> float -> Fun.mode -> float
Sourceval ellint_RJ_e : float -> float -> float -> float -> Fun.mode -> Fun.result

Error function

Sourceval erf : float -> float
Sourceval erf_e : float -> Fun.result
Sourceval erfc : float -> float
Sourceval erfc_e : float -> Fun.result
Sourceval log_erfc : float -> float
Sourceval log_erfc_e : float -> Fun.result
Sourceval erf_Z : float -> float
Sourceval erf_Z_e : float -> Fun.result
Sourceval erf_Q : float -> float
Sourceval erf_Q_e : float -> Fun.result

Exponential functions

Sourceval exp : float -> float
Sourceval exp_e : float -> Fun.result

exp x computes the exponential function eˣ using GSL semantics and error checking.

Sourceval exp_e10 : float -> Fun.result_e10

exp_e10 x computes the exponential eˣ and returns a result with extended range. This function may be useful if the value of eˣ would overflow the numeric range of double.

Sourceval exp_mult : float -> float -> float
Sourceval exp_mult_e : float -> float -> Fun.result

exp_mult x y exponentiate x and multiply by the factor y to return the product y eˣ.

Sourceval exp_mult_e10 : float -> float -> Fun.result_e10

Same as exp_e10 but return a result with extended numeric range.

Sourceval expm1 : float -> float
Sourceval expm1_e : float -> Fun.result

expm1 x compute the quantity eˣ-1 using an algorithm that is accurate for small x.

Sourceval exprel : float -> float
Sourceval exprel_e : float -> Fun.result

exprel x compute the quantity (eˣ-1)/x using an algorithm that is accurate for small x. For small x the algorithm is based on the expansion (eˣ-1)/x = 1 + x/2 + x²/(2*3) + x³/(2*3*4) + ⋯

Sourceval exprel_2 : float -> float
Sourceval exprel_2_e : float -> Fun.result

exprel_2 x compute the quantity 2(eˣ-1-x)/x² using an algorithm that is accurate for small x. For small x the algorithm is based on the expansion 2(eˣ-1-x)/x^2 = 1 + x/3 + x²/(3*4) + x³/(3*4*5) + ⋯

Sourceval exprel_n : int -> float -> float
Sourceval exprel_n_e : int -> float -> Fun.result

exprel_n x compute the n-relative exponential, which is the n-th generalization of the functions exprel and exprel_2. The N-relative exponential is given by,

                         n-1
exprel_n x = n!/xⁿ (aˣ -  ∑ xᵏ/k!)
                         k=0
           = 1 + x/(N+1) + x²/((N+1)(N+2)) + ⋯
Sourceval exp_err_e : x:float -> dx:float -> Fun.result
Sourceval exp_err_e10 : x:float -> dx:float -> Fun.result_e10
Sourceval exp_mult_err_e : x:float -> dx:float -> y:float -> dy:float -> Fun.result
Sourceval exp_mult_err_e10_e : x:float -> dx:float -> y:float -> dy:float -> Fun.result_e10

Exponential integrals

Sourceval expint_E1 : float -> float
Sourceval expint_E1_e : float -> Fun.result
Sourceval expint_E2 : float -> float
Sourceval expint_E2_e : float -> Fun.result
Sourceval expint_E1_scaled : float -> float
Sourceval expint_E1_scaled_e : float -> Fun.result
Sourceval expint_E2_scaled : float -> float
Sourceval expint_E2_scaled_e : float -> Fun.result
Sourceval expint_Ei : float -> float
Sourceval expint_Ei_e : float -> Fun.result
Sourceval expint_Ei_scaled : float -> float
Sourceval expint_Ei_scaled_e : float -> Fun.result
Sourceval shi : float -> float
Sourceval chi : float -> float
Sourceval expint_3 : float -> float
Sourceval expint_3_e : float -> Fun.result
Sourceval si : float -> float
Sourceval ci : float -> float
Sourceval atanint : float -> float
Sourceval atanint_e : float -> Fun.result

Fermi-Dirac function

Sourceval fermi_dirac_m1 : float -> float
Sourceval fermi_dirac_m1_e : float -> Fun.result
Sourceval fermi_dirac_0 : float -> float
Sourceval fermi_dirac_0_e : float -> Fun.result
Sourceval fermi_dirac_1 : float -> float
Sourceval fermi_dirac_1_e : float -> Fun.result
Sourceval fermi_dirac_2 : float -> float
Sourceval fermi_dirac_2_e : float -> Fun.result
Sourceval fermi_dirac_int : int -> float -> float
Sourceval fermi_dirac_int_e : int -> float -> Fun.result
Sourceval fermi_dirac_mhalf : float -> float
Sourceval fermi_dirac_mhalf_e : float -> Fun.result
Sourceval fermi_dirac_half : float -> float
Sourceval fermi_dirac_half_e : float -> Fun.result
Sourceval fermi_dirac_3half : float -> float
Sourceval fermi_dirac_3half_e : float -> Fun.result
Sourceval fermi_dirac_inc_0 : float -> float -> float
Sourceval fermi_dirac_inc_0_e : float -> float -> Fun.result

Gamma function

Sourceval gamma : float -> float
Sourceval gamma_e : float -> Fun.result
Sourceval lngamma : float -> float
Sourceval lngamma_e : float -> Fun.result
Sourceval lngamma_sgn_e : float -> Fun.result * float
Sourceval gammastar : float -> float
Sourceval gammastar_e : float -> Fun.result
Sourceval gammainv : float -> float
Sourceval gammainv_e : float -> Fun.result
Sourceval lngamma_complex_e : float -> float -> Fun.result * Fun.result
Sourceval taylorcoeff : int -> float -> float
Sourceval taylorcoeff_e : int -> float -> Fun.result
Sourceval fact : int -> float
Sourceval fact_e : int -> Fun.result
Sourceval doublefact : int -> float
Sourceval doublefact_e : int -> Fun.result
Sourceval lnfact : int -> float
Sourceval lnfact_e : int -> Fun.result
Sourceval lndoublefact : int -> float
Sourceval lndoublefact_e : int -> Fun.result
Sourceval choose : int -> int -> float
Sourceval choose_e : int -> int -> Fun.result
Sourceval lnchoose : int -> int -> float
Sourceval lnchoose_e : int -> int -> Fun.result
Sourceval poch : float -> float -> float
Sourceval poch_e : float -> float -> Fun.result
Sourceval lnpoch : float -> float -> float
Sourceval lnpoch_e : float -> float -> Fun.result
Sourceval lnpoch_sgn_e : float -> float -> Fun.result * float
Sourceval pochrel : float -> float -> float
Sourceval pochrel_e : float -> float -> Fun.result
Sourceval gamma_inc_Q : float -> float -> float
Sourceval gamma_inc_Q_e : float -> float -> Fun.result
Sourceval gamma_inc_P : float -> float -> float
Sourceval gamma_inc_P_e : float -> float -> Fun.result
Sourceval gamma_inc : float -> float -> float
Sourceval gamma_inc_e : float -> float -> Fun.result
Sourceval beta : float -> float -> float
Sourceval beta_e : float -> float -> Fun.result
Sourceval lnbeta : float -> float -> float
Sourceval lnbeta_e : float -> float -> Fun.result
Sourceval lnbeta_sgn_e : float -> float -> Fun.result * float
Sourceval beta_inc : float -> float -> float -> float
Sourceval beta_inc_e : float -> float -> float -> Fun.result

Gegenbauer functions aka Ultraspherical polynomials

Gegenbauer functions are defined in DLMF.

Sourceval gegenpoly_1 : float -> float -> float
Sourceval gegenpoly_1_e : float -> float -> Fun.result

gegenpoly_1 l x = C₁⁽ˡ⁾(x).

Sourceval gegenpoly_2 : float -> float -> float
Sourceval gegenpoly_2_e : float -> float -> Fun.result

gegenpoly_2 l x = C₂⁽ˡ⁾(x).

Sourceval gegenpoly_3 : float -> float -> float
Sourceval gegenpoly_3_e : float -> float -> Fun.result

gegenpoly_3 l x = C₃⁽ˡ⁾(x).

Sourceval gegenpoly_n : int -> float -> float -> float
Sourceval gegenpoly_n_e : int -> float -> float -> Fun.result

gegenpoly_n n l x = Cₙ⁽ˡ⁾(x). Constraints: l > -1/2, n ≥ 0.

Sourceval gegenpoly_array : float -> float -> float array -> unit

gegenpoly_array l x c computes an array of Gegenbauer polynomials c.(n) = Cₙ⁽ˡ⁾(x) for n = 0, 1, 2,̣..., Array.length c - 1. Constraints: l > -1/2.

Hypergeometric functions

Sourceval hyperg_0F1 : c:float -> float -> float
Sourceval hyperg_0F1_e : c:float -> float -> Fun.result

hyperg_0F1 c x computes the hypergeometric function ₀F₁(c; x).

Sourceval hyperg_1F1_int : m:int -> n:int -> float -> float
Sourceval hyperg_1F1_int_e : m:int -> n:int -> float -> Fun.result

hyperg_1F1_int m n x computes the confluent hypergeometric function ₁F₁(m;n;x) = M(m,n,x) for integer parameters m, n.

Sourceval hyperg_1F1 : a:float -> b:float -> float -> float
Sourceval hyperg_1F1_e : a:float -> b:float -> float -> Fun.result

hyperg_1F1 a b x computes the confluent hypergeometric function ₁F₁(a;b;x) = M(a,b,x) for general parameters a, b.

Sourceval hyperg_U_int : m:int -> n:int -> float -> float
Sourceval hyperg_U_int_e : m:int -> n:int -> float -> Fun.result

hyperg_U_int m n x computes the confluent hypergeometric function U(m,n,x) for integer parameters m, n.

Sourceval hyperg_U_int_e10 : m:int -> n:int -> float -> Fun.result_e10

hyperg_U_int_e10 m n x computes the confluent hypergeometric function U(m,n,x) for integer parameters m, n with extended range.

Sourceval hyperg_U : a:float -> b:float -> float -> float
Sourceval hyperg_U_e : a:float -> b:float -> float -> Fun.result

hyperg_U a b x computes the confluent hypergeometric function U(a,b,x).

Sourceval hyperg_U_e10 : a:float -> b:float -> float -> Fun.result_e10

hyperg_U_e10 a b x computes the confluent hypergeometric function U(a,b,x) with extended range.

Sourceval hyperg_2F1 : a:float -> b:float -> c:float -> float -> float
Sourceval hyperg_2F1_e : a:float -> b:float -> c:float -> float -> Fun.result

hyperg_2F1 a b c x computes the Gauss hypergeometric function ₂F₁(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 raise the exception Error.Gsl_exn(Error.EMAXITER, _) when the series approximation converges too slowly. This occurs in the region of x=1, c - a - b ∈ ℤ.

Sourceval hyperg_2F1_conj : aR:float -> aI:float -> c:float -> float -> float
Sourceval hyperg_2F1_conj_e : aR:float -> aI:float -> c:float -> float -> Fun.result

hyperg_2F1_conj aR aI c x computes the Gauss hypergeometric function ₂F₁(aR + i aI, aR - i aI, c, x) with complex parameters for |x| < 1.

Sourceval hyperg_2F1_renorm : a:float -> b:float -> c:float -> float -> float
Sourceval hyperg_2F1_renorm_e : a:float -> b:float -> c:float -> float -> Fun.result

hyperg_2F1_renorm a b c x computes the renormalized Gauss hypergeometric function ₂F₁(a,b,c,x) / Γ(c) for |x| < 1.

Sourceval hyperg_2F1_conj_renorm : aR:float -> aI:float -> c:float -> float -> float
Sourceval hyperg_2F1_conj_renorm_e : aR:float -> aI:float -> c:float -> float -> Fun.result

hyperg_2F1_conj_renorm aR aI c x computes the renormalized Gauss hypergeometric function ₂F₁(aR + i aI, aR - i aI, c, x) / Γ(c) for |x| < 1.

Sourceval hyperg_2F0 : a:float -> b:float -> float -> float
Sourceval hyperg_2F0_e : a:float -> b:float -> float -> Fun.result

hyperg_2F0 a b x computes the hypergeometric function ₂F₀(a,b,x). The series representation is a divergent hypergeometric series. However, for x < 0 we have ₂F₀(a,b,x) = (-1/x)ᵃ U(a,1+a-b,-1/x)

Laguerre functions

Sourceval laguerre_1 : a:float -> float -> float
Sourceval laguerre_1_e : a:float -> float -> Fun.result
Sourceval laguerre_2 : a:float -> float -> float
Sourceval laguerre_2_e : a:float -> float -> Fun.result
Sourceval laguerre_3 : a:float -> float -> float
Sourceval laguerre_3_e : a:float -> float -> Fun.result
Sourceval laguerre_n : n:int -> a:float -> float -> float
Sourceval laguerre_n_e : n:int -> a:float -> float -> Fun.result

Lambert W functions

Sourceval lambert_W0 : float -> float
Sourceval lambert_W0_e : float -> Fun.result
Sourceval lambert_Wm1 : float -> float
Sourceval lambert_Wm1_e : float -> Fun.result

Legendre functions

Sourceval legendre_P1 : float -> float
Sourceval legendre_P1_e : float -> Fun.result
Sourceval legendre_P2 : float -> float
Sourceval legendre_P2_e : float -> Fun.result
Sourceval legendre_P3 : float -> float
Sourceval legendre_P3_e : float -> Fun.result
Sourceval legendre_Pl : int -> float -> float
Sourceval legendre_Pl_e : int -> float -> Fun.result
Sourceval legendre_Pl_array : float -> float array -> unit
Sourceval legendre_Q0 : float -> float
Sourceval legendre_Q0_e : float -> Fun.result
Sourceval legendre_Q1 : float -> float
Sourceval legendre_Q1_e : float -> Fun.result
Sourceval legendre_Ql : int -> float -> float
Sourceval legendre_Ql_e : int -> float -> Fun.result

Associated Legendre functions and Spherical Harmonics

Sourcetype legendre_t =
  1. | Schmidt
    (*

    Specifies the computation of the Schmidt semi-normalized associated Legendre polynomials Sₗᵐ(x).

    *)
  2. | Spharm
    (*

    Specifies the computation of the spherical harmonic associated Legendre polynomials Yₗᵐ(x).

    *)
  3. | Full
    (*

    Specifies the computation of the fully normalized associated Legendre polynomials Nₗᵐ(x).

    *)
  4. | None
    (*

    Specifies the computation of the unnormalized associated Legendre polynomials Pₗᵐ(x).

    *)

Normalization of Legendre functions. See the GSL documentation.

Sourceval legendre_array : legendre_t -> int -> float -> float array -> unit

legendre_array norm lmax x result calculate all normalized associated Legendre polynomials for 0 ≤ llmax and 0 ≤ m ≤ l for |x| ≤ 1. The norm parameter specifies which normalization is used. The normalized Pₗᵐ(x) values are stored in result, whose minimum size can be obtained from calling legendre_array_n. The array index of Pₗᵐ(x) is obtained from calling legendre_array_index(l, m). To include or exclude the Condon-Shortley phase factor of (-1)ᵐ, set the parameter csphase to either -1 or 1 respectively in the _e function. This factor is included by default.

Sourceval legendre_array_n : int -> int

legendre_array_n lmax 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ₗᵐ(x) functions, plus extra space for precomputing multiplicative factors used in the recurrence relations.

Sourceval legendre_array_index : int -> int -> int

legendre_array_index l m returns the index into the result array of the legendre_array, legendre_deriv_array, legendre_deriv_alt_array, legendre_deriv2_array, and !legendre_deriv2_alt_array corresponding to Pₗᵐ(x), ∂ₓPₗᵐ(x), or ∂ₓ²Pₗₗᵐ(x). The index is given by l(l+1)/2 + m.

Sourceval legendre_Plm : int -> int -> float -> float
Sourceval legendre_Plm_e : int -> int -> float -> Fun.result

legendre_Plm l m x and legendre_Plm_e l m x compute the associated Legendre polynomial Pₗᵐ(x) for m ≥ 0, l ≥ m, |x| ≤ 1.

Sourceval legendre_sphPlm : int -> int -> float -> float
Sourceval legendre_sphPlm_e : int -> int -> float -> Fun.result

legendre_sphPlm l m x and legendre_Plm_e compute the normalized associated Legendre polynomial √((2l+1)/(4\pi)) √((l-m)!/(l+m)!) Pₗᵐ(x) suitable for use in spherical harmonics. The parameters must satisfy m ≥ 0, l ≥ m, |x| ≤ 1. Theses routines avoid the overflows that occur for the standard normalization of Pₗᵐ(x).

Logarithm and related functions

Sourceval log : float -> float
Sourceval log_e : float -> Fun.result
Sourceval log_abs : float -> float
Sourceval log_abs_e : float -> Fun.result
Sourceval log_complex_e : float -> float -> Fun.result * Fun.result
Sourceval log_1plusx : float -> float
Sourceval log_1plusx_e : float -> Fun.result
Sourceval log_1plusx_mx : float -> float
Sourceval log_1plusx_mx_e : float -> Fun.result

Power function

Sourceval pow_int : float -> int -> float
Sourceval pow_int_e : float -> int -> Fun.result

Psi (Digamma) function

Sourceval psi_int : int -> float
Sourceval psi_int_e : int -> Fun.result
Sourceval psi : float -> float
Sourceval psi_e : float -> Fun.result
Sourceval psi_1piy : float -> float
Sourceval psi_1piy_e : float -> Fun.result
Sourceval psi_complex_e : float -> float -> Fun.result * Fun.result
Sourceval psi_1_int : int -> float
Sourceval psi_1_int_e : int -> Fun.result
Sourceval psi_1 : float -> float
Sourceval psi_1_e : float -> Fun.result
Sourceval psi_n : int -> float -> float
Sourceval psi_n_e : int -> float -> Fun.result

Synchrotron functions

Sourceval synchrotron_1 : float -> float
Sourceval synchrotron_1_e : float -> Fun.result
Sourceval synchrotron_2 : float -> float
Sourceval synchrotron_2_e : float -> Fun.result

Transport functions

Sourceval transport_2 : float -> float
Sourceval transport_2_e : float -> Fun.result
Sourceval transport_3 : float -> float
Sourceval transport_3_e : float -> Fun.result
Sourceval transport_4 : float -> float
Sourceval transport_4_e : float -> Fun.result
Sourceval transport_5 : float -> float
Sourceval transport_5_e : float -> Fun.result

Trigonometric functions

Sourceval sin : float -> float
Sourceval sin_e : float -> Fun.result
Sourceval cos : float -> float
Sourceval cos_e : float -> Fun.result
Sourceval hypot : float -> float -> float
Sourceval hypot_e : float -> float -> Fun.result
Sourceval sinc : float -> float
Sourceval sinc_e : float -> Fun.result
Sourceval complex_sin_e : float -> float -> Fun.result * Fun.result
Sourceval complex_cos_e : float -> float -> Fun.result * Fun.result
Sourceval complex_logsin_e : float -> float -> Fun.result * Fun.result
Sourceval lnsinh : float -> float
Sourceval lnsinh_e : float -> Fun.result
Sourceval lncosh : float -> float
Sourceval lncosh_e : float -> Fun.result
Sourceval rect_of_polar : r:float -> theta:float -> Fun.result * Fun.result
Sourceval polar_of_rect : x:float -> y:float -> Fun.result * Fun.result
Sourceval angle_restrict_symm : float -> float
Sourceval angle_restrict_pos : float -> float
Sourceval sin_err_e : float -> dx:float -> Fun.result
Sourceval cos_err_e : float -> dx:float -> Fun.result

Zeta functions

Sourceval zeta_int : int -> float
Sourceval zeta_int_e : int -> Fun.result
Sourceval zeta : float -> float
Sourceval zeta_e : float -> Fun.result
Sourceval hzeta : float -> float -> float
Sourceval hzeta_e : float -> float -> Fun.result
Sourceval eta_int : int -> float
Sourceval eta_int_e : int -> Fun.result
Sourceval eta : float -> float
Sourceval eta_e : float -> Fun.result
OCaml

Innovation. Community. Security.