[c.math] - C++17 → C++20

Files changed (1) hide show

tmp/tmpbs9l08t_/{from.md → to.md} +174 -443

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

@@ -211,11 +211,11 @@ namespace std {
   float fabsf(float x);
   long double fabsl(long double x);
   float hypot(float x, float y);        // see [library.c]
   double hypot(double x, double y);
-  long double hypot(double x, double y);  // see [library.c]
   float hypotf(float x, float y);
   long double hypotl(long double x, long double y);
   // [c.math.hypot3], three-dimensional hypotenuse
   float hypot(float x, float y, float z);
@@ -380,123 +380,128 @@ namespace std {
   double fma(double x, double y, double z);
   long double fma(long double x, long double y, long double z); // see [library.c]
   float fmaf(float x, float y, float z);
   long double fmal(long double x, long double y, long double z);
   // [c.math.fpclass], classification / comparison functions
   int fpclassify(float x);
   int fpclassify(double x);
   int fpclassify(long double x);
- int isfinite(float x);
- int isfinite(double x);
- int isfinite(long double x);
- int isinf(float x);
- int isinf(double x);
- int isinf(long double x);
- int isnan(float x);
- int isnan(double x);
- int isnan(long double x);
- int isnormal(float x);
- int isnormal(double x);
- int isnormal(long double x);
- int signbit(float x);
- int signbit(double x);
- int signbit(long double x);
- int isgreater(float x, float y);
- int isgreater(double x, double y);
- int isgreater(long double x, long double y);
- int isgreaterequal(float x, float y);
- int isgreaterequal(double x, double y);
- int isgreaterequal(long double x, long double y);
- int isless(float x, float y);
- int isless(double x, double y);
- int isless(long double x, long double y);
- int islessequal(float x, float y);
- int islessequal(double x, double y);
- int islessequal(long double x, long double y);
- int islessgreater(float x, float y);
- int islessgreater(double x, double y);
- int islessgreater(long double x, long double y);
- int isunordered(float x, float y);
- int isunordered(double x, double y);
- int isunordered(long double x, long double y);
   // [sf.cmath], mathematical special functions
-  // [sf.cmath.assoc_laguerre], associated Laguerre polynomials
   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);
-  // [sf.cmath.assoc_legendre], associated Legendre functions
   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);
   // [sf.cmath.beta], beta function
   double       beta(double x, double y);
   float        betaf(float x, float y);
   long double  betal(long double x, long double y);
-  // [sf.cmath.comp_ellint_1], complete elliptic integral of the first kind
   double       comp_ellint_1(double k);
   float        comp_ellint_1f(float k);
   long double  comp_ellint_1l(long double k);
-  // [sf.cmath.comp_ellint_2], complete elliptic integral of the second kind
   double       comp_ellint_2(double k);
   float        comp_ellint_2f(float k);
   long double  comp_ellint_2l(long double k);
-  // [sf.cmath.comp_ellint_3], complete elliptic integral of the third kind
   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);
-  // [sf.cmath.cyl_bessel_i], regular modified cylindrical Bessel functions
   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);
-  // [sf.cmath.cyl_bessel_j], cylindrical Bessel functions of the first kind
   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);
-  // [sf.cmath.cyl_bessel_k], irregular modified cylindrical Bessel functions
   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);
-  // [sf.cmath.cyl_neumann], cylindrical Neumann functions;
   // cylindrical Bessel functions of the second kind
   double       cyl_neumann(double nu, double x);
   float        cyl_neumannf(float nu, float x);
   long double  cyl_neumannl(long double nu, long double x);
-  // [sf.cmath.ellint_1], incomplete elliptic integral of the first kind
   double       ellint_1(double k, double phi);
   float        ellint_1f(float k, float phi);
   long double  ellint_1l(long double k, long double phi);
-  // [sf.cmath.ellint_2], incomplete elliptic integral of the second kind
   double       ellint_2(double k, double phi);
   float        ellint_2f(float k, float phi);
   long double  ellint_2l(long double k, long double phi);
-  // [sf.cmath.ellint_3], incomplete elliptic integral of the third kind
   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);
   // [sf.cmath.expint], exponential integral
@@ -517,27 +522,27 @@ namespace std {
   // [sf.cmath.legendre], Legendre polynomials
   double       legendre(unsigned l, double x);
   float        legendref(unsigned l, float x);
   long double  legendrel(unsigned l, long double x);
-  // [sf.cmath.riemann_zeta], Riemann zeta function
   double       riemann_zeta(double x);
   float        riemann_zetaf(float x);
   long double  riemann_zetal(long double x);
-  // [sf.cmath.sph_bessel], spherical Bessel functions of the first kind
   double       sph_bessel(unsigned n, double x);
   float        sph_besself(unsigned n, float x);
   long double  sph_bessell(unsigned n, long double x);
-  // [sf.cmath.sph_legendre], spherical associated Legendre functions
   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);
-  // [sf.cmath.sph_neumann], spherical Neumann functions;
-  // spherical Bessel functions of the second kind:
   double       sph_neumann(unsigned n, double x);
   float        sph_neumannf(unsigned n, float x);
   long double  sph_neumannl(unsigned n, long double x);
 }
 ```
@@ -546,38 +551,37 @@ The contents and meaning of the header `<cmath>` are the same as the C
 standard library header `<math.h>`, with the addition of a
 three-dimensional hypotenuse function ([[c.math.hypot3]]) and the
 mathematical special functions described in [[sf.cmath]].
 [*Note 1*: Several functions have additional overloads in this
-International Standard, but they have the same behavior as in the C
-standard library ([[library.c]]). — *end note*]
 For each set of overloaded functions within `<cmath>`, with the
 exception of `abs`, there shall be additional overloads sufficient to
 ensure:
-1.  If any argument of arithmetic type corresponding to a `double`
   parameter has type `long double`, then all arguments of arithmetic
- type ([[basic.fundamental]]) corresponding to `double` parameters
-    are effectively cast to `long double`.
-2.  Otherwise, if any argument of arithmetic type corresponding to a
   `double` parameter has type `double` or an integer type, then all
- arguments of arithmetic type corresponding to `double` parameters
-    are effectively cast to `double`.
-3.  Otherwise, all arguments of arithmetic type corresponding to
- `double` parameters have type `float`.
-[*Note 2*: `abs` is exempted from these rules in order to stay
 compatible with C. — *end note*]
 ISO C 7.12
 ### Absolute values <a id="c.math.abs">[[c.math.abs]]</a>
-[*Note 1*: The headers `<cstdlib>` ([[cstdlib.syn]]) and `<cmath>` (
-[[cmath.syn]]) declare the functions described in this
-subclause. — *end note*]
 ``` cpp
 int abs(int j);
 long int abs(long int j);
 long long int abs(long long int j);
@@ -590,16 +594,16 @@ long double abs(long double j);
 standard library for the functions `abs`, `labs`, `llabs`, `fabsf`,
 `fabs`, and `fabsl`.
 *Remarks:* If `abs()` is called with an argument of type `X` for which
 `is_unsigned_v<X>` is `true` and if `X` cannot be converted to `int` by
-integral promotion ([[conv.prom]]), the program is ill-formed.
 [*Note 1*: Arguments that can be promoted to `int` are permitted for
 compatibility with C. — *end note*]
-ISO C 7.12.7.2, 7.22.6.1
 ### Three-dimensional hypotenuse <a id="c.math.hypot3">[[c.math.hypot3]]</a>
 ``` cpp
 float hypot(float x, float y, float z);
@@ -607,10 +611,34 @@ double hypot(double x, double y, double z);
 long double hypot(long double x, long double y, long double z);
 ```
 *Returns:* $\sqrt{x^2+y^2+z^2}$.
 ### Classification / comparison functions <a id="c.math.fpclass">[[c.math.fpclass]]</a>
 The classification / comparison functions behave the same as the C
 macros with the corresponding names defined in the C standard library.
 Each function is overloaded for the three floating-point types.
@@ -627,54 +655,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`.
@@ -687,115 +709,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);
@@ -828,14 +840,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);
@@ -863,13 +875,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);
@@ -877,17 +889,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);
@@ -895,16 +905,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);
@@ -912,16 +921,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);
@@ -967,15 +973,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>
@@ -987,22 +991,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);
@@ -1032,32 +1033,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);
@@ -1065,30 +1065,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);
@@ -1096,276 +1089,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.

   float fabsf(float x);
   long double fabsl(long double x);
   float hypot(float x, float y);        // see [library.c]
   double hypot(double x, double y);
+  long double hypot(long double x, long double y);  // see [library.c]
   float hypotf(float x, float y);
   long double hypotl(long double x, long double y);
   // [c.math.hypot3], three-dimensional hypotenuse
   float hypot(float x, float y, float z);
   double fma(double x, double y, double z);
   long double fma(long double x, long double y, long double z); // see [library.c]
   float fmaf(float x, float y, float z);
   long double fmal(long double x, long double y, long double z);
+  // [c.math.lerp], linear interpolation
+  constexpr float lerp(float a, float b, float t) noexcept;
+  constexpr double lerp(double a, double b, double t) noexcept;
+  constexpr long double lerp(long double a, long double b, long double t) noexcept;
   // [c.math.fpclass], classification / comparison functions
   int fpclassify(float x);
   int fpclassify(double x);
   int fpclassify(long double x);
+ bool isfinite(float x);
+ bool isfinite(double x);
+ bool isfinite(long double x);
+ bool isinf(float x);
+ bool isinf(double x);
+ bool isinf(long double x);
+ bool isnan(float x);
+ bool isnan(double x);
+ bool isnan(long double x);
+ bool isnormal(float x);
+ bool isnormal(double x);
+ bool isnormal(long double x);
+ bool signbit(float x);
+ bool signbit(double x);
+ bool signbit(long double x);
+ bool isgreater(float x, float y);
+ bool isgreater(double x, double y);
+ bool isgreater(long double x, long double y);
+ bool isgreaterequal(float x, float y);
+ bool isgreaterequal(double x, double y);
+ bool isgreaterequal(long double x, long double y);
+ bool isless(float x, float y);
+ bool isless(double x, double y);
+ bool isless(long double x, long double y);
+ bool islessequal(float x, float y);
+ bool islessequal(double x, double y);
+ bool islessequal(long double x, long double y);
+ bool islessgreater(float x, float y);
+ bool islessgreater(double x, double y);
+ bool islessgreater(long double x, long double y);
+ bool isunordered(float x, float y);
+ bool isunordered(double x, double y);
+ bool isunordered(long double x, long double y);
   // [sf.cmath], mathematical special functions
+  // [sf.cmath.assoc.laguerre], associated Laguerre polynomials
   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);
+  // [sf.cmath.assoc.legendre], associated Legendre functions
   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);
   // [sf.cmath.beta], beta function
   double       beta(double x, double y);
   float        betaf(float x, float y);
   long double  betal(long double x, long double y);
+  // [sf.cmath.comp.ellint.1], complete elliptic integral of the first kind
   double       comp_ellint_1(double k);
   float        comp_ellint_1f(float k);
   long double  comp_ellint_1l(long double k);
+  // [sf.cmath.comp.ellint.2], complete elliptic integral of the second kind
   double       comp_ellint_2(double k);
   float        comp_ellint_2f(float k);
   long double  comp_ellint_2l(long double k);
+  // [sf.cmath.comp.ellint.3], complete elliptic integral of the third kind
   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);
+  // [sf.cmath.cyl.bessel.i], regular modified cylindrical Bessel functions
   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);
+  // [sf.cmath.cyl.bessel.j], cylindrical Bessel functions of the first kind
   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);
+  // [sf.cmath.cyl.bessel.k], irregular modified cylindrical Bessel functions
   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);
+  // [sf.cmath.cyl.neumann], cylindrical Neumann functions;
   // cylindrical Bessel functions of the second kind
   double       cyl_neumann(double nu, double x);
   float        cyl_neumannf(float nu, float x);
   long double  cyl_neumannl(long double nu, long double x);
+  // [sf.cmath.ellint.1], incomplete elliptic integral of the first kind
   double       ellint_1(double k, double phi);
   float        ellint_1f(float k, float phi);
   long double  ellint_1l(long double k, long double phi);
+  // [sf.cmath.ellint.2], incomplete elliptic integral of the second kind
   double       ellint_2(double k, double phi);
   float        ellint_2f(float k, float phi);
   long double  ellint_2l(long double k, long double phi);
+  // [sf.cmath.ellint.3], incomplete elliptic integral of the third kind
   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);
   // [sf.cmath.expint], exponential integral
   // [sf.cmath.legendre], Legendre polynomials
   double       legendre(unsigned l, double x);
   float        legendref(unsigned l, float x);
   long double  legendrel(unsigned l, long double x);
+  // [sf.cmath.riemann.zeta], Riemann zeta function
   double       riemann_zeta(double x);
   float        riemann_zetaf(float x);
   long double  riemann_zetal(long double x);
+  // [sf.cmath.sph.bessel], spherical Bessel functions of the first kind
   double       sph_bessel(unsigned n, double x);
   float        sph_besself(unsigned n, float x);
   long double  sph_bessell(unsigned n, long double x);
+  // [sf.cmath.sph.legendre], spherical associated Legendre functions
   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);
+  // [sf.cmath.sph.neumann], spherical Neumann functions;
+  // spherical Bessel functions of the second kind
   double       sph_neumann(unsigned n, double x);
   float        sph_neumannf(unsigned n, float x);
   long double  sph_neumannl(unsigned n, long double x);
 }
 ```
 standard library header `<math.h>`, with the addition of a
 three-dimensional hypotenuse function ([[c.math.hypot3]]) and the
 mathematical special functions described in [[sf.cmath]].
 [*Note 1*: Several functions have additional overloads in this
+document, but they have the same behavior as in the C standard library
+[[library.c]]. — *end note*]
 For each set of overloaded functions within `<cmath>`, with the
 exception of `abs`, there shall be additional overloads sufficient to
 ensure:
+- If any argument of arithmetic type corresponding to a `double`
   parameter has type `long double`, then all arguments of arithmetic
+ type [[basic.fundamental]] corresponding to `double` parameters are
+ effectively cast to `long double`.
+- Otherwise, if any argument of arithmetic type corresponding to a
   `double` parameter has type `double` or an integer type, then all
+ arguments of arithmetic type corresponding to `double` parameters are
+ effectively cast to `double`.
+- \[*Note 2*: Otherwise, all arguments of arithmetic type corresponding
+  to `double` parameters have type `float`. — *end note*]
+[*Note 3*: `abs` is exempted from these rules in order to stay
 compatible with C. — *end note*]
 ISO C 7.12
 ### Absolute values <a id="c.math.abs">[[c.math.abs]]</a>
+[*Note 1*: The headers `<cstdlib>` and `<cmath>` declare the functions
+described in this subclause. — *end note*]
 ``` cpp
 int abs(int j);
 long int abs(long int j);
 long long int abs(long long int j);
 standard library for the functions `abs`, `labs`, `llabs`, `fabsf`,
 `fabs`, and `fabsl`.
 *Remarks:* If `abs()` is called with an argument of type `X` for which
 `is_unsigned_v<X>` is `true` and if `X` cannot be converted to `int` by
+integral promotion [[conv.prom]], the program is ill-formed.
 [*Note 1*: Arguments that can be promoted to `int` are permitted for
 compatibility with C. — *end note*]
+See also: ISO C 7.12.7.2, 7.22.6.1
 ### Three-dimensional hypotenuse <a id="c.math.hypot3">[[c.math.hypot3]]</a>
 ``` cpp
 float hypot(float x, float y, float z);
 long double hypot(long double x, long double y, long double z);
 ```
 *Returns:* $\sqrt{x^2+y^2+z^2}$.
+### Linear interpolation <a id="c.math.lerp">[[c.math.lerp]]</a>
+``` cpp
+constexpr float lerp(float a, float b, float t) noexcept;
+constexpr double lerp(double a, double b, double t) noexcept;
+constexpr long double lerp(long double a, long double b, long double t) noexcept;
+```
+*Returns:* a+t(b-a).
+*Remarks:* Let `r` be the value returned. If
+`isfinite(a) && isfinite(b)`, then:
+- If `t == 0`, then `r == a`.
+- If `t == 1`, then `r == b`.
+- If `t >= 0 && t <= 1`, then `isfinite(r)`.
+- If `isfinite(t) && a == b`, then `r == a`.
+- If `isfinite(t) || !isnan(t) && b-a != 0`, then `!isnan(r)`.
+Let *`CMP`*`(x,y)` be `1` if `x > y`, `-1` if `x < y`, and `0`
+otherwise. For any `t1` and `t2`, the product of
+*`CMP`*`(lerp(a, b, t2), lerp(a, b, t1))`, *`CMP`*`(t2, t1)`, and
+*`CMP`*`(b, a)` is non-negative.
 ### Classification / comparison functions <a id="c.math.fpclass">[[c.math.fpclass]]</a>
 The classification / comparison functions behave the same as the C
 macros with the corresponding names defined in the C standard library.
 Each function is overloaded for the three floating-point types.
 - 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