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

Files changed (1) hide show

tmp/tmpnt0xkgmu/{from.md → to.md} +1160 -238

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

@@ -1,247 +1,1135 @@
-## C library <a id="c.math">[[c.math]]</a>
-The header `<ctgmath>` simply includes the headers `<ccomplex>` and
-`<cmath>`.
-The overloads provided in C by type-generic macros are already provided
-in `<ccomplex>` and `<cmath>` by “sufficient” additional overloads.
-Tables  [[tab:numerics.hdr.cmath]] and  [[tab:numerics.hdr.cstdlib]]
-describe headers `<cmath>` and `<cstdlib>`, respectively.
-The contents of these headers are the same as the Standard C library
-headers `<math.h>` and `<stdlib.h>` respectively, with the following
-changes:
-The `rand` function has the semantics specified in the C standard,
-except that the implementation may specify that particular library
-functions may call `rand`. It is implementation-defined whether the
-`rand` function may introduce data races ([[res.on.data.races]]). The
-random number generation ([[rand]]) facilities in this standard are
-often preferable to `rand`, because `rand`’s underlying algorithm is
-unspecified. Use of `rand` therefore continues to be nonportable, with
-unpredictable and oft-questionable quality and performance.
-In addition to the `int` versions of certain math functions in
-`<cstdlib>`, C++adds `long` and `long long` overloaded versions of these
-functions, with the same semantics.
-The added signatures are:
-``` cpp
-long abs(long);                     // labs()
-long long abs(long long); // llabs()
-ldiv_t div(long, long);             // ldiv()
-lldiv_t div(long long, long long);  // lldiv()
-```
-In addition to the `double` versions of the math functions in `<cmath>`,
-C++adds `float` and `long double` overloaded versions of these
-functions, with the same semantics.
-The added signatures are:
-``` cpp
-float abs(float);
-float acos(float);
-float acosh(float);
-float asin(float);
-float asinh(float);
-float atan(float);
-float atan2(float, float);
-float atanh(float);
-float cbrt(float);
-float ceil(float);
-float copysign(float, float);
-float cos(float);
-float cosh(float);
-float erf(float);
-float erfc(float);
-float exp(float);
-float exp2(float);
-float expm1(float);
-float fabs(float);
-float fdim(float, float);
-float floor(float);
-float fma(float, float, float);
-float fmax(float, float);
-float fmin(float, float);
-float fmod(float, float);
-float frexp(float, int*);
-float hypot(float, float);
-int ilogb(float);
-float ldexp(float, int);
-float lgamma(float);
-long long llrint(float);
-long long llround(float);
-float log(float);
-float log10(float);
-float log1p(float);
-float log2(float);
-float logb(float);
-long lrint(float);
-long lround(float);
-float modf(float, float*);
-float nearbyint(float);
-float nextafter(float, float);
-float nexttoward(float, long double);
-float pow(float, float);
-float remainder(float, float);
-float remquo(float, float, int *);
-float rint(float);
-float round(float);
-float scalbln(float, long);
-float scalbn(float, int);
-float sin(float);
-float sinh(float);
-float sqrt(float);
-float tan(float);
-float tanh(float);
-float tgamma(float);
-float trunc(float);
-double abs(double);            // fabs()
-long double abs(long double);
-long double acos(long double);
-long double acosh(long double);
-long double asin(long double);
-long double asinh(long double);
-long double atan(long double);
-long double atan2(long double, long double);
-long double atanh(long double);
-long double cbrt(long double);
-long double ceil(long double);
-long double copysign(long double, long double);
-long double cos(long double);
-long double cosh(long double);
-long double erf(long double);
-long double erfc(long double);
-long double exp(long double);
-long double exp2(long double);
-long double expm1(long double);
-long double fabs(long double);
-long double fdim(long double, long double);
-long double floor(long double);
-long double fma(long double, long double, long double);
-long double fmax(long double, long double);
-long double fmin(long double, long double);
-long double fmod(long double, long double);
-long double frexp(long double, int*);
-long double hypot(long double, long double);
-int ilogb(long double);
-long double ldexp(long double, int);
-long double lgamma(long double);
-long long llrint(long double);
-long long llround(long double);
-long double log(long double);
-long double log10(long double);
-long double log1p(long double);
-long double log2(long double);
-long double logb(long double);
-long lrint(long double);
-long lround(long double);
-long double modf(long double, long double*);
-long double nearbyint(long double);
-long double nextafter(long double, long double);
-long double nexttoward(long double, long double);
-long double pow(long double, long double);
-long double remainder(long double, long double);
-long double remquo(long double, long double, int *);
-long double rint(long double);
-long double round(long double);
-long double scalbln(long double, long);
-long double scalbn(long double, int);
-long double sin(long double);
-long double sinh(long double);
-long double sqrt(long double);
-long double tan(long double);
-long double tanh(long double);
-long double tgamma(long double);
-long double trunc(long double);
-```
-The classification/comparison functions behave the same as the C macros
-with the corresponding names defined in 7.12.3, Classification macros,
-and 7.12.14, Comparison macros in the C Standard. Each function is
-overloaded for the three floating-point types, as follows:
-``` cpp
   int fpclassify(float x);
-bool isfinite(float x);
-bool isinf(float x);
-bool isnan(float x);
-bool isnormal(float x);
-bool signbit(float x);
-bool isgreater(float x, float y);
-bool isgreaterequal(float x, float y);
-bool isless(float x, float y);
-bool islessequal(float x, float y);
-bool islessgreater(float x, float y);
-bool isunordered(float x, float y);
   int fpclassify(double x);
-bool isfinite(double x);
-bool isinf(double x);
-bool isnan(double x);
-bool isnormal(double x);
-bool signbit(double x);
-bool isgreater(double x, double y);
-bool isgreaterequal(double x, double y);
-bool isless(double x, double y);
-bool islessequal(double x, double y);
-bool islessgreater(double x, double y);
-bool isunordered(double x, double y);
   int fpclassify(long double x);
-bool isfinite(long double x);
-bool isinf(long double x);
-bool isnan(long double x);
-bool isnormal(long double x);
-bool signbit(long double x);
-bool isgreater(long double x, long double y);
-bool isgreaterequal(long double x, long double y);
-bool isless(long double x, long double y);
-bool islessequal(long double x, long double y);
-bool islessgreater(long double x, long double y);
-bool isunordered(long double x, long double y);
-```
-Moreover, there shall be additional overloads sufficient to ensure:
-1.  If any arithmetic argument corresponding to a `double` parameter has
-    type `long double`, then all arithmetic arguments corresponding to
-    `double` parameters are effectively cast to `long double`.
-2. Otherwise, if any arithmetic argument corresponding to a `double`
-    parameter has type `double` or an integer type, then all arithmetic
-    arguments corresponding to `double` parameters are effectively cast
-    to `double`.
-3. Otherwise, all arithmetic arguments corresponding to `double`
-    parameters have type `float`.
-ISO C 7.5, 7.10.2, 7.10.6.
 <!-- 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
-[ccmplx]: #ccmplx
 [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
 [cmplx.over]: #cmplx.over
 [complex]: #complex
 [complex.literals]: #complex.literals
 [complex.member.ops]: #complex.member.ops
 [complex.members]: #complex.members
@@ -250,39 +1138,48 @@ ISO C 7.5, 7.10.2, 7.10.6.
 [complex.special]: #complex.special
 [complex.syn]: #complex.syn
 [complex.transcendentals]: #complex.transcendentals
 [complex.value.ops]: #complex.value.ops
 [cons.slice]: #cons.slice
-[copyassignable]: #copyassignable
-[copyconstructible]: #copyconstructible
 [dcl.init]: dcl.md#dcl.init
-[equalitycomparable]: #equalitycomparable
 [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
 [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.output]: input.md#input.output
 [iostate.flags]: input.md#iostate.flags
 [istream.formatted]: input.md#istream.formatted
-[limits]: language.md#limits
 [mask.array.assign]: #mask.array.assign
 [mask.array.comp.assign]: #mask.array.comp.assign
 [mask.array.fill]: #mask.array.fill
-[moveassignable]: #moveassignable
 [numarray]: #numarray
 [numeric.iota]: #numeric.iota
 [numeric.ops]: #numeric.ops
 [numeric.ops.overview]: #numeric.ops.overview
 [numeric.requirements]: #numeric.requirements
 [numerics]: #numerics
 [numerics.general]: #numerics.general
 [partial.sum]: #partial.sum
 [rand]: #rand
 [rand.adapt]: #rand.adapt
 [rand.adapt.disc]: #rand.adapt.disc
 [rand.adapt.general]: #rand.adapt.general
@@ -331,25 +1228,49 @@ ISO C 7.5, 7.10.2, 7.10.6.
 [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
 [res.on.data.races]: library.md#res.on.data.races
 [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:UniformRandomNumberGenerator]: #tab:UniformRandomNumberGenerator
 [tab:iterator.input.requirements]: iterators.md#tab:iterator.input.requirements
-[tab:iterator.output.requirements]: iterators.md#tab:iterator.output.requirements
-[tab:iterator.random.access.requirements]: iterators.md#tab:iterator.random.access.requirements
-[tab:numerics.hdr.cmath]: #tab:numerics.hdr.cmath
-[tab:numerics.hdr.cstdlib]: #tab:numerics.hdr.cstdlib
 [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
@@ -358,10 +1279,13 @@ ISO C 7.5, 7.10.2, 7.10.6.
 [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
 [valarray.access]: #valarray.access
 [valarray.assign]: #valarray.assign
 [valarray.binary]: #valarray.binary
 [valarray.cassign]: #valarray.cassign
 [valarray.comparison]: #valarray.comparison
@@ -397,53 +1321,51 @@ ISO C 7.5, 7.10.2, 7.10.6.
 [^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]: Clause  [[limits]] 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]: For convenience, such objects are referred to as “arrays”
-    throughout the remainder of [[numarray]].
-[^10]: 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.
-[^11]: This constructor is the preferred method for converting a C array
     to a `valarray` object.
-[^12]: 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.
-[^13]: Compilers may take advantage of inlining, constant propagation,
-    loop fusion, tracking of pointers obtained from `operator new`, and
-    other techniques to generate efficient `valarray`s.
-[^14]: 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.
-[^15]: `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.
-[^16]: The use of fully closed ranges is intentional
-[^17]: The use of fully closed ranges is intentional
-[^18]: The use of fully closed ranges is intentional.
-[^19]: The use of fully closed ranges is intentional.

+## Mathematical functions for floating-point types <a id="c.math">[[c.math]]</a>
+### Header `<cmath>` synopsis <a id="cmath.syn">[[cmath.syn]]</a>
+``` cpp
+namespace std {
+  using float_t = see below;
+  using double_t = see below;
+}
+#define HUGE_VAL see below
+#define HUGE_VALF see below
+#define HUGE_VALL see below
+#define INFINITY see below
+#define NAN see below
+#define FP_INFINITE see below
+#define FP_NAN see below
+#define FP_NORMAL see below
+#define FP_SUBNORMAL see below
+#define FP_ZERO see below
+#define FP_FAST_FMA see below
+#define FP_FAST_FMAF see below
+#define FP_FAST_FMAL see below
+#define FP_ILOGB0 see below
+#define FP_ILOGBNAN see below
+#define MATH_ERRNO see below
+#define MATH_ERREXCEPT see below
+#define math_errhandling see below
+namespace std {
+  float acos(float x);  // see [library.c]
+  double acos(double x);
+  long double acos(long double x);  // see [library.c]
+  float acosf(float x);
+  long double acosl(long double x);
+  float asin(float x);  // see [library.c]
+  double asin(double x);
+  long double asin(long double x);  // see [library.c]
+  float asinf(float x);
+  long double asinl(long double x);
+  float atan(float x);  // see [library.c]
+  double atan(double x);
+  long double atan(long double x);  // see [library.c]
+  float atanf(float x);
+  long double atanl(long double x);
+  float atan2(float y, float x);  // see [library.c]
+  double atan2(double y, double x);
+ long double atan2(long double y, long double x); // see [library.c]
+  float atan2f(float y, float x);
+  long double atan2l(long double y, long double x);
+  float cos(float x);  // see [library.c]
+  double cos(double x);
+  long double cos(long double x);  // see [library.c]
+  float cosf(float x);
+  long double cosl(long double x);
+  float sin(float x);  // see [library.c]
+  double sin(double x);
+  long double sin(long double x);  // see [library.c]
+  float sinf(float x);
+  long double sinl(long double x);
+  float tan(float x);  // see [library.c]
+  double tan(double x);
+  long double tan(long double x);  // see [library.c]
+ float tanf(float x);
+  long double tanl(long double x);
+  float acosh(float x);  // see [library.c]
+  double acosh(double x);
+  long double acosh(long double x);  // see [library.c]
+  float acoshf(float x);
+  long double acoshl(long double x);
+  float asinh(float x);  // see [library.c]
+  double asinh(double x);
+  long double asinh(long double x);  // see [library.c]
+  float asinhf(float x);
+  long double asinhl(long double x);
+  float atanh(float x);  // see [library.c]
+  double atanh(double x);
+  long double atanh(long double x);  // see [library.c]
+  float atanhf(float x);
+  long double atanhl(long double x);
+  float cosh(float x);  // see [library.c]
+  double cosh(double x);
+  long double cosh(long double x);  // see [library.c]
+  float coshf(float x);
+  long double coshl(long double x);
+  float sinh(float x);  // see [library.c]
+  double sinh(double x);
+  long double sinh(long double x);  // see [library.c]
+  float sinhf(float x);
+  long double sinhl(long double x);
+  float tanh(float x);  // see [library.c]
+  double tanh(double x);
+  long double tanh(long double x);  // see [library.c]
+  float tanhf(float x);
+  long double tanhl(long double x);
+  float exp(float x);  // see [library.c]
+  double exp(double x);
+  long double exp(long double x);  // see [library.c]
+  float expf(float x);
+  long double expl(long double x);
+  float exp2(float x);  // see [library.c]
+  double exp2(double x);
+  long double exp2(long double x);  // see [library.c]
+  float exp2f(float x);
+  long double exp2l(long double x);
+  float expm1(float x);  // see [library.c]
+  double expm1(double x);
+  long double expm1(long double x);  // see [library.c]
+  float expm1f(float x);
+  long double expm1l(long double x);
+  float frexp(float value, int* exp);  // see [library.c]
+  double frexp(double value, int* exp);
+  long double frexp(long double value, int* exp);  // see [library.c]
+  float frexpf(float value, int* exp);
+  long double frexpl(long double value, int* exp);
+  int ilogb(float x);  // see [library.c]
+  int ilogb(double x);
+  int ilogb(long double x);  // see [library.c]
+  int ilogbf(float x);
+  int ilogbl(long double x);
+  float ldexp(float x, int exp);  // see [library.c]
+  double ldexp(double x, int exp);
+  long double ldexp(long double x, int exp);  // see [library.c]
+  float ldexpf(float x, int exp);
+  long double ldexpl(long double x, int exp);
+  float log(float x);  // see [library.c]
+  double log(double x);
+  long double log(long double x);  // see [library.c]
+  float logf(float x);
+  long double logl(long double x);
+  float log10(float x);  // see [library.c]
+  double log10(double x);
+  long double log10(long double x);  // see [library.c]
+  float log10f(float x);
+  long double log10l(long double x);
+  float log1p(float x);  // see [library.c]
+  double log1p(double x);
+  long double log1p(long double x);  // see [library.c]
+  float log1pf(float x);
+  long double log1pl(long double x);
+  float log2(float x);  // see [library.c]
+  double log2(double x);
+  long double log2(long double x);  // see [library.c]
+  float log2f(float x);
+  long double log2l(long double x);
+  float logb(float x);  // see [library.c]
+  double logb(double x);
+  long double logb(long double x);  // see [library.c]
+  float logbf(float x);
+  long double logbl(long double x);
+  float modf(float value, float* iptr);  // see [library.c]
+  double modf(double value, double* iptr);
+  long double modf(long double value, long double* iptr);  // see [library.c]
+  float modff(float value, float* iptr);
+  long double modfl(long double value, long double* iptr);
+  float scalbn(float x, int n);  // see [library.c]
+  double scalbn(double x, int n);
+  long double scalbn(long double x, int n);  // see [library.c]
+  float scalbnf(float x, int n);
+  long double scalbnl(long double x, int n);
+  float scalbln(float x, long int n);  // see [library.c]
+  double scalbln(double x, long int n);
+  long double scalbln(long double x, long int n);  // see [library.c]
+  float scalblnf(float x, long int n);
+  long double scalblnl(long double x, long int n);
+  float cbrt(float x);  // see [library.c]
+  double cbrt(double x);
+  long double cbrt(long double x);  // see [library.c]
+  float cbrtf(float x);
+  long double cbrtl(long double x);
+  // [c.math.abs], absolute values
+  int abs(int j);
+  long int abs(long int j);
+  long long int abs(long long int j);
+  float abs(float j);
+  double abs(double j);
+  long double abs(long double j);
+  float fabs(float x);  // see [library.c]
+  double fabs(double x);
+  long double fabs(long double x);  // see [library.c]
+  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);
+  double hypot(double x, double y, double z);
+  long double hypot(long double x, long double y, long double z);
+  float pow(float x, float y);  // see [library.c]
+  double pow(double x, double y);
+  long double pow(long double x, long double y);  // see [library.c]
+  float powf(float x, float y);
+  long double powl(long double x, long double y);
+  float sqrt(float x);  // see [library.c]
+  double sqrt(double x);
+  long double sqrt(long double x);  // see [library.c]
+  float sqrtf(float x);
+  long double sqrtl(long double x);
+  float erf(float x);  // see [library.c]
+  double erf(double x);
+  long double erf(long double x);  // see [library.c]
+  float erff(float x);
+  long double erfl(long double x);
+  float erfc(float x);  // see [library.c]
+  double erfc(double x);
+  long double erfc(long double x);  // see [library.c]
+  float erfcf(float x);
+  long double erfcl(long double x);
+  float lgamma(float x);  // see [library.c]
+  double lgamma(double x);
+  long double lgamma(long double x);  // see [library.c]
+  float lgammaf(float x);
+  long double lgammal(long double x);
+  float tgamma(float x);  // see [library.c]
+  double tgamma(double x);
+  long double tgamma(long double x);  // see [library.c]
+  float tgammaf(float x);
+  long double tgammal(long double x);
+  float ceil(float x);  // see [library.c]
+  double ceil(double x);
+  long double ceil(long double x);  // see [library.c]
+  float ceilf(float x);
+  long double ceill(long double x);
+  float floor(float x);  // see [library.c]
+  double floor(double x);
+  long double floor(long double x);  // see [library.c]
+  float floorf(float x);
+  long double floorl(long double x);
+  float nearbyint(float x);  // see [library.c]
+  double nearbyint(double x);
+  long double nearbyint(long double x);  // see [library.c]
+  float nearbyintf(float x);
+  long double nearbyintl(long double x);
+  float rint(float x);  // see [library.c]
+  double rint(double x);
+  long double rint(long double x);  // see [library.c]
+  float rintf(float x);
+  long double rintl(long double x);
+  long int lrint(float x);  // see [library.c]
+  long int lrint(double x);
+  long int lrint(long double x);  // see [library.c]
+  long int lrintf(float x);
+  long int lrintl(long double x);
+  long long int llrint(float x);  // see [library.c]
+  long long int llrint(double x);
+  long long int llrint(long double x);  // see [library.c]
+  long long int llrintf(float x);
+  long long int llrintl(long double x);
+  float round(float x);  // see [library.c]
+  double round(double x);
+  long double round(long double x);  // see [library.c]
+  float roundf(float x);
+  long double roundl(long double x);
+  long int lround(float x);  // see [library.c]
+  long int lround(double x);
+  long int lround(long double x);  // see [library.c]
+  long int lroundf(float x);
+  long int lroundl(long double x);
+  long long int llround(float x);  // see [library.c]
+  long long int llround(double x);
+  long long int llround(long double x);  // see [library.c]
+  long long int llroundf(float x);
+  long long int llroundl(long double x);
+  float trunc(float x);  // see [library.c]
+  double trunc(double x);
+  long double trunc(long double x);  // see [library.c]
+  float truncf(float x);
+  long double truncl(long double x);
+  float fmod(float x, float y);  // see [library.c]
+  double fmod(double x, double y);
+  long double fmod(long double x, long double y);  // see [library.c]
+  float fmodf(float x, float y);
+  long double fmodl(long double x, long double y);
+  float remainder(float x, float y);  // see [library.c]
+  double remainder(double x, double y);
+  long double remainder(long double x, long double y);  // see [library.c]
+  float remainderf(float x, float y);
+  long double remainderl(long double x, long double y);
+  float remquo(float x, float y, int* quo);  // see [library.c]
+  double remquo(double x, double y, int* quo);
+  long double remquo(long double x, long double y, int* quo);  // see [library.c]
+  float remquof(float x, float y, int* quo);
+  long double remquol(long double x, long double y, int* quo);
+  float copysign(float x, float y);  // see [library.c]
+  double copysign(double x, double y);
+  long double copysign(long double x, long double y);  // see [library.c]
+  float copysignf(float x, float y);
+  long double copysignl(long double x, long double y);
+  double nan(const char* tagp);
+  float nanf(const char* tagp);
+  long double nanl(const char* tagp);
+  float nextafter(float x, float y);  // see [library.c]
+  double nextafter(double x, double y);
+  long double nextafter(long double x, long double y);  // see [library.c]
+  float nextafterf(float x, float y);
+  long double nextafterl(long double x, long double y);
+  float nexttoward(float x, long double y);  // see [library.c]
+  double nexttoward(double x, long double y);
+  long double nexttoward(long double x, long double y);  // see [library.c]
+  float nexttowardf(float x, long double y);
+  long double nexttowardl(long double x, long double y);
+  float fdim(float x, float y);  // see [library.c]
+  double fdim(double x, double y);
+  long double fdim(long double x, long double y);  // see [library.c]
+  float fdimf(float x, float y);
+  long double fdiml(long double x, long double y);
+  float fmax(float x, float y);  // see [library.c]
+  double fmax(double x, double y);
+  long double fmax(long double x, long double y);  // see [library.c]
+  float fmaxf(float x, float y);
+  long double fmaxl(long double x, long double y);
+  float fmin(float x, float y);  // see [library.c]
+  double fmin(double x, double y);
+  long double fmin(long double x, long double y);  // see [library.c]
+  float fminf(float x, float y);
+  long double fminl(long double x, long double y);
+  float fma(float x, float y, float z);  // see [library.c]
+  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
+  double       expint(double x);
+  float        expintf(float x);
+  long double  expintl(long double x);
+  // [sf.cmath.hermite], Hermite polynomials
+  double       hermite(unsigned n, double x);
+  float        hermitef(unsigned n, float x);
+  long double  hermitel(unsigned n, long double x);
+  // [sf.cmath.laguerre], Laguerre polynomials
+  double       laguerre(unsigned n, double x);
+  float        laguerref(unsigned n, float x);
+  long double  laguerrel(unsigned n, long double x);
+  // [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);
+}
+```
+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);
+float abs(float j);
+double abs(double j);
+long double abs(long double j);
+```
+*Effects:* The `abs` functions have the semantics specified in the C
+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);
+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.
+ISO C 7.12.3, 7.12.4
+### 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.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.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.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
 [^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