[sf.cmath] - C++17 → C++20

Files changed (1) hide show

tmp/tmp3nw_lvln/{from.md → to.md} +79 -376

tmp/tmp3nw_lvln/{from.md → to.md} RENAMED Viewed

@@ -8,54 +8,48 @@ a domain error for just those argument values for which:
 - the function description’s *Returns:* clause explicitly specifies a
   domain and those argument values fall outside the specified domain, or
 - the corresponding mathematical function value has a nonzero imaginary
   component, or
 - the corresponding mathematical function is not mathematically
-  defined.[^18]
 Unless otherwise specified, each function is defined for all finite
 values, for negative infinity, and for positive infinity.
-#### Associated Laguerre polynomials <a id="sf.cmath.assoc_laguerre">[[sf.cmath.assoc_laguerre]]</a>
 ``` cpp
 double       assoc_laguerre(unsigned n, unsigned m, double x);
 float        assoc_laguerref(unsigned n, unsigned m, float x);
 long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Laguerre polynomials
 of their respective arguments `n`, `m`, and `x`.
-*Returns:* $$%
- \mathsf{L}_n^m(x) =
-  (-1)^m \frac{\mathsf{d} ^ m}
-       {\mathsf{d}x ^ m} \, \mathsf{L}_{n+m}(x),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128` or if `m >= 128`.
-#### Associated Legendre functions <a id="sf.cmath.assoc_legendre">[[sf.cmath.assoc_legendre]]</a>
 ``` cpp
 double       assoc_legendre(unsigned l, unsigned m, double x);
 float        assoc_legendref(unsigned l, unsigned m, float x);
 long double  assoc_legendrel(unsigned l, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Legendre functions of
 their respective arguments `l`, `m`, and `x`.
-*Returns:* $$%
- \mathsf{P}_\ell^m(x) =
-  (1 - x^2) ^ {m/2}
-  \:
-  \frac{ \mathsf{d} ^ m}
-       { \mathsf{d}x ^ m} \, \mathsf{P}_\ell(x),
-       \quad \mbox{for $|x| \le 1$}$$ where l is `l`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
@@ -68,115 +62,105 @@ long double  betal(long double x, long double y);
 ```
 *Effects:* These functions compute the beta function of their respective
 arguments `x` and `y`.
-*Returns:* $$%
- \mathsf{B}(x, y) =
- \frac{ \Gamma(x) \, \Gamma(y) }
-       { \Gamma(x+y) },
-       \quad \mbox{for $x > 0$,\, $y > 0$}$$ where x is `x` and y is
-`y`.
-#### Complete elliptic integral of the first kind <a id="sf.cmath.comp_ellint_1">[[sf.cmath.comp_ellint_1]]</a>
 ``` cpp
 double       comp_ellint_1(double k);
 float        comp_ellint_1f(float k);
 long double  comp_ellint_1l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 first kind of their respective arguments `k`.
-*Returns:* $$%
- \mathsf{K}(k) =
-  \mathsf{F}(k, \pi / 2),
-              \quad \mbox{for $|k| \le 1$}$$ where k is `k`.
-See also [[sf.cmath.ellint_1]].
-#### Complete elliptic integral of the second kind <a id="sf.cmath.comp_ellint_2">[[sf.cmath.comp_ellint_2]]</a>
 ``` cpp
 double       comp_ellint_2(double k);
 float        comp_ellint_2f(float k);
 long double  comp_ellint_2l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 second kind of their respective arguments `k`.
-*Returns:* $$%
- \mathsf{E}(k) =
-  \mathsf{E}(k, \pi / 2),
-\quad \mbox{for $|k| \le 1$}$$ where k is `k`.
-See also [[sf.cmath.ellint_2]].
-#### Complete elliptic integral of the third kind <a id="sf.cmath.comp_ellint_3">[[sf.cmath.comp_ellint_3]]</a>
 ``` cpp
 double       comp_ellint_3(double k, double nu);
 float        comp_ellint_3f(float k, float nu);
 long double  comp_ellint_3l(long double k, long double nu);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 third kind of their respective arguments `k` and `nu`.
-*Returns:* $$%
- \mathsf{\Pi}(\nu, k) = \mathsf{\Pi}(\nu, k, \pi / 2),
-        \quad \mbox{for $|k| \le 1$}$$ where k is `k` and $\nu$ is `nu`.
-See also [[sf.cmath.ellint_3]].
-#### Regular modified cylindrical Bessel functions <a id="sf.cmath.cyl_bessel_i">[[sf.cmath.cyl_bessel_i]]</a>
 ``` cpp
 double       cyl_bessel_i(double nu, double x);
 float        cyl_bessel_if(float nu, float x);
 long double  cyl_bessel_il(long double nu, long double x);
 ```
 *Effects:* These functions compute the regular modified cylindrical
 Bessel functions of their respective arguments `nu` and `x`.
-*Returns:* $$%
- \mathsf{I}_\nu(x) =
-  i^{-\nu} \mathsf{J}_\nu(ix)
-  =
-  \sum_{k=0}^\infty \frac{(x/2)^{\nu+2k}}
-             {k! \: \Gamma(\nu+k+1)},
-       \quad \mbox{for $x \ge 0$}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-See also [[sf.cmath.cyl_bessel_j]].
-#### Cylindrical Bessel functions of the first kind <a id="sf.cmath.cyl_bessel_j">[[sf.cmath.cyl_bessel_j]]</a>
 ``` cpp
 double       cyl_bessel_j(double nu, double x);
 float        cyl_bessel_jf(float nu, float x);
 long double  cyl_bessel_jl(long double nu, long double x);
 ```
 *Effects:* These functions compute the cylindrical Bessel functions of
 the first kind of their respective arguments `nu` and `x`.
-*Returns:* $$%
- \mathsf{J}_\nu(x) =
- \sum_{k=0}^\infty \frac{(-1)^k (x/2)^{\nu+2k}}
-             {k! \: \Gamma(\nu+k+1)},
-       \quad \mbox{for $x \ge 0$}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-#### Irregular modified cylindrical Bessel functions <a id="sf.cmath.cyl_bessel_k">[[sf.cmath.cyl_bessel_k]]</a>
 ``` cpp
 double       cyl_bessel_k(double nu, double x);
 float        cyl_bessel_kf(float nu, float x);
 long double  cyl_bessel_kl(long double nu, long double x);
@@ -209,14 +193,14 @@ Bessel functions of their respective arguments `nu` and `x`.
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-See also [[sf.cmath.cyl_bessel_i]], [[sf.cmath.cyl_bessel_j]],
-[[sf.cmath.cyl_neumann]].
-#### Cylindrical Neumann functions <a id="sf.cmath.cyl_neumann">[[sf.cmath.cyl_neumann]]</a>
 ``` cpp
 double       cyl_neumann(double nu, double x);
 float        cyl_neumannf(float nu, float x);
 long double  cyl_neumannl(long double nu, long double x);
@@ -244,13 +228,13 @@ their respective arguments `nu` and `x`.
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-See also [[sf.cmath.cyl_bessel_j]].
-#### Incomplete elliptic integral of the first kind <a id="sf.cmath.ellint_1">[[sf.cmath.ellint_1]]</a>
 ``` cpp
 double       ellint_1(double k, double phi);
 float        ellint_1f(float k, float phi);
 long double  ellint_1l(long double k, long double phi);
@@ -258,17 +242,15 @@ long double  ellint_1l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the first kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
-*Returns:* $$%
- \mathsf{F}(k, \phi) =
- \int_0^\phi \! \frac{\mathsf{d}\theta}
-                      {\sqrt{1 - k^2 \sin^2 \theta}},
-       \quad \mbox{for $|k| \le 1$}$$ where k is `k` and φ is `phi`.
-#### Incomplete elliptic integral of the second kind <a id="sf.cmath.ellint_2">[[sf.cmath.ellint_2]]</a>
 ``` cpp
 double       ellint_2(double k, double phi);
 float        ellint_2f(float k, float phi);
 long double  ellint_2l(long double k, long double phi);
@@ -276,16 +258,15 @@ long double  ellint_2l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the second kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
-*Returns:* $$%
- \mathsf{E}(k, \phi) =
- \int_0^\phi \! \sqrt{1 - k^2 \sin^2 \theta} \, \mathsf{d}\theta,
-       \quad \mbox{for $|k| \le 1$}$$ where k is `k` and φ is `phi`.
-#### Incomplete elliptic integral of the third kind <a id="sf.cmath.ellint_3">[[sf.cmath.ellint_3]]</a>
 ``` cpp
 double       ellint_3(double k, double nu, double phi);
 float        ellint_3f(float k, float nu, float phi);
 long double  ellint_3l(long double k, long double nu, long double phi);
@@ -293,16 +274,13 @@ long double  ellint_3l(long double k, long double nu, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the third kind of their respective arguments `k`, `nu`, and `phi` (`phi`
 measured in radians).
-*Returns:* $$%
- \mathsf{\Pi}(\nu, k, \phi) =
-  \int_0^\phi \! \frac{ \mathsf{d}\theta }
-                      { (1 - \nu \, \sin^2 \theta) \sqrt{1 - k^2 \sin^2 \theta} },
-       \quad \mbox{for $|k| \le 1$}$$ where $\nu$ is `nu`, k is `k`, and
-φ is `phi`.
 #### Exponential integral <a id="sf.cmath.expint">[[sf.cmath.expint]]</a>
 ``` cpp
 double       expint(double x);
@@ -348,15 +326,13 @@ long double  laguerrel(unsigned n, long double x);
 ```
 *Effects:* These functions compute the Laguerre polynomials of their
 respective arguments `n` and `x`.
-*Returns:* $$%
- \mathsf{L}_n(x) =
- \frac{e^x}{n!} \frac{ \mathsf{d} ^ n}
-            { \mathsf{d}x ^ n} \, (x^n e^{-x}),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
 #### Legendre polynomials <a id="sf.cmath.legendre">[[sf.cmath.legendre]]</a>
@@ -368,22 +344,19 @@ long double  legendrel(unsigned l, long double x);
 ```
 *Effects:* These functions compute the Legendre polynomials of their
 respective arguments `l` and `x`.
-*Returns:* $$%
- \mathsf{P}_\ell(x) =
- \frac{1}
-       {2^\ell \, \ell!}
-  \frac{ \mathsf{d} ^ \ell}
-       { \mathsf{d}x ^ \ell} \, (x^2 - 1) ^ \ell,
-       \quad \mbox{for $|x| \le 1$}$$ where l is `l` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
-#### Riemann zeta function <a id="sf.cmath.riemann_zeta">[[sf.cmath.riemann_zeta]]</a>
 ``` cpp
 double       riemann_zeta(double x);
 float        riemann_zetaf(float x);
 long double  riemann_zetal(long double x);
@@ -413,32 +386,31 @@ respective arguments `x`.
   & \mbox{for $x < 0$}
   \end{array}
   \right.
 \;$$ where x is `x`.
-#### Spherical Bessel functions of the first kind <a id="sf.cmath.sph_bessel">[[sf.cmath.sph_bessel]]</a>
 ``` cpp
 double       sph_bessel(unsigned n, double x);
 float        sph_besself(unsigned n, float x);
 long double  sph_bessell(unsigned n, long double x);
 ```
 *Effects:* These functions compute the spherical Bessel functions of the
 first kind of their respective arguments `n` and `x`.
-*Returns:* $$%
- \mathsf{j}_n(x) =
-  (\pi/2x)^{1\!/\!2} \mathsf{J}_{n + 1\!/\!2}(x),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
-See also [[sf.cmath.cyl_bessel_j]].
-#### Spherical associated Legendre functions <a id="sf.cmath.sph_legendre">[[sf.cmath.sph_legendre]]</a>
 ``` cpp
 double       sph_legendre(unsigned l, unsigned m, double theta);
 float        sph_legendref(unsigned l, unsigned m, float theta);
 long double  sph_legendrel(unsigned l, unsigned m, long double theta);
@@ -446,30 +418,23 @@ long double  sph_legendrel(unsigned l, unsigned m, long double theta);
 *Effects:* These functions compute the spherical associated Legendre
 functions of their respective arguments `l`, `m`, and `theta` (`theta`
 measured in radians).
-*Returns:* $$%
- \mathsf{Y}_\ell^m(\theta, 0)
-\;$$ where $$%
- \mathsf{Y}_\ell^m(\theta, \phi) =
-  (-1)^m \left[ \frac{(2 \ell + 1)}
-                     {4 \pi}
-            \frac{(\ell - m)!}
-                 {(\ell + m)!}
-         \right]^{1/2}
-     \mathsf{P}_\ell^m
-     ( \cos\theta ) e ^ {i m \phi},
-       \quad \mbox{for $|m| \le \ell$}$$ and l is `l`, m is `m`, and θ
 is `theta`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
-See also [[sf.cmath.assoc_legendre]].
-#### Spherical Neumann functions <a id="sf.cmath.sph_neumann">[[sf.cmath.sph_neumann]]</a>
 ``` cpp
 double       sph_neumann(unsigned n, double x);
 float        sph_neumannf(unsigned n, float x);
 long double  sph_neumannl(unsigned n, long double x);
@@ -477,276 +442,14 @@ long double  sph_neumannl(unsigned n, long double x);
 *Effects:* These functions compute the spherical Neumann functions, also
 known as the spherical Bessel functions of the second kind, of their
 respective arguments `n` and `x`.
-*Returns:* $$%
- \mathsf{n}_n(x) =
-  (\pi/2x)^{1\!/\!2} \mathsf{N}_{n + 1\!/\!2}(x),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
-See also [[sf.cmath.cyl_neumann]].
-<!-- Link reference definitions -->
-[accumulate]: #accumulate
-[adjacent.difference]: #adjacent.difference
-[algorithms]: algorithms.md#algorithms
-[bad.alloc]: language.md#bad.alloc
-[basic.fundamental]: basic.md#basic.fundamental
-[basic.stc.thread]: basic.md#basic.stc.thread
-[basic.types]: basic.md#basic.types
-[c.math]: #c.math
-[c.math.abs]: #c.math.abs
-[c.math.fpclass]: #c.math.fpclass
-[c.math.hypot3]: #c.math.hypot3
-[c.math.rand]: #c.math.rand
-[cfenv]: #cfenv
-[cfenv.syn]: #cfenv.syn
-[class.gslice]: #class.gslice
-[class.gslice.overview]: #class.gslice.overview
-[class.slice]: #class.slice
-[class.slice.overview]: #class.slice.overview
-[cmath.syn]: #cmath.syn
-[cmplx.over]: #cmplx.over
-[complex]: #complex
-[complex.literals]: #complex.literals
-[complex.member.ops]: #complex.member.ops
-[complex.members]: #complex.members
-[complex.numbers]: #complex.numbers
-[complex.ops]: #complex.ops
-[complex.special]: #complex.special
-[complex.syn]: #complex.syn
-[complex.transcendentals]: #complex.transcendentals
-[complex.value.ops]: #complex.value.ops
-[cons.slice]: #cons.slice
-[conv.prom]: conv.md#conv.prom
-[cpp.pragma]: cpp.md#cpp.pragma
-[cstdlib.syn]: language.md#cstdlib.syn
-[dcl.array]: dcl.md#dcl.array
-[dcl.init]: dcl.md#dcl.init
-[exclusive.scan]: #exclusive.scan
-[function.objects]: utilities.md#function.objects
-[gslice.access]: #gslice.access
-[gslice.array.assign]: #gslice.array.assign
-[gslice.array.comp.assign]: #gslice.array.comp.assign
-[gslice.array.fill]: #gslice.array.fill
-[gslice.cons]: #gslice.cons
-[implimits]: limits.md#implimits
-[inclusive.scan]: #inclusive.scan
-[indirect.array.assign]: #indirect.array.assign
-[indirect.array.comp.assign]: #indirect.array.comp.assign
-[indirect.array.fill]: #indirect.array.fill
-[inner.product]: #inner.product
-[input.iterators]: iterators.md#input.iterators
-[input.output]: input.md#input.output
-[iostate.flags]: input.md#iostate.flags
-[istream.formatted]: input.md#istream.formatted
-[iterator.requirements.general]: iterators.md#iterator.requirements.general
-[library.c]: library.md#library.c
-[mask.array.assign]: #mask.array.assign
-[mask.array.comp.assign]: #mask.array.comp.assign
-[mask.array.fill]: #mask.array.fill
-[numarray]: #numarray
-[numeric.iota]: #numeric.iota
-[numeric.ops]: #numeric.ops
-[numeric.ops.gcd]: #numeric.ops.gcd
-[numeric.ops.lcm]: #numeric.ops.lcm
-[numeric.ops.overview]: #numeric.ops.overview
-[numeric.requirements]: #numeric.requirements
-[numerics]: #numerics
-[numerics.defns]: #numerics.defns
-[numerics.general]: #numerics.general
-[output.iterators]: iterators.md#output.iterators
-[partial.sum]: #partial.sum
-[rand]: #rand
-[rand.adapt]: #rand.adapt
-[rand.adapt.disc]: #rand.adapt.disc
-[rand.adapt.general]: #rand.adapt.general
-[rand.adapt.ibits]: #rand.adapt.ibits
-[rand.adapt.shuf]: #rand.adapt.shuf
-[rand.device]: #rand.device
-[rand.dist]: #rand.dist
-[rand.dist.bern]: #rand.dist.bern
-[rand.dist.bern.bernoulli]: #rand.dist.bern.bernoulli
-[rand.dist.bern.bin]: #rand.dist.bern.bin
-[rand.dist.bern.geo]: #rand.dist.bern.geo
-[rand.dist.bern.negbin]: #rand.dist.bern.negbin
-[rand.dist.general]: #rand.dist.general
-[rand.dist.norm]: #rand.dist.norm
-[rand.dist.norm.cauchy]: #rand.dist.norm.cauchy
-[rand.dist.norm.chisq]: #rand.dist.norm.chisq
-[rand.dist.norm.f]: #rand.dist.norm.f
-[rand.dist.norm.lognormal]: #rand.dist.norm.lognormal
-[rand.dist.norm.normal]: #rand.dist.norm.normal
-[rand.dist.norm.t]: #rand.dist.norm.t
-[rand.dist.pois]: #rand.dist.pois
-[rand.dist.pois.exp]: #rand.dist.pois.exp
-[rand.dist.pois.extreme]: #rand.dist.pois.extreme
-[rand.dist.pois.gamma]: #rand.dist.pois.gamma
-[rand.dist.pois.poisson]: #rand.dist.pois.poisson
-[rand.dist.pois.weibull]: #rand.dist.pois.weibull
-[rand.dist.samp]: #rand.dist.samp
-[rand.dist.samp.discrete]: #rand.dist.samp.discrete
-[rand.dist.samp.pconst]: #rand.dist.samp.pconst
-[rand.dist.samp.plinear]: #rand.dist.samp.plinear
-[rand.dist.uni]: #rand.dist.uni
-[rand.dist.uni.int]: #rand.dist.uni.int
-[rand.dist.uni.real]: #rand.dist.uni.real
-[rand.eng]: #rand.eng
-[rand.eng.lcong]: #rand.eng.lcong
-[rand.eng.mers]: #rand.eng.mers
-[rand.eng.sub]: #rand.eng.sub
-[rand.predef]: #rand.predef
-[rand.req]: #rand.req
-[rand.req.adapt]: #rand.req.adapt
-[rand.req.dist]: #rand.req.dist
-[rand.req.eng]: #rand.req.eng
-[rand.req.genl]: #rand.req.genl
-[rand.req.seedseq]: #rand.req.seedseq
-[rand.req.urng]: #rand.req.urng
-[rand.synopsis]: #rand.synopsis
-[rand.util]: #rand.util
-[rand.util.canonical]: #rand.util.canonical
-[rand.util.seedseq]: #rand.util.seedseq
-[random.access.iterators]: iterators.md#random.access.iterators
-[reduce]: #reduce
-[res.on.data.races]: library.md#res.on.data.races
-[sf.cmath]: #sf.cmath
-[sf.cmath.assoc_laguerre]: #sf.cmath.assoc_laguerre
-[sf.cmath.assoc_legendre]: #sf.cmath.assoc_legendre
-[sf.cmath.beta]: #sf.cmath.beta
-[sf.cmath.comp_ellint_1]: #sf.cmath.comp_ellint_1
-[sf.cmath.comp_ellint_2]: #sf.cmath.comp_ellint_2
-[sf.cmath.comp_ellint_3]: #sf.cmath.comp_ellint_3
-[sf.cmath.cyl_bessel_i]: #sf.cmath.cyl_bessel_i
-[sf.cmath.cyl_bessel_j]: #sf.cmath.cyl_bessel_j
-[sf.cmath.cyl_bessel_k]: #sf.cmath.cyl_bessel_k
-[sf.cmath.cyl_neumann]: #sf.cmath.cyl_neumann
-[sf.cmath.ellint_1]: #sf.cmath.ellint_1
-[sf.cmath.ellint_2]: #sf.cmath.ellint_2
-[sf.cmath.ellint_3]: #sf.cmath.ellint_3
-[sf.cmath.expint]: #sf.cmath.expint
-[sf.cmath.hermite]: #sf.cmath.hermite
-[sf.cmath.laguerre]: #sf.cmath.laguerre
-[sf.cmath.legendre]: #sf.cmath.legendre
-[sf.cmath.riemann_zeta]: #sf.cmath.riemann_zeta
-[sf.cmath.sph_bessel]: #sf.cmath.sph_bessel
-[sf.cmath.sph_legendre]: #sf.cmath.sph_legendre
-[sf.cmath.sph_neumann]: #sf.cmath.sph_neumann
-[slice.access]: #slice.access
-[slice.arr.assign]: #slice.arr.assign
-[slice.arr.comp.assign]: #slice.arr.comp.assign
-[slice.arr.fill]: #slice.arr.fill
-[strings]: strings.md#strings
-[tab:RandomDistribution]: #tab:RandomDistribution
-[tab:RandomEngine]: #tab:RandomEngine
-[tab:SeedSequence]: #tab:SeedSequence
-[tab:UniformRandomBitGenerator]: #tab:UniformRandomBitGenerator
-[tab:copyassignable]: #tab:copyassignable
-[tab:copyconstructible]: #tab:copyconstructible
-[tab:equalitycomparable]: #tab:equalitycomparable
-[tab:iterator.input.requirements]: iterators.md#tab:iterator.input.requirements
-[tab:moveassignable]: #tab:moveassignable
-[tab:moveconstructible]: #tab:moveconstructible
-[tab:numerics.lib.summary]: #tab:numerics.lib.summary
-[template.gslice.array]: #template.gslice.array
-[template.gslice.array.overview]: #template.gslice.array.overview
-[template.indirect.array]: #template.indirect.array
-[template.indirect.array.overview]: #template.indirect.array.overview
-[template.mask.array]: #template.mask.array
-[template.mask.array.overview]: #template.mask.array.overview
-[template.slice.array]: #template.slice.array
-[template.slice.array.overview]: #template.slice.array.overview
-[template.valarray]: #template.valarray
-[template.valarray.overview]: #template.valarray.overview
-[thread.thread.class]: thread.md#thread.thread.class
-[transform.exclusive.scan]: #transform.exclusive.scan
-[transform.inclusive.scan]: #transform.inclusive.scan
-[transform.reduce]: #transform.reduce
-[valarray.access]: #valarray.access
-[valarray.assign]: #valarray.assign
-[valarray.binary]: #valarray.binary
-[valarray.cassign]: #valarray.cassign
-[valarray.comparison]: #valarray.comparison
-[valarray.cons]: #valarray.cons
-[valarray.members]: #valarray.members
-[valarray.nonmembers]: #valarray.nonmembers
-[valarray.range]: #valarray.range
-[valarray.special]: #valarray.special
-[valarray.sub]: #valarray.sub
-[valarray.syn]: #valarray.syn
-[valarray.transcend]: #valarray.transcend
-[valarray.unary]: #valarray.unary
-[vector]: containers.md#vector
-[^1]: In other words, value types. These include arithmetic types,
-    pointers, the library class `complex`, and instantiations of
-    `valarray` for value types.
-[^2]: The name of this engine refers, in part, to a property of its
-    period: For properly-selected values of the parameters, the period
-    is closely related to a large Mersenne prime number.
-[^3]: The parameter is intended to allow an implementation to
-    differentiate between different sources of randomness.
-[^4]: If a device has n states whose respective probabilities are
-    P₀, …, Pₙ₋₁, the device entropy S is defined as
-    $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
-[^5]: b is introduced to avoid any attempt to produce more bits of
-    randomness than can be held in `RealType`.
-[^6]: The distribution corresponding to this probability density
-    function is also known (with a possible change of variable) as the
-    Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
-    distribution.
-[^7]: Annex  [[implimits]] recommends a minimum number of recursively
-    nested template instantiations. This requirement thus indirectly
-    suggests a minimum allowable complexity for valarray expressions.
-[^8]: The intent is to specify an array template that has the minimum
-    functionality necessary to address aliasing ambiguities and the
-    proliferation of temporaries. Thus, the `valarray` template is
-    neither a matrix class nor a field class. However, it is a very
-    useful building block for designing such classes.
-[^9]: This default constructor is essential, since arrays of `valarray`
-    may be useful. After initialization, the length of an empty array
-    can be increased with the `resize` member function.
-[^10]: This constructor is the preferred method for converting a C array
-    to a `valarray` object.
-[^11]: This copy constructor creates a distinct array rather than an
-    alias. Implementations in which arrays share storage are permitted,
-    but they shall implement a copy-on-reference mechanism to ensure
-    that arrays are conceptually distinct.
-[^12]: BLAS stands for *Basic Linear Algebra Subprograms.* C++programs
-    may instantiate this class. See, for example, Dongarra, Du Croz,
-    Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
-    Subprograms*; Technical Report MCS-P1-0888, Argonne National
-    Laboratory (USA), Mathematics and Computer Science Division, August,
-    1988.
-[^13]: The use of fully closed ranges is intentional.
-[^14]: `accumulate` is similar to the APL reduction operator and Common
-    Lisp reduce function, but it avoids the difficulty of defining the
-    result of reduction on an empty sequence by always requiring an
-    initial value.
-[^15]: The use of fully closed ranges is intentional.
-[^16]: The use of fully closed ranges is intentional.
-[^17]: The use of fully closed ranges is intentional.
-[^18]: A mathematical function is mathematically defined for a given set
-    of argument values (a) if it is explicitly defined for that set of
-    argument values, or (b) if its limiting value exists and does not
-    depend on the direction of approach.

 - the function description’s *Returns:* clause explicitly specifies a
   domain and those argument values fall outside the specified domain, or
 - the corresponding mathematical function value has a nonzero imaginary
   component, or
 - the corresponding mathematical function is not mathematically
+  defined.[^13]
 Unless otherwise specified, each function is defined for all finite
 values, for negative infinity, and for positive infinity.
+#### Associated Laguerre polynomials <a id="sf.cmath.assoc.laguerre">[[sf.cmath.assoc.laguerre]]</a>
 ``` cpp
 double       assoc_laguerre(unsigned n, unsigned m, double x);
 float        assoc_laguerref(unsigned n, unsigned m, float x);
 long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Laguerre polynomials
 of their respective arguments `n`, `m`, and `x`.
+*Returns:* $$\mathsf{L}_n^m(x) =
+   (-1)^m \frac{\mathsf{d} ^ m}{\mathsf{d}x ^ m} \, \mathsf{L}_{n+m}(x)
+ \text{ ,\quad for $x \ge 0$,}$$ where n is `n`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128` or if `m >= 128`.
+#### Associated Legendre functions <a id="sf.cmath.assoc.legendre">[[sf.cmath.assoc.legendre]]</a>
 ``` cpp
 double       assoc_legendre(unsigned l, unsigned m, double x);
 float        assoc_legendref(unsigned l, unsigned m, float x);
 long double  assoc_legendrel(unsigned l, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Legendre functions of
 their respective arguments `l`, `m`, and `x`.
+*Returns:* $$\mathsf{P}_\ell^m(x) = (1 - x^2) ^ {m/2} \:
+ \frac{\mathsf{d} ^ m}{\mathsf{d}x ^ m} \, \mathsf{P}_\ell(x)
+   \text{ ,\quad for $|x| \le 1$,}$$ where l is `l`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
 ```
 *Effects:* These functions compute the beta function of their respective
 arguments `x` and `y`.
+*Returns:*
+$$\mathsf{B}(x, y) = \frac{\Gamma(x) \, \Gamma(y)}{\Gamma(x + y)}
+ \text{ ,\quad for $x > 0$,\, $y > 0$,}$$ where x is `x` and y is `y`.
+#### Complete elliptic integral of the first kind <a id="sf.cmath.comp.ellint.1">[[sf.cmath.comp.ellint.1]]</a>
 ``` cpp
 double       comp_ellint_1(double k);
 float        comp_ellint_1f(float k);
 long double  comp_ellint_1l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 first kind of their respective arguments `k`.
+*Returns:*
+$$\mathsf{K}(k) = \mathsf{F}(k, \pi / 2) \text{ ,\quad for $|k| \le 1$,}$$
+where k is `k`.
+See also [[sf.cmath.ellint.1]].
+#### Complete elliptic integral of the second kind <a id="sf.cmath.comp.ellint.2">[[sf.cmath.comp.ellint.2]]</a>
 ``` cpp
 double       comp_ellint_2(double k);
 float        comp_ellint_2f(float k);
 long double  comp_ellint_2l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 second kind of their respective arguments `k`.
+*Returns:*
+$$\mathsf{E}(k) = \mathsf{E}(k, \pi / 2) \text{ ,\quad for $|k| \le 1$,}$$
+where k is `k`.
+See also [[sf.cmath.ellint.2]].
+#### Complete elliptic integral of the third kind <a id="sf.cmath.comp.ellint.3">[[sf.cmath.comp.ellint.3]]</a>
 ``` cpp
 double       comp_ellint_3(double k, double nu);
 float        comp_ellint_3f(float k, float nu);
 long double  comp_ellint_3l(long double k, long double nu);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 third kind of their respective arguments `k` and `nu`.
+*Returns:*
+$$\mathsf{\Pi}(\nu, k) = \mathsf{\Pi}(\nu, k, \pi / 2) \text{ ,\quad for $|k| \le 1$,}$$
+where k is `k` and $\nu$ is `nu`.
+See also [[sf.cmath.ellint.3]].
+#### Regular modified cylindrical Bessel functions <a id="sf.cmath.cyl.bessel.i">[[sf.cmath.cyl.bessel.i]]</a>
 ``` cpp
 double       cyl_bessel_i(double nu, double x);
 float        cyl_bessel_if(float nu, float x);
 long double  cyl_bessel_il(long double nu, long double x);
 ```
 *Effects:* These functions compute the regular modified cylindrical
 Bessel functions of their respective arguments `nu` and `x`.
+*Returns:* $$\mathsf{I}_\nu(x) =
+     i^{-\nu} \mathsf{J}_\nu(ix) =
+     \sum_{k=0}^\infty \frac{(x/2)^{\nu+2k}}{k! \: \Gamma(\nu+k+1)}
+     \text{ ,\quad for $x \ge 0$,}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+See also [[sf.cmath.cyl.bessel.j]].
+#### Cylindrical Bessel functions of the first kind <a id="sf.cmath.cyl.bessel.j">[[sf.cmath.cyl.bessel.j]]</a>
 ``` cpp
 double       cyl_bessel_j(double nu, double x);
 float        cyl_bessel_jf(float nu, float x);
 long double  cyl_bessel_jl(long double nu, long double x);
 ```
 *Effects:* These functions compute the cylindrical Bessel functions of
 the first kind of their respective arguments `nu` and `x`.
+*Returns:* $$\mathsf{J}_\nu(x) =
+ \sum_{k=0}^\infty \frac{(-1)^k (x/2)^{\nu+2k}}{k! \: \Gamma(\nu+k+1)}
+ \text{ ,\quad for $x \ge 0$,}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+#### Irregular modified cylindrical Bessel functions <a id="sf.cmath.cyl.bessel.k">[[sf.cmath.cyl.bessel.k]]</a>
 ``` cpp
 double       cyl_bessel_k(double nu, double x);
 float        cyl_bessel_kf(float nu, float x);
 long double  cyl_bessel_kl(long double nu, long double x);
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+See also [[sf.cmath.cyl.bessel.i]], [[sf.cmath.cyl.bessel.j]],
+[[sf.cmath.cyl.neumann]].
+#### Cylindrical Neumann functions <a id="sf.cmath.cyl.neumann">[[sf.cmath.cyl.neumann]]</a>
 ``` cpp
 double       cyl_neumann(double nu, double x);
 float        cyl_neumannf(float nu, float x);
 long double  cyl_neumannl(long double nu, long double x);
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+See also [[sf.cmath.cyl.bessel.j]].
+#### Incomplete elliptic integral of the first kind <a id="sf.cmath.ellint.1">[[sf.cmath.ellint.1]]</a>
 ``` cpp
 double       ellint_1(double k, double phi);
 float        ellint_1f(float k, float phi);
 long double  ellint_1l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the first kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
+*Returns:* $$\mathsf{F}(k, \phi) =
+ \int_0^\phi \! \frac{\mathsf{d}\theta}{\sqrt{1 - k^2 \sin^2 \theta}}
+ \text{ ,\quad for $|k| \le 1$,}$$ where k is `k` and φ is `phi`.
+#### Incomplete elliptic integral of the second kind <a id="sf.cmath.ellint.2">[[sf.cmath.ellint.2]]</a>
 ``` cpp
 double       ellint_2(double k, double phi);
 float        ellint_2f(float k, float phi);
 long double  ellint_2l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the second kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
+*Returns:*
+$$\mathsf{E}(k, \phi) = \int_0^\phi \! \sqrt{1 - k^2 \sin^2 \theta} \, \mathsf{d}\theta
+ \text{ ,\quad for $|k| \le 1$,}$$ where k is `k` and φ is `phi`.
+#### Incomplete elliptic integral of the third kind <a id="sf.cmath.ellint.3">[[sf.cmath.ellint.3]]</a>
 ``` cpp
 double       ellint_3(double k, double nu, double phi);
 float        ellint_3f(float k, float nu, float phi);
 long double  ellint_3l(long double k, long double nu, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the third kind of their respective arguments `k`, `nu`, and `phi` (`phi`
 measured in radians).
+*Returns:* $$\mathsf{\Pi}(\nu, k, \phi) = \int_0^\phi \!
+ \frac{ \mathsf{d}\theta }{ (1 - \nu \, \sin^2 \theta) \sqrt{1 - k^2 \sin^2 \theta} } \text{ ,\quad for $|k| \le 1$,}$$
+where $\nu$ is `nu`, k is `k`, and φ is `phi`.
 #### Exponential integral <a id="sf.cmath.expint">[[sf.cmath.expint]]</a>
 ``` cpp
 double       expint(double x);
 ```
 *Effects:* These functions compute the Laguerre polynomials of their
 respective arguments `n` and `x`.
+*Returns:* $$\mathsf{L}_n(x) =
+ \frac{e^x}{n!} \frac{\mathsf{d}^n}{\mathsf{d}x^n} \, (x^n e^{-x})
+ \text{ ,\quad for $x \ge 0$,}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
 #### Legendre polynomials <a id="sf.cmath.legendre">[[sf.cmath.legendre]]</a>
 ```
 *Effects:* These functions compute the Legendre polynomials of their
 respective arguments `l` and `x`.
+*Returns:* $$\mathsf{P}_\ell(x) =
+ \frac{1}{2^\ell \, \ell!}
+ \frac{\mathsf{d}^\ell}{\mathsf{d}x^\ell} \, (x^2 - 1) ^ \ell
+ \text{ ,\quad for $|x| \le 1$,}$$ where l is `l` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
+#### Riemann zeta function <a id="sf.cmath.riemann.zeta">[[sf.cmath.riemann.zeta]]</a>
 ``` cpp
 double       riemann_zeta(double x);
 float        riemann_zetaf(float x);
 long double  riemann_zetal(long double x);
   & \mbox{for $x < 0$}
   \end{array}
   \right.
 \;$$ where x is `x`.
+#### Spherical Bessel functions of the first kind <a id="sf.cmath.sph.bessel">[[sf.cmath.sph.bessel]]</a>
 ``` cpp
 double       sph_bessel(unsigned n, double x);
 float        sph_besself(unsigned n, float x);
 long double  sph_bessell(unsigned n, long double x);
 ```
 *Effects:* These functions compute the spherical Bessel functions of the
 first kind of their respective arguments `n` and `x`.
+*Returns:*
+$$\mathsf{j}_n(x) = (\pi/2x)^{1\!/\!2} \mathsf{J}_{n + 1\!/\!2}(x) \text{ ,\quad for $x \ge 0$,}$$
+where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
+See also [[sf.cmath.cyl.bessel.j]].
+#### Spherical associated Legendre functions <a id="sf.cmath.sph.legendre">[[sf.cmath.sph.legendre]]</a>
 ``` cpp
 double       sph_legendre(unsigned l, unsigned m, double theta);
 float        sph_legendref(unsigned l, unsigned m, float theta);
 long double  sph_legendrel(unsigned l, unsigned m, long double theta);
 *Effects:* These functions compute the spherical associated Legendre
 functions of their respective arguments `l`, `m`, and `theta` (`theta`
 measured in radians).
+*Returns:* $$\mathsf{Y}_\ell^m(\theta, 0)$$ where
+$$\mathsf{Y}_\ell^m(\theta, \phi) =
+     (-1)^m \left[\frac{(2 \ell + 1)}{4 \pi} \frac{(\ell - m)!}{(\ell + m)!}\right]^{1/2}
+ \mathsf{P}_\ell^m (\cos\theta) e^{i m \phi}
+     \text{ ,\quad for $|m| \le \ell$,}$$ and l is `l`, m is `m`, and θ
 is `theta`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
+See also [[sf.cmath.assoc.legendre]].
+#### Spherical Neumann functions <a id="sf.cmath.sph.neumann">[[sf.cmath.sph.neumann]]</a>
 ``` cpp
 double       sph_neumann(unsigned n, double x);
 float        sph_neumannf(unsigned n, float x);
 long double  sph_neumannl(unsigned n, long double x);
 *Effects:* These functions compute the spherical Neumann functions, also
 known as the spherical Bessel functions of the second kind, of their
 respective arguments `n` and `x`.
+*Returns:*
+$$\mathsf{n}_n(x) = (\pi/2x)^{1\!/\!2} \mathsf{N}_{n + 1\!/\!2}(x)
+ \text{ ,\quad for $x \ge 0$,}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
+See also [[sf.cmath.cyl.neumann]].

Diff to HTML by rtfpessoa