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

Files changed (1) hide show

tmp/tmpt_d78z_o/{from.md → to.md} +752 -0

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

	@@ -0,0 +1,752 @@

+### Mathematical special functions <a id="sf.cmath">[[sf.cmath]]</a>
+If any argument value to any of the functions specified in this
+subclause is a NaN (Not a Number), the function shall return a NaN but
+it shall not report a domain error. Otherwise, the function shall report
+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`.
+#### Beta function <a id="sf.cmath.beta">[[sf.cmath.beta]]</a>
+``` cpp
+double       beta(double x, double y);
+float        betaf(float x, float y);
+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);
+```
+*Effects:* These functions compute the irregular modified cylindrical
+Bessel functions of their respective arguments `nu` and `x`.
+*Returns:* $$%
+  \mathsf{K}_\nu(x) =
+  (\pi/2)i^{\nu+1} (            \mathsf{J}_\nu(ix)
+                + i \mathsf{N}_\nu(ix)
+                )
+  =
+  \left\{
+  \begin{array}{cl}
+  \displaystyle
+  \frac{\pi}{2}
+  \frac{\mathsf{I}_{-\nu}(x) - \mathsf{I}_{\nu}(x)}
+       {\sin \nu\pi },
+  & \mbox{for $x \ge 0$ and non-integral $\nu$}
+  \\
+  \\
+  \displaystyle
+  \frac{\pi}{2}
+  \lim_{\mu \rightarrow \nu} \frac{\mathsf{I}_{-\mu}(x) - \mathsf{I}_{\mu}(x)}
+                                  {\sin \mu\pi },
+  & \mbox{for $x \ge 0$ and integral $\nu$}
+  \end{array}
+  \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);
+```
+*Effects:* These functions compute the cylindrical Neumann functions,
+also known as the cylindrical Bessel functions of the second kind, of
+their respective arguments `nu` and `x`.
+*Returns:* $$%
+  \mathsf{N}_\nu(x) =
+  \left\{
+  \begin{array}{cl}
+  \displaystyle
+  \frac{\mathsf{J}_\nu(x) \cos \nu\pi - \mathsf{J}_{-\nu}(x)}
+       {\sin \nu\pi },
+  & \mbox{for $x \ge 0$ and non-integral $\nu$}
+  \\
+  \\
+  \displaystyle
+  \lim_{\mu \rightarrow \nu} \frac{\mathsf{J}_\mu(x) \cos \mu\pi - \mathsf{J}_{-\mu}(x)}
+                                {\sin \mu\pi },
+  & \mbox{for $x \ge 0$ and integral $\nu$}
+  \end{array}
+  \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}},
+       \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);
+```
+*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);
+```
+*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);
+float        expintf(float x);
+long double  expintl(long double x);
+```
+*Effects:* These functions compute the exponential integral of their
+respective arguments `x`.
+*Returns:* $$%
+  \mathsf{Ei}(x) =
+  - \int_{-x}^\infty \frac{e^{-t}}
+                          {t     } \, \mathsf{d}t
+\;$$ where x is `x`.
+#### Hermite polynomials <a id="sf.cmath.hermite">[[sf.cmath.hermite]]</a>
+``` cpp
+double       hermite(unsigned n, double x);
+float        hermitef(unsigned n, float x);
+long double  hermitel(unsigned n, long double x);
+```
+*Effects:* These functions compute the Hermite polynomials of their
+respective arguments `n` and `x`.
+*Returns:* $$%
+  \mathsf{H}_n(x) =
+  (-1)^n e^{x^2} \frac{ \mathsf{d} ^n}
+              { \mathsf{d}x^n} \, e^{-x^2}
+\;$$ where n is `n` and x is `x`.
+*Remarks:* The effect of calling each of these functions is
+*implementation-defined* if `n >= 128`.
+#### Laguerre polynomials <a id="sf.cmath.laguerre">[[sf.cmath.laguerre]]</a>
+``` cpp
+double       laguerre(unsigned n, double x);
+float        laguerref(unsigned n, float x);
+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>
+``` cpp
+double       legendre(unsigned l, double x);
+float        legendref(unsigned l, float x);
+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);
+```
+*Effects:* These functions compute the Riemann zeta function of their
+respective arguments `x`.
+*Returns:* $$%
+  \mathsf{\zeta}(x) =
+  \left\{
+  \begin{array}{cl}
+  \displaystyle
+  \sum_{k=1}^\infty k^{-x},
+  & \mbox{for $x > 1$}
+  \\
+  \\
+  \displaystyle
+  \frac{1}
+    {1 - 2^{1-x}}
+  \sum_{k=1}^\infty (-1)^{k-1} k^{-x},
+  & \mbox{for $0 \le x \le 1$}
+  \\
+  \\
+  \displaystyle
+  2^x \pi^{x-1} \sin(\frac{\pi x}{2}) \, \Gamma(1-x) \, \zeta(1-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);
+```
+*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);
+```
+*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.

Diff to HTML by rtfpessoa