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.
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) + ⋯
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) + ⋯
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,
hyperg_0F1 c x computes the hypergeometric function ₀F₁(c; x).
val hyperg_1F1_int : m:int ->n:int ->float -> float
val 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.
val hyperg_1F1 : a:float ->b:float ->float -> float
val 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.
val hyperg_U_int : m:int ->n:int ->float -> float
val 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.
val 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.
val hyperg_U : a:float ->b:float ->float -> float
val hyperg_U_e : a:float ->b:float ->float ->Fun.result
hyperg_U a b x computes the confluent hypergeometric function U(a,b,x).
val 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.
val hyperg_2F1 : a:float ->b:float ->c:float ->float -> float
val 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 ∈ ℤ.
val hyperg_2F1_conj : aR:float ->aI:float ->c:float ->float -> float
val 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.
val hyperg_2F1_renorm : a:float ->b:float ->c:float ->float -> float
val 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.
val hyperg_2F1_conj_renorm : aR:float ->aI:float ->c:float ->float -> float
val 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.
val hyperg_2F0 : a:float ->b:float ->float -> float
val 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)
val legendre_array : legendre_t->int ->float ->float array-> unit
legendre_array norm lmax x result calculate all normalized associated Legendre polynomials for 0 ≤ l ≤ lmax 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.
val 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.
val legendre_array_index : int ->int -> int
legendre_array_index l m returns the index into the result array of 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.
val legendre_Plm : int ->int ->float -> float
val 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.
val legendre_sphPlm : int ->int ->float -> float
val 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).