txt: ## dist_zef-FRITH-Math-Libgsl-Function.md
  ## Chunk 1 of 3
  [![Actions Status](https://github.com/frithnanth/raku-Math-Libgsl-Function/workflows/test/badge.svg)](https://github.com/frithnanth/raku-Math-Libgsl-Function/actions)
  
  # NAME
  
  Math::Libgsl::Function - An interface to libgsl, the Gnu Scientific Library - Special functions.
  
  # SYNOPSIS
  
  ```
  use Math::Libgsl::Raw::Function :ALL;
  
  use Math::Libgsl::Function :ALL;
  
  ```
  
  # DESCRIPTION
  
  Math::Libgsl::Function provides an interface to special function evaluation in libgsl, the GNU Scientific Library.
  
  Math::Libgsl::Function makes these tags available:
  
  * :airy
  * :bessel
  * :coulomb
  * :coupling
  * :dawson
  * :debye
  * :dilog
  * :mult
  * :ellint
  * :ellfun
  * :err
  * :exp
  * :fermidirac
  * :gammabeta
  * :gegen
  * :hermite
  * :hyperg
  * :laguerre
  * :lambert
  * :legendre
  * :log
  * :mathieu
  * :pow
  * :psi
  * :sync
  * :transport
  * :trig
  * :zeta
  
  Throughout this module the subs whose name ends with "-e" return a List of two values: the result and its associated error.
  
  ### sub Ai(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Ai-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the Airy function Ai(x) with an accuracy specified by mode.
  
  ### sub Bi(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Bi-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the Airy function Bi(x) with an accuracy specified by mode.
  
  ### sub Ai-scaled(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Ai-scaled-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the scaled value of the Airy function Ai(x) with an accuracy specified by mode.
  
  ### sub Bi-scaled(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Bi-scaled-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the scaled value of the Airy function Bi(x) with an accuracy specified by mode.
  
  ### sub Ai-deriv(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Ai-deriv-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the scaled value of the Airy function derivative A'i(x) with an accuracy specified by mode.
  
  ### sub Bi-deriv(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Bi-deriv-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the scaled value of the Airy function derivative B'i(x) with an accuracy specified by mode.
  
  ### sub Ai-deriv-scaled(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Ai-deriv-scaled-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the scaled value of the Airy function derivative A'i(x) with an accuracy specified by mode.
  
  ### sub Bi-deriv-scaled(Num(Cool) $x, UInt $mode --> Num) is export(:airy)
  
  ### sub Bi-deriv-scaled-e(Num(Cool) $x, UInt $mode --> List) is export(:airy)
  
  These routines compute the scaled value of the Airy function derivative B'i(x) with an accuracy specified by mode.
  
  ### sub Ai-zero(UInt $s --> Num) is export(:airy)
  
  ### sub Ai-zero-e(UInt $s --> List) is export(:airy)
  
  These routines compute the location of the s-th zero of the Airy function Ai(x).
  
  ### sub Bi-zero(UInt $s --> Num) is export(:airy)
  
  ### sub Bi-zero-e(UInt $s --> List) is export(:airy)
  
  These routines compute the location of the s-th zero of the Airy function Bi(x).
  
  ### sub Ai-deriv-zero(UInt $s --> Num) is export(:airy)
  
  ### sub Ai-deriv-zero-e(UInt $s --> List) is export(:airy)
  
  These routines compute the location of the s-th zero of the Airy function derivative A'i(x).
  
  ### sub Bi-deriv-zero(UInt $s --> Num) is export(:airy)
  
  ### sub Bi-deriv-zero-e(UInt $s --> List) is export(:airy)
  
  These routines compute the location of the s-th zero of the Airy function derivative B'i(x).
  
  ### sub J0(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub J0-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular cylindrical Bessel function of zeroth order, J₀(x).
  
  ### sub J1(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub J1-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular cylindrical Bessel function of first order, J₁(x).
  
  ### sub Jn(Int $n, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub Jn-e(Int $n, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular cylindrical Bessel function of order n, Jₙ(x).
  
  ### sub Jn-array(Int $nmin, Int $nmax where $nmin < $nmax, Num(Cool) $x --> List) is export(:bessel)
  
  This routine computes the values of the regular cylindrical Bessel functions Jₙ(x) for n from nmin to nmax inclusive.
  
  ### sub Y0(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Y0-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular cylindrical Bessel function of zeroth order, Y₀(x).
  
  ### sub Y1(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Y1-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular cylindrical Bessel function of first order, Y₁(x).
  
  ### sub Yn(Int $n, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Yn-e(Int $n, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular cylindrical Bessel function of order n, Yₙ(x).
  
  ### sub Yn-array(Int $nmin, Int $nmax where $nmin < $nmax, Num(Cool) $x --> List) is export(:bessel)
  
  This routine computes the values of the irregular cylindrical Bessel functions Yₙ(x) for n from nmin to nmax inclusive.
  
  ### sub I0(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub I0-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular modified cylindrical Bessel function of zeroth order, I₀(x).
  
  ### sub I1(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub I1-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular modified cylindrical Bessel function of first order, I₁(x).
  
  ### sub In(Int $n, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub In-e(Int $n, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular modified cylindrical Bessel function of order n, Iₙ(x).
  
  ### sub In-array(UInt $nmin, UInt $nmax where $nmin < $nmax, Num(Cool) $x --> List) is export(:bessel)
  
  This routine computes the values of the regular modified cylindrical Bessel functions Iₙ(x) for n from nmin to nmax inclusive.
  
  ### sub I0-scaled(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub I0-scaled-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified cylindrical Bessel function of zeroth order exp(−|x|)I₀(x).
  
  ### sub I1-scaled(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub I1-scaled-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified cylindrical Bessel function of first order exp(−|x|)I₁(x).
  
  ### sub In-scaled(Int $n, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub In-scaled-e(Int $n, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified cylindrical Bessel function of order n exp(−|x|)Iₙ(x).
  
  ### sub In-scaled-array(UInt $nmin, UInt $nmax where $nmin < $nmax, Num(Cool) $x --> List) is export(:bessel)
  
  This routine computes the values of the scaled regular cylindrical Bessel functions exp(−|x|)Iₙ(x) for n from nmin to nmax inclusive.
  
  ### sub K0(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub K0-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular modified cylindrical Bessel function of zeroth order, K₀(x).
  
  ### sub K1(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub K1-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular modified cylindrical Bessel function of first order, K₁(x).
  
  ### sub Kn(Int $n, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Kn-e(Int $n, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular modified cylindrical Bessel function of order n, Kₙ(x).
  
  ### sub Kn-array(UInt $nmin, UInt $nmax where $nmin < $nmax, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  This routine computes the values of the irregular modified cylindrical Bessel functions K n (x) for n from nmin to nmax inclusive.
  
  ### sub K0-scaled(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub K0-scaled-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified cylindrical Bessel function of zeroth order exp(x)K₀(x).
  
  ### sub K1-scaled(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub K1-scaled-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified cylindrical Bessel function of first order exp(x)K₁(x).
  
  ### sub Kn-scaled(Int $n, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Kn-scaled-e(Int $n, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified cylindrical Bessel function of order n exp(x)Kₙ(x).
  
  ### sub Kn-scaled-array(UInt $nmin, UInt $nmax where $nmin < $nmax, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  This routine computes the values of the scaled irregular cylindrical Bessel functions exp(x)Kₙ(x) for n from nmin to nmax inclusive.
  
  ### sub j0(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub j0-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular spherical Bessel function of zeroth order, j₀(x).
  
  ### sub j1(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub j1-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular spherical Bessel function of first order, j₁(x).
  
  ### sub j2(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub j2-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular spherical Bessel function of second order, j₂(x).
  
  ### sub jl(UInt $l, Num(Cool) $x where \* ≥ 0 --> Num) is export(:bessel)
  
  ### sub jl-e(UInt $l, Num(Cool) $x where \* ≥ 0 --> List) is export(:bessel)
  
  These routines compute the regular spherical Bessel function of order l, jₗ(x).
  
  ### sub jl-array(UInt $lmax, Num(Cool) $x where \* ≥ 0 --> List) is export(:bessel)
  
  This routine computes the values of the regular spherical Bessel functions jₗ(x) for l from 0 to lmax inclusive.
  
  ### sub jl-steed-array(UInt $lmax, Num(Cool) $x where \* ≥ 0 --> List) is export(:bessel)
  
  This routine uses Steed’s method to compute the values of the regular spherical Bessel functions jₗ(x) for l from 0 to lmax inclusive.
  
  ### sub y0(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub y0-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the irregular spherical Bessel function of zeroth order, y₀(x).
  
  ### sub y1(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub y1-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the irregular spherical Bessel function of first order, y₁(x).
  
  ### sub y2(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub y2-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the irregular spherical Bessel function of second order, y₂(x).
  
  ### sub yl(UInt $l, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub yl-e(UInt $l, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the irregular spherical Bessel function of order l, yₗ(x).
  
  ### sub yl-array(UInt $lmax, Num(Cool) $x --> List) is export(:bessel)
  
  This routine computes the values of the irregular spherical Bessel functions yₗ(x) for l from 0 to lmax inclusive.
  
  ### sub i0-scaled(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub i0-scaled-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified spherical Bessel function of zeroth order.
  
  ### sub i1-scaled(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub i1-scaled-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified spherical Bessel function of first order.
  
  ### sub i2-scaled(Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub i2-scaled-e(Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified spherical Bessel function of second order.
  
  ### sub il-scaled(UInt $l, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub il-scaled-e(UInt $l, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the scaled regular modified spherical Bessel function of order l.
  
  ### sub il-scaled-array(UInt $lmax, Num(Cool) $x --> List) is export(:bessel)
  
  This routine computes the values of the scaled regular modified spherical Bessel functions for l from 0 to lmax inclusive.
  
  ### sub k0-scaled(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub k0-scaled-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified spherical Bessel function of zeroth order.
  
  ### sub k1-scaled(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub k1-scaled-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified spherical Bessel function of first order.
  
  ### sub k2-scaled(Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub k2-scaled-e(Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified spherical Bessel function of second order.
  
  ### sub kl-scaled(UInt $l, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub kl-scaled-e(UInt $l, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified spherical Bessel function of order l.
  
  ### sub kl-scaled-array(UInt $lmax, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  This routine computes the values of the scaled irregular modified spherical Bessel functions for l from 0 to lmax inclusive.
  
  ### sub Jnu(Num(Cool) $ν, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub Jnu-e(Num(Cool) $ν, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the regular cylindrical Bessel function of fractional order ν, Jν(x).
  
  ### sub Jnu-sequence(Num(Cool) $ν, UInt $mode, Positional $x --> List) is export(:bessel)
  
  This function computes the regular cylindrical Bessel function of fractional order ν, Jν(x), with an accuracy specified by $mode, evaluated at a series of x values.
  
  ### sub Ynu(Num(Cool) $ν, Num(Cool) $x --> Num) is export(:bessel)
  
  ### sub Ynu-e(Num(Cool) $ν, Num(Cool) $x --> List) is export(:bessel)
  
  These routines compute the irregular cylindrical Bessel function of fractional order ν, Yν(x).
  
  ### sub Inu(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0--> Num) is export(:bessel)
  
  ### sub Inu-e(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the regular modified Bessel function of fractional order ν, Iν(x).
  
  ### sub Inu-scaled(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Inu-scaled-e(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled regular modified Bessel function of fractional order ν.
  
  ### sub Knu(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Knu-e(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the irregular modified Bessel function of fractional order ν, Kν(x).
  
  ### sub lnKnu(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub lnKnu-e(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the logarithm of the irregular modified Bessel function of fractional order ν, ln(Kν(x)).
  
  ### sub Knu-scaled(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> Num) is export(:bessel)
  
  ### sub Knu-scaled-e(Num(Cool) $ν where \* > 0, Num(Cool) $x where \* > 0 --> List) is export(:bessel)
  
  These routines compute the scaled irregular modified Bessel function of fractional order ν.
  
  ### sub J0-zero(UInt $s --> Num) is export(:bessel)
  
  ### sub J0-zero-e(UInt $s --> List) is export(:bessel)
  
  These routines compute the location of the s-th positive zero of the Bessel function J₀(x).
  
  ### sub J1-zero(UInt $s --> Num) is export(:bessel)
  
  ### sub J1-zero-e(UInt $s --> List) is export(:bessel)
  
  These routines compute the location of the s-th positive zero of the Bessel function J₁(x).
  
  ### sub Jnu-zero(Num(Cool) $ν where \* ≥ 0, UInt $s --> Num) is export(:bessel)
  
  ### sub Jnu-zero-e(Num(Cool) $ν where \* ≥ 0, UInt $s --> List) is export(:bessel)
  
  These routines compute the location of the s-th positive zero of the Bessel function Jν(x).
  
  ### sub clausen(Num(Cool) $x --> Num) is export(:clausen)
  
  ### sub clausen-e(Num(Cool) $x --> List) is export(:clausen)
  
  These routines compute the Clausen integral Cl₂(x).
  
  ### sub hydrogenic-R1(Num(Cool) $Z, Num(Cool) $r --> Num) is export(:coulomb)
  
  ### sub hydrogenic-R1-e(Num(Cool) $Z, Num(Cool) $r --> List) is export(:coulomb)
  
  These √ routines compute the lowest-order normalized hydrogenic bound state radial wavefunction R₁.
  
  ### sub hydrogenic-R(Int $n, Int $l, Num(Cool) $Z, Num(Cool) $r --> Num) is export(:coulomb)
  
  ### sub hydrogenic-R-e(Int $n, Int $l, Num(Cool) $Z, Num(Cool) $r --> List) is export(:coulomb)
  
  These routines compute the n-th normalized hydrogenic bound state radial wavefunction Rₙ.
  
  ### sub coulomb-wave-FG-e(Num(Cool) $eta, Num(Cool) $x where \* > 0, Num(Cool) $LF where \* > -½, Int $k --> List) is export(:coulomb)
  
  This function computes the Coulomb wave functions Fₗ(η, x), Gₗ₋ₖ(η, x) and their derivatives Fₗ’(η, x), Gₗ₋ₖ’(η, x) with respect to x. It returns a List of Pairs (that can be read as a Hash):
  
  * :Fval the Fₗ(η, x) value
  * :Ferr the Fₗ(η, x) error
  * :Fpval the Fₗ’(η, x) value
  * :Fperr the Fₗ’(η, x) error
  * :Gval the Gₗ₋ₖ(η, x) value
  * :Gerr the Gₗ₋ₖ(η, x) error
  * :Gpval the Gₗ₋ₖ’(η, x) value
  * :Gperr the Gₗ₋ₖ’(η, x) error
  * :overflow Bool: if an overflow occurred, this is True, otherwise False
  * :expF if an overflow occurred, this is the scaling exponent for Fₗ(η, x)
  * :expG if an overflow occurred, this is the scaling exponent for Gₗ₋ₖ(η, x)
  
  ```
  my %res = coulomb-wave-FG-e(1, 5, 0, 0);
  say %res<Fval>;
  say %res<Fpval>;
  say %res<Gval>;
  say %res<Gpval>;
  
  ```
  
  ### sub coulomb-wave-F-array(Num(Cool) $lmin, UInt $kmax, Num(Cool) $eta, Num(Cool) $x where \* > 0 --> List) is export(:coulomb)
  
  This function computes the Coulomb wave function Fₗ(η, x) for l = lmin … lmin + kmax. It returns a List of Pairs (that can be read as a Hash):
  
  * :outF array of Fₗ(η, x) values
  * :overflow Bool: if an overflow occurred, this is True, otherwise False
  * :expF if an overflow occurred, this is the scaling exponent for Fₗ(η, x)
  
  ### sub coulomb-wave-FG-array(Num(Cool) $lmin, UInt $kmax, Num(Cool) $eta, Num(Cool) $x where \* > 0 --> List) is export(:coulomb)
  
  This function computes the functions Fₗ(η, x), Gₗ(η, x) for l = lmin … lmin + kmax. It returns a List of Pairs (that can be read as a Hash):
  
  * :outF array of Fₗ(η, x) values
  * :outG array of Gₗ(η, x) values
  * :overflow Bool: if an overflow occurred, this is True, otherwise False
  * :expF if an overflow occurred, this is the scaling exponent for Fₗ(η, x)
  * :expG if an overflow occurred, this is the scaling exponent for Gₗ₋ₖ(η, x)
  
  ### sub coulomb-wave-FGp-array(Num(Cool) $lmin, UInt $kmax, Num(Cool) $eta, Num(Cool) $x where \* > 0 --> List) is export(:coulomb)
  
  This function computes the functions Fₗ(η, x), Gₗ(η, x) and their derivatives F’ₗ(η, x), G’ₗ(η, x) for l = lmin … lmin + kmax It returns a List of Pairs (that can be read as a Hash):
  
  * :outF array of Fₗ(η, x) values
  * :outG array of Gₗ(η, x) values
  * :outFp array of Fₗ’(η, x) values
  * :outGp array of Gₗ’(η, x) values
  * :overflow Bool: if an overflow occurred, this is True, otherwise False
  * :expF if an overflow occurred, this is the scaling exponent for Fₗ(η, x)
  * :expG if an overflow occurred, this is the scaling exponent for Gₗ₋ₖ(η, x)
  
  ### sub coulomb-wave-sphF-array(Num(Cool) $lmin, UInt $kmax, Num(Cool) $eta, Num(Cool) $x where \* > 0 --> List) is export(:coulomb)
  
  This function computes the Coulomb wave function divided by the argument Fₗ(η, x)/x for l = lmin… lmin + kmax It returns a List of Pairs (that can be read as a Hash):
  
  * :outF array of Fₗ(η, x) values
  * :overflow Bool: if an overflow occurred, this is True, otherwise False
  * :expF if an overflow occurred, this is the scaling exponent for Fₗ(η, x)
  
  ### sub coulomb-CL-e(Num(Cool) $L where \* > -1, Num(Cool) $eta --> List) is export(:coulomb)
  
  This function computes the Coulomb wave function normalization constant Cₗ(η).
  
  ### sub coulomb-CL-array(Num(Cool) $lmin where \* > -1, UInt $kmax, Num(Cool) $eta --> List) is export(:coulomb)
  
  This function computes the Coulomb wave function normalization constant C L (η) for l = lmin … lmin + kmax.
  
  ### sub coupling3j(Int $two-ja, Int $two-jb, Int $two-jc, Int $two-ma, Int $two-mb, Int $two-mc --> Num) is export(:coupling)
  
  ### sub coupling3j-e(Int $two-ja, Int $two-jb, Int $two-jc, Int $two-ma, Int $two-mb, Int $two-mc --> List) is export(:coupling)
  
  These routines compute the Wigner 3-j coefficient. The arguments are given in half-integer units: two\_ja/2, two\_ma/2, etc.
  
  ### sub coupling6j(Int $two-ja, Int $two-jb, Int $two-jc, Int $two-jd, Int $two-je, Int $two-jf --> Num) is export(:coupling)
  
  ### sub coupling6j-e(Int $two-ja, Int $two-jb, Int $two-jc, Int $two-jd, Int $two-je, Int $two-jf --> List) is export(:coupling)
  
  These routines compute the Wigner 6-j coefficient. The arguments are given in half-integer units: two\_ja/2, two\_ma/2, etc.
  
  ### sub coupling9j(Int $two-ja, Int $two-jb, Int $two-jc, Int $two-jd, Int $two-je, Int $two-jf, Int $two-jg, Int $two-jh, Int $two-ji --> Num) is export(:coupling)
  
  ### sub coupling9j-e(Int $two-ja, Int $two-jb, Int $two-jc, Int $two-jd, Int $two-je, Int $two-jf, Int $two-jg, Int $two-jh, Int $two-ji --> List) is export(:coupling)
  
  These routines compute the Wigner 9-j coefficient. The arguments are given in half-integer units: two\_ja/2, two\_ma/2, etc.
  
  ### sub dawson(Num(Cool) $x --> Num) is export(:dawson)
  
  ### sub dawson-e(Num(Cool) $x --> List) is export(:dawson)
  
  These routines compute the value of Dawson’s integral for x.
  
  ### sub debye1(Num(Cool) $x --> Num) is export(:debye)
  
  ### sub debye1-e(Num(Cool) $x --> List) is export(:debye)
  
  These routines compute the first-order Debye function D₁(x).
  
  ### sub debye2(Num(Cool) $x --> Num) is export(:debye)
  
  ### sub debye2-e(Num(Cool) $x --> List) is export(:debye)
  
  These routines compute the first-order Debye function D₂(x).
  
  ### sub debye3(Num(Cool) $x --> Num) is export(:debye)
  
  ### sub debye3-e(Num(Cool) $x --> List) is export(:debye)
  
  These routines compute the first-order Debye function D₃(x).
  
  ### sub debye4(Num(Cool) $x --> Num) is export(:debye)
  
  ### sub debye4-e(Num(Cool) $x --> List) is export(:debye)
  
  These routines compute the first-order Debye function D₄(x).
  
  ### sub debye5(Num(Cool) $x --> Num) is export(:debye)
  
  ### sub debye5-e(Num(Cool) $x --> List) is export(:debye)
  
  These routines compute the first-order Debye function D₅(x).
  
  ### sub debye6(Num(Cool) $x --> Num) is export(:debye)
  
  ### sub debye6-e(Num(Cool) $x --> List) is export(:debye)
  
  These routines compute the first-order Debye function D₆(x).
  
  ### sub dilog(Num(Cool) $x --> Num) is export(:dilog)
  
  ### sub dilog-e(Num(Cool) $x --> List) is export(:dilog)
  
  These routines compute the dilogarithm for a real argument.
  
  ### sub complex-dilog-xy-e(Num(Cool) $x, Num(Cool) $y --> List) is export(:dilog)
  
  ### sub complex-dilog-e(Num(Cool) $r, Num(Cool) $θ --> List) is export(:dilog)
  
  This function computes the full complex-valued dilogarithm for the complex argument z = r exp(iθ).
  
  ### sub complex-spence-xy-e(Num(Cool) $x, Num(Cool) $y --> List) is export(:dilog)
  
  This function computes the full complex-valued Spence integral. It returns a List: the first element is the value as a Raku’s Complex datatype, the following are the errors on the real and imaginary part.
  
  ### sub multiply(Num(Cool) $x, Num(Cool) $y --> Num) is export(:mult)
  
  ### sub multiply-e(Num(Cool) $x, Num(Cool) $y --> List) is export(:mult)
  
  These functions multiply x and y, allowing for the propagation of errors.
  
  ### sub multiply-err-e(Num(Cool) $x, Num(Cool) $dx, Num(Cool) $y, Num(Cool) $dy --> List) is export(:mult)
  
  This function multiplies x and y with associated absolute errors dx and dy.
  
  ### sub Kcomp(Num(Cool) $k, UInt $mode --> Num) is export(:ellint)
  
  ### sub Kcomp-e(Num(Cool) $k, UInt $mode --> List) is export(:ellint)
  
  These routines compute the complete elliptic integral K(k) to the accuracy specified by the mode variable mode.
  
  ### sub Ecomp(Num(Cool) $k, UInt $mode --> Num) is export(:ellint)
  
  ### sub Ecomp-e(Num(Cool) $k, UInt $mode --> List) is export(:ellint)
  
  These routines compute the complete elliptic integral E(k) to the accuracy specified by the mode variable mode.
  
  ### sub Pcomp(Num(Cool) $k, Num(Cool) $n, UInt $mode --> Num) is export(:ellint)
  
  ### sub Pcomp-e(Num(Cool) $k, Num(Cool) $n, UInt $mode --> List) is export(:ellint)
  
  These routines compute the complete elliptic integral Π(k,n) to the accuracy specified by the mode variable mode.
  
  ### sub Dcomp(Num(Cool) $k, UInt $mode --> Num) is export(:ellint)
  
  ### sub Dcomp-e(Num(Cool) $k, UInt $mode --> List) is export(:ellint)
  
  These routines compute the complete elliptic integral D(k) to the accuracy specified by the mode variable mode.
  
  ### sub F(Num(Cool) $Φ, Num(Cool) $k, UInt $mode --> Num) is export(:ellint)
  
  ### sub F-e(Num(Cool) $Φ, Num(Cool) $k, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral F(φ, k) to the accuracy specified by the mode variable mode.
  
  ### sub E(Num(Cool) $Φ, Num(Cool) $k, UInt $mode --> Num) is export(:ellint)
  
  ### sub E-e(Num(Cool) $Φ, Num(Cool) $k, UInt $mode --> List) is export(:ellint)
  
  These routines compute the incomplete elliptic integral E(φ, k) to the accuracy specified by the mode variable mode.
  
  ### sub P(Num(Cool) $Φ, Num(Cool) $k, Num(Cool) $n, UInt $mode --> Num) is export(:ellint)
  
  ### sub P-e(Num(Cool) $Φ, Num(Cool) $k, Num(Cool) $n, UInt $mode --> List