txt: ## dist_cpan-FRITH-Math-Libgsl-Function.md
  ## Chunk 2 of 3
  These routines compute the incomplete elliptic integral P(φ, k) to the accuracy specified by the mode variable mode.
  
  ### sub D(Num(Cool) $Φ, Num(Cool) $k, UInt $mode --> Num) is export(:ellint)
  
  ### sub D-e(Num(Cool) $Φ, Num(Cool) $k, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral D(φ, k) to the accuracy specified by the mode variable mode.
  
  ### sub RC(Num(Cool) $x, Num(Cool) $y, UInt $mode --> Num) is export(:ellint)
  
  ### sub RC-e(Num(Cool) $x, Num(Cool) $y, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral RC(x, y) to the accuracy specified by the mode variable mode.
  
  ### sub RD(Num(Cool) $x, Num(Cool) $y, Num(Cool) $z, UInt $mode --> Num) is export(:ellint)
  
  ### sub RD-e(Num(Cool) $x, Num(Cool) $y, Num(Cool) $z, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral RD(x, y, z) to the accuracy specified by the mode variable mode.
  
  ### sub RF(Num(Cool) $x, Num(Cool) $y, Num(Cool) $z, UInt $mode --> Num) is export(:ellint)
  
  ### sub RF-e(Num(Cool) $x, Num(Cool) $y, Num(Cool) $z, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral RF(x, y, z) to the accuracy specified by the mode variable mode.
  
  ### sub RJ(Num(Cool) $x, Num(Cool) $y, Num(Cool) $z, Num(Cool) $p, UInt $mode --> Num) is export(:ellint)
  
  ### sub RJ-e(Num(Cool) $x, Num(Cool) $y, Num(Cool) $z, Num(Cool) $p, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral RJ(x, y, z, p) to the accuracy specified by the mode variable mode.
  
  ### sub elljac-e(Num(Cool) $u, Num(Cool) $m --> List) is export(:ellfun)
  
  This function computes the Jacobian elliptic functions sn(u|m), cn(u|m), dn(u|m) by descending Landen transformations.
  
  ### sub erf(Num(Cool) $x --> Num) is export(:err)
  
  ### sub erf-e(Num(Cool) $x --> List) is export(:err)
  
  These routines compute the error function erf(x).
  
  ### sub erfc(Num(Cool) $x --> Num) is export(:err)
  
  ### sub erfc-e(Num(Cool) $x --> List) is export(:err)
  
  These routines compute the complementary error function erfc(x) = 1 − erf(x).
  
  ### sub log-erfc(Num(Cool) $x --> Num) is export(:err)
  
  ### sub log-erfc-e(Num(Cool) $x --> List) is export(:err)
  
  These routines compute the logarithm of the complementary error function log(erfc(x)).
  
  ### sub erf-Z(Num(Cool) $x --> Num) is export(:err)
  
  ### sub erf-Z-e(Num(Cool) $x --> List) is export(:err)
  
  These routines compute the Gaussian probability density function Z(x).
  
  ### sub erf-Q(Num(Cool) $x --> Num) is export(:err)
  
  ### sub erf-Q-e(Num(Cool) $x --> List) is export(:err)
  
  These routines compute the upper tail of the Gaussian probability function Q(x).
  
  ### sub hazard(Num(Cool) $x --> Num) is export(:err)
  
  ### sub hazard-e(Num(Cool) $x --> List) is export(:err)
  
  These routines compute the hazard function for the normal distribution.
  
  ### sub gexp(Num(Cool) $x --> Num) is export(:exp)
  
  ### sub gexp-e(Num(Cool) $x --> List) is export(:exp)
  
  These routines provide an exponential function exp(x) using GSL semantics and error checking.
  
  ### sub gexp-e10(Num(Cool) $x --> List) is export(:exp)
  
  This function computes the exponential exp(x) and returns a result with extended range. This function may be useful if the value of exp(x) would overflow the numeric range of double. It returns a list of three numbers: the value, the error, and the scaling exponent.
  
  ### sub gexp-mult(Num(Cool) $x, Num(Cool) $y --> Num) is export(:exp)
  
  ### sub gexp-mult-e(Num(Cool) $x, Num(Cool) $y --> List) is export(:exp)
  
  These routines exponentiate x and multiply by the factor y to return the product y exp(x).
  
  ### sub gexp-mult-e10(Num(Cool) $x, Num(Cool) $y --> List) is export(:exp)
  
  This function computes the product y exp(x) and returns a result with extended range. This function may be useful if the value of exp(x) would overflow the numeric range of double. It returns a list of three numbers: the value, the error, and the scaling exponent.
  
  ### sub gexpm1(Num(Cool) $x --> Num) is export(:exp)
  
  ### sub gexpm1-e(Num(Cool) $x --> List) is export(:exp)
  
  These routines compute the quantity exp(x) − 1 using an algorithm that is accurate for small x.
  
  ### sub gexprel(Num(Cool) $x --> Num) is export(:exp)
  
  ### sub gexprel-e(Num(Cool) $x --> List) is export(:exp)
  
  These routines compute the quantity (exp(x) − 1)/x using an algorithm that is accurate for small x.
  
  ### sub gexprel2(Num(Cool) $x --> Num) is export(:exp)
  
  ### sub gexprel2-e(Num(Cool) $x --> List) is export(:exp)
  
  These routines compute the quantity 2(exp(x) − 1 − x)/x 2 using an algorithm that is accurate for small x.
  
  ### sub gexprel-n(Int $n, Num(Cool) $x --> Num) is export(:exp)
  
  ### sub gexprel-n-e(Int $n, Num(Cool) $x --> List) is export(:exp)
  
  These routines compute the N -relative exponential, which is the n-th generalization of the functions gexprel, gexprel2, gexprel-e, and gexprel2-e.
  
  ### sub gexp-err-e(Num(Cool) $x, Num(Cool) $dx --> List) is export(:exp)
  
  This function exponentiates x with an associated absolute error dx.
  
  ### sub gexp-err-e10(Num(Cool) $x, Num(Cool) $dx --> List) is export(:exp)
  
  This function exponentiates a quantity x with an associated absolute error dx and returns a result with extended range. This function may be useful if the value of exp(x) would overflow the numeric range of double. It returns a list of three numbers: the value, the error, and the scaling exponent.
  
  ### sub gexp-mult-err-e(Num(Cool) $x, Num(Cool) $dx, Num(Cool) $y, Num(Cool) $dy --> List) is export(:exp)
  
  This routine computes the product y exp(x) for the quantities x, y with associated absolute errors dx, dy.
  
  ### sub gexp-mult-err-e10(Num(Cool) $x, Num(Cool) $dx, Num(Cool) $y, Num(Cool) $dy --> List) is export(:exp)
  
  This routine computes the product y exp(x) for the quantities x, y with associated absolute errors dx, dy and returns a result with extended range. This function may be useful if the value of exp(x) would overflow the numeric range of double. It returns a list of three numbers: the value, the error, and the scaling exponent.
  
  ### sub E1(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub E1-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the exponential integral E₁(x).
  
  ### sub E2(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub E2-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the exponential integral E₂(x).
  
  ### sub En(Int $n, Num(Cool) $x --> Num) is export(:expint)
  
  ### sub En-e(Int $n, Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the exponential integral Eₙ(x) of order n.
  
  ### sub Ei(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub Ei-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the exponential integral Ei(x).
  
  ### sub Shi(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub Shi-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the hyperbolic integral Shi(x).
  
  ### sub Chi(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub Chi-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the hyperbolic integral Chi(x).
  
  ### sub expint3(Num(Cool) $x where \* ≥ 0 --> Num) is export(:expint)
  
  ### sub expint3-e(Num(Cool) $x where \* ≥ 0 --> List) is export(:expint)
  
  These routines compute the third-order exponential integral Ei₃(x).
  
  ### sub Si(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub Si-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the Sine integral Si(x).
  
  ### sub Ci(Num(Cool) $x where \* > 0 --> Num) is export(:expint)
  
  ### sub Ci-e(Num(Cool) $x where \* > 0 --> List) is export(:expint)
  
  These routines compute the Cosine integral Ci(x).
  
  ### sub atanint(Num(Cool) $x --> Num) is export(:expint)
  
  ### sub atanint-e(Num(Cool) $x --> List) is export(:expint)
  
  These routines compute the Arctangent integral.
  
  ### sub fd-m1(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd-m1-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral with an index of −1.
  
  ### sub fd0(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd0-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral with an index of 0.
  
  ### sub fd1(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd1-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral with an index of 1.
  
  ### sub fd2(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd2-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral with an index of 2.
  
  ### sub fd-int(Int $j, Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd-int-e(Int $j, Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral with an integer index j.
  
  ### sub fd-mhalf(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd-mhalf-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral F₋₁/₂(x).
  
  ### sub fd-half(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd-half-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral F₁/₂(x).
  
  ### sub fd-half3(Num(Cool) $x --> Num) is export(:fermidirac)
  
  ### sub fd-half3-e(Num(Cool) $x --> List) is export(:fermidirac)
  
  These routines compute the complete Fermi-Dirac integral F₃/₂(x).
  
  ### sub fd-inc0(Num(Cool) $x, Num(Cool) $b --> Num) is export(:fermidirac)
  
  ### sub fd-inc0-e(Num(Cool) $x, Num(Cool) $b --> List) is export(:fermidirac)
  
  These routines compute the incomplete Fermi-Dirac integral with an index of zero, F₀(x, b).
  
  ### sub gamma(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> Num) is export(:gammabeta)
  
  ### sub gamma-e(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> List) is export(:gammabeta)
  
  These routines compute the Gamma function Γ(x).
  
  ### sub lngamma(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> Num) is export(:gammabeta)
  
  ### sub lngamma-e(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> List) is export(:gammabeta)
  
  These routines compute the logarithm of the Gamma function, log(Γ(x)).
  
  ### sub lngamma-sgn-e(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> List) is export(:gammabeta)
  
  This routine computes the sign of the gamma function and the logarithm of its magnitude. It returns three numbers: the value, its associated error, and the sign.
  
  ### sub gammastar(Num(Cool) $x where \* > 0 --> Num) is export(:gammabeta)
  
  ### sub gammastar-e(Num(Cool) $x where \* > 0 --> List) is export(:gammabeta)
  
  These routines compute the regulated Gamma Function Γ\*(x).
  
  ### sub gammainv(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> Num) is export(:gammabeta)
  
  ### sub gammainv-e(Num(Cool) $x where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> List) is export(:gammabeta)
  
  These routines compute the reciprocal of the gamma function, 1/Γ(x) using the real Lanczos method.
  
  ### sub lngamma-complex-e(Num(Cool) $zr where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) }, Num(Cool) $zi where { $\_ > 0 || ($\_ < 0 && $\_ ≠ $\_.Int) } --> List) is export(:gammabeta)
  
  This routine computes log(Γ(z)) for complex z = zᵣ + izᵢ. The returned parameters are lnr = log |Γ(z)|, its error, arg = arg(Γ(z)) in (−π, π], and its error.
  
  ### sub fact(UInt $n where \* ≤ GSL\_SF\_FACT\_NMAX --> Num) is export(:gammabeta)
  
  ### sub fact-e(UInt $n where \* ≤ GSL\_SF\_FACT\_NMAX --> List) is export(:gammabeta)
  
  These routines compute the factorial n!.
  
  ### sub doublefact(UInt $n where \* ≤ GSL\_SF\_DOUBLEFACT\_NMAX --> Num) is export(:gammabeta)
  
  ### sub doublefact-e(UInt $n where \* ≤ GSL\_SF\_DOUBLEFACT\_NMAX --> List) is export(:gammabeta)
  
  These routines compute the double factorial n!! = n(n − 2)(n − 4)…
  
  ### sub lnfact(UInt $n --> Num) is export(:gammabeta)
  
  ### sub lnfact-e(UInt $n --> List) is export(:gammabeta)
  
  These routines compute the logarithm of the factorial of n, log(n!).
  
  ### sub lndoublefact(UInt $n --> Num) is export(:gammabeta)
  
  ### sub lndoublefact-e(UInt $n --> List) is export(:gammabeta)
  
  These routines compute the logarithm of the double factorial of n, log(n!!).
  
  ### sub choose(UInt $n, UInt $m --> Num) is export(:gammabeta)
  
  ### sub choose-e(UInt $n, UInt $m --> List) is export(:gammabeta)o
  
  These routines compute the combinatorial factor n choose m = n!/(m!(n − m)!).
  
  ### sub lnchoose(UInt $n, UInt $m --> Num) is export(:gammabeta)
  
  ### sub lnchoose-e(UInt $n, UInt $m --> List) is export(:gammabeta)
  
  These routines compute the logarithm of n choose m.
  
  ### sub taylorcoeff(UInt $n, Num(Cool) $x where \* ≥ 0 --> Num) is export(:gammabeta)
  
  ### sub taylorcoeff-e(UInt $n, Num(Cool) $x where \* ≥ 0 --> List) is export(:gammabeta)
  
  These routines compute the Taylor coefficient xⁿ/n!.
  
  ### sub poch(Num(Cool) $a, Num(Cool) $x --> Num) is export(:gammabeta)
  
  ### sub poch-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta)
  
  These routines compute the Pochhammer symbol (a)ₓ = Γ(a + x)/Γ(a).
  
  ### sub lnpoch(Num(Cool) $a, Num(Cool) $x --> Num) is export(:gammabeta)
  
  ### sub lnpoch-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta)
  
  These routines compute the Pochhammer symbol log((a)ₓ) = log(Γ(a + x)/Γ(a)).
  
  ### sub lnpoch-sgn-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta)
  
  These routines compute the sign of the Pochhammer symbol and the logarithm of its magnitude. It returns three numbers: the value, its associated error, and the sign.
  
  ### sub pochrel(Num(Cool) $a, Num(Cool) $x --> Num) is export(:gammabeta)
  
  ### sub pochrel-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta)
  
  These routines compute the relative Pochhammer symbol ((a)ₓ − 1)/x
  
  ### sub gamma-inc(Num(Cool) $a where \* > 0, Num(Cool) $x where \* ≥ 0 --> Num) is export(:gammabeta)
  
  ### sub gamma-inc-e(Num(Cool) $a, Num(Cool) $x where \* ≥ 0 --> List) is export(:gammabeta)
  
  These functions compute the unnormalized incomplete Gamma Function Γ(a, x).
  
  ### sub gamma-inc-Q(Num(Cool) $a where \* > 0, Num(Cool) $x where \* ≥ 0 --> Num) is export(:gammabeta)
  
  ### sub gamma-inc-Q-e(Num(Cool) $a where \* > 0, Num(Cool) $x where \* ≥ 0 --> List) is export(:gammabeta)
  
  These routines compute the normalized incomplete Gamma Function Q(a, x) = 1/Γ(a).
  
  ### sub gamma-inc-P(Num(Cool) $a where \* > 0, Num(Cool) $x where \* ≥ 0 --> Num) is export(:gammabeta)
  
  ### sub gamma-inc-P-e(Num(Cool) $a where \* > 0, Num(Cool) $x where \* ≥ 0 --> List) is export(:gammabeta)
  
  These routines compute the complementary normalized incomplete Gamma Function P (a, x).
  
  ### sub beta(Num(Cool) $a where \* > 0, Num(Cool) $b where \* > 0 --> Num) is export(:gammabeta)
  
  ### sub beta-e(Num(Cool) $a where \* > 0, Num(Cool) $b where \* > 0 --> List) is export(:gammabeta)
  
  These routines compute the Beta Function, B(a, b).
  
  ### sub lnbeta(Num(Cool) $a where \* > 0, Num(Cool) $b where \* > 0 --> Num) is export(:gammabeta)
  
  ### sub lnbeta-e(Num(Cool) $a where \* > 0, Num(Cool) $b where \* > 0 --> List) is export(:gammabeta)
  
  These routines compute the logarithm of the Beta Function, log(B(a, b)).
  
  ### sub beta-inc(Num(Cool) $a where \* > 0, Num(Cool) $b where \* > 0, Num(Cool) $x where 0 ≤ \* ≤ 1 --> Num) is export(:gammabeta)
  
  ### sub beta-inc-e(Num(Cool) $a where \* > 0, Num(Cool) $b where \* > 0, Num(Cool) $x where 0 ≤ \* ≤ 1 --> List) is export(:gammabeta)
  
  These routines compute the normalized incomplete Beta function I x (a, b).
  
  ### sub gegenpoly1(Num(Cool) $lambda, Num(Cool) $x --> Num) is export(:gegen)
  
  ### sub gegenpoly1-e(Num(Cool) $lambda, Num(Cool) $x --> List) is export(:gegen)
  
  ### sub gegenpoly2(Num(Cool) $lambda, Num(Cool) $x --> Num) is export(:gegen)
  
  ### sub gegenpoly2-e(Num(Cool) $lambda, Num(Cool) $x --> List) is export(:gegen)
  
  ### sub gegenpoly3(Num(Cool) $lambda, Num(Cool) $x --> Num) is export(:gegen)
  
  ### sub gegenpoly3-e(Num(Cool) $lambda, Num(Cool) $x --> List) is export(:gegen)
  
  These functions evaluate the Gegenbauer polynomials Cₙλ(x) using explicit representations for n = 1, 2, 3.
  
  ### sub gegenpolyn(UInt $n, Num(Cool) $lambda where \* > -½, Num(Cool) $x --> Num) is export(:gegen)
  
  ### sub gegenpolyn-e(UInt $n, Num(Cool) $lambda where \* > -½, Num(Cool) $x --> List) is export(:gegen)
  
  These functions evaluate the Gegenbauer polynomials Cₙλ(x) for a specific value of n, λ, x.
  
  ### sub gegenpoly-array(UInt $nmax, Num(Cool) $lambda where \* > -½, Num(Cool) $x --> List) is export(:gegen)
  
  This function computes an array of Gegenbauer polynomials Cₙλ(x) for n = 0, 1, 2 … $nmax.
  
  ### sub hermite(Int $n, Num(Cool) $x --> Num) is export(:hermite)
  
  ### sub hermite-e(Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  These routines evaluate the physicist Hermite polynomial H n (x) of order n at position x.
  
  ### sub hermite-array(Int $nmax, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates all physicist Hermite polynomials H n up to order nmax at position x.
  
  ### sub hermite-series(Int $n, Num(Cool) $x, \*@a --> Num) is export(:hermite)
  
  ### sub hermite-series-e(Int $n, Num(Cool) $x, \*@a --> List) is export(:hermite)
  
  These routines evaluate the series Σ aⱼHⱼ(x) for j = 0 … n.
  
  ### sub hermite-prob(Int $n, Num(Cool) $x --> Num) is export(:hermite)
  
  ### sub hermite-prob-e(Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  These routines evaluate the probabilist Hermite polynomial He n (x) of order n at position x.
  
  ### sub hermite-prob-array(Int $nmax, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates all probabilist Hermite polynomials Heₙ(x) up to order nmax at position x.
  
  ### sub hermite-prob-series(Int $n, Num(Cool) $x, \*@a --> Num) is export(:hermite)
  
  ### sub hermite-prob-series-e(Int $n, Num(Cool) $x, \*@a --> List) is export(:hermite)
  
  These routines evaluate the series Σ aⱼHeⱼ(x) for j = 0 … n.
  
  ### sub hermite-der(Int $n, Int $m, Num(Cool) $x --> Num) is export(:hermite)
  
  ### sub hermite-der-e(Int $n, Int $m, Num(Cool) $x --> List) is export(:hermite)
  
  These routines evaluate the m-th derivative of the physicist Hermite polynomial Hₙ(x) of order n at position x.
  
  ### sub hermite-array-der(Int $m, Int $nmax, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates the m-th derivative of all physicist Hermite polynomials Hₙ(x) from orders 0 … nmax at position x.
  
  ### sub hermite-der-array(Int $mmax, Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates all derivative orders from 0 … mmax of the physicist Hermite polynomial of order n, Hₙ, at position x.
  
  ### sub hermite-prob-der(Int $m, Int $n, Num(Cool) $x --> Num) is export(:hermite)
  
  ### sub hermite-prob-der-e(Int $m, Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  These routines evaluate the m-th derivative of the probabilist Hermite polynomial Heₙ(x) of order n at position x.
  
  ### sub hermite-prob-array-der(Int $m, Int $nmax, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates the m-th derivative of all probabilist Hermite polynomials Heₙ(x) from orders 0 … nmax at position x.
  
  ### sub hermite-prob-der-array(Int $mmax, Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates all derivative orders from 0 … mmax of the probabilist Hermite polynomial of order n, Heₙ, at position x.
  
  ### sub hermite-func(Int $n, Num(Cool) $x --> Num) is export(:hermite)
  
  ### sub hermite-func-e(Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  These routines evaluate the Hermite function ψₙ(x) of order n at position x.
  
  ### sub hermite-func-array(Int $nmax, Num(Cool) $x --> List) is export(:hermite)
  
  This routine evaluates all Hermite functions ψₙ(x) for orders n = 0 … nmax at position x.
  
  ### sub hermite-func-series(Int $n, Num(Cool) $x, \*@a --> Num) is export(:hermite)
  
  ### sub hermite-func-series-e(Int $n, Num(Cool) $x, \*@a --> List) is export(:hermite)
  
  These routines evaluate the series Σ aⱼψⱼ(x) for j = 0 … n.
  
  ### sub hermite-func-der(Int $m, Int $n, Num(Cool) $x --> Num) is export(:hermite)
  
  ### sub hermite-func-der-e(Int $m, Int $n, Num(Cool) $x --> List) is export(:hermite)
  
  These routines evaluate the m-th derivative of the Hermite function ψₙ(x) of order n at position x.
  
  ### sub hermite-zero(Int $n, Int $s --> Num) is export(:hermite)
  
  ### sub hermite-zero-e(Int $n, Int $s --> List) is export(:hermite)
  
  These routines evaluate the s-th zero of the physicist Hermite polynomial Hₙ(x) of order n.
  
  ### sub hermite-prob-zero(Int $n, Int $s --> Num) is export(:hermite)
  
  ### sub hermite-prob-zero-e(Int $n, Int $s --> List) is export(:hermite)
  
  These routines evaluate the s-th zero of the probabilist Hermite polynomial Heₙ(x) of order n.
  
  ### sub hermite-func-zero(Int $n, Int $s --> Num) is export(:hermite)
  
  ### sub hermite-func-zero-e(Int $n, Int $s --> List) is export(:hermite)
  
  These routines evaluate the s-th zero of the Hermite function ψₙ(x) of order n.
  
  ### sub F01(Num(Cool) $c, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub F01-e(Num(Cool) $c, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the hypergeometric function ₀F₁(c, x).
  
  ### sub F11(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub F11-e(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the confluent hypergeometric function ₁F₁(a, b, x).
  
  ### sub F11-int(Int $m, Int $n, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub F11-int-e(Int $m, Int $n, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the confluent hypergeometric function ₁F₁(m, n, x) for integer parameters m, n.
  
  ### sub U(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub U-e(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the confluent hypergeometric function U(a, b, x).
  
  ### sub U-e10(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> List) is export(:hyperg)
  
  This routine computes the confluent hypergeometric function U(a, b, x) and returns a result with extended range. It returns a list of three numbers: the value, the error, and the scaling exponent.
  
  ### sub U-int(Int $m, Int $n, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub U-int-e(Int $m, Int $n, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the confluent hypergeometric function U(m, n, x) for integer parameters m, n.
  
  ### sub U-int-e10(Int $m, Int $n, Num(Cool) $x --> List) is export(:hyperg)
  
  This routine computes the confluent hypergeometric function U(m, n, x) for integer parameters m, n and returns a result with extended range. It returns a list of three numbers: the value, the error, and the scaling exponent.
  
  ### sub F21(Num(Cool) $a, Num(Cool) $b, Num(Cool) $c, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub F21-e(Num(Cool) $a, Num(Cool) $b, Num(Cool) $c, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the Gauss hypergeometric function ₂F₁(a, b, c, x).
  
  ### sub F21-conj(Num(Cool) $aR, Num(Cool) $aI, Num(Cool) $c, Num(Cool) $x where -1 < \* < 1 --> Num) is export(:hyperg)
  
  ### sub F21-conj-e(Num(Cool) $aR, Num(Cool) $aI, Num(Cool) $c, Num(Cool) $x where -1 < \* < 1 --> List) is export(:hyperg)
  
  These routines compute the Gauss hypergeometric function ₂F₁(aᵣ + iaᵢ, aᵣ − iaᵢ, c, x).
  
  ### sub F21-renorm(Num(Cool) $a, Num(Cool) $b, Num(Cool) $c, Num(Cool) $x where -1 < \* < 1 --> Num) is export(:hyperg)
  
  ### sub F21-renorm-e(Num(Cool) $a, Num(Cool) $b, Num(Cool) $c, Num(Cool) $x where -1 < \* < 1 --> List) is export(:hyperg)
  
  These routines compute the renormalized Gauss hypergeometric function ₂F₁(a, b, c, x)/Γ(c).
  
  ### sub F21-conj-renorm(Num(Cool) $aR, Num(Cool) $aI, Num(Cool) $c, Num(Cool) $x where -1 < \* < 1 --> Num) is export(:hyperg)
  
  ### sub F21-conj-renorm-e(Num(Cool) $aR, Num(Cool) $aI, Num(Cool) $c, Num(Cool) $x where -1 < \* < 1 --> List) is export(:hyperg)
  
  These routines compute the renormalized Gauss hypergeometric function ₂F₁(aᵣ + iaᵢ, aᵣ − iaᵢ, c, x)/Γ(c).
  
  ### sub F20(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> Num) is export(:hyperg)
  
  ### sub F20-e(Num(Cool) $a, Num(Cool) $b, Num(Cool) $x --> List) is export(:hyperg)
  
  These routines compute the hypergeometric function ₂F₀(a, b, x).
  
  ### sub laguerre1(Num(Cool) $a, Num(Cool) $x --> Num) is export(:laguerre)
  
  ### sub laguerre1-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:laguerre)
  
  ### sub laguerre2(Num(Cool) $a, Num(Cool) $x --> Num) is export(:laguerre)
  
  ### sub laguerre2-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:laguerre)
  
  ### sub laguerre3(Num(Cool) $a, Num(Cool) $x --> Num) is export(:laguerre)
  
  ### sub laguerre3-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:laguerre)
  
  These routines evaluate the generalized Laguerre polynomials L₁a(x), L₂a(x), L₃a(x) using explicit representations.
  
  ### sub laguerre-n(UInt $n, Num(Cool) $a where \* > -1, Num(Cool) $x --> Num) is export(:laguerre)
  
  ### sub laguerre-n-e(UInt $n, Num(Cool) $a where \* > -1, Num(Cool) $x --> List) is export(:laguerre)
  
  These routines evaluate the generalized Laguerre polynomials Lₙa(x).
  
  ### sub lambert-W0(Num(Cool) $x --> Num) is export(:lambert)
  
  ### sub lambert-W0-e(Num(Cool) $x --> List) is export(:lambert