diff --git a/manual/arith.texi b/manual/arith.texi
index e403cb5..28a0e13 100644
--- a/manual/arith.texi
+++ b/manual/arith.texi
@@ -686,9 +686,13 @@ such as by defining @code{_GNU_SOURCE}, and then you must include
 @deftypevr Macro float SNANF
 @deftypevrx Macro double SNAN
 @deftypevrx Macro {long double} SNANL
+@deftypevrx Macro _FloatN SNANFN
+@deftypevrx Macro _FloatNx SNANFNx
 @standards{TS 18661-1:2014, math.h}
-These macros, defined by TS 18661-1:2014, are constant expressions for
-signaling NaNs.
+@standardsx{SNANFN, TS 18661-3:2015, math.h}
+@standardsx{SNANFNx, TS 18661-3:2015, math.h}
+These macros, defined by TS 18661-1:2014 and TS 18661-3:2015, are
+constant expressions for signaling NaNs.
 @end deftypevr
 
 @deftypevr Macro int FE_SNANS_ALWAYS_SIGNAL
@@ -917,7 +921,11 @@ to test for overflow on both old and new hardware.
 @deftypevr Macro double HUGE_VAL
 @deftypevrx Macro float HUGE_VALF
 @deftypevrx Macro {long double} HUGE_VALL
+@deftypevrx Macro _FloatN HUGE_VAL_FN
+@deftypevrx Macro _FloatNx HUGE_VAL_FNx
 @standards{ISO, math.h}
+@standardsx{HUGE_VAL_FN, TS 18661-3:2015, math.h}
+@standardsx{HUGE_VAL_FNx, TS 18661-3:2015, math.h}
 An expression representing a particular very large number.  On machines
 that use @w{IEEE 754} floating point format, @code{HUGE_VAL} is infinity.
 On other machines, it's typically the largest positive number that can
@@ -1229,8 +1237,8 @@ whose imaginary part is @var{y}, the absolute value is @w{@code{sqrt
 @pindex stdlib.h
 Prototypes for @code{abs}, @code{labs} and @code{llabs} are in @file{stdlib.h};
 @code{imaxabs} is declared in @file{inttypes.h};
-@code{fabs}, @code{fabsf} and @code{fabsl} are declared in @file{math.h}.
-@code{cabs}, @code{cabsf} and @code{cabsl} are declared in @file{complex.h}.
+the @code{fabs} functions are declared in @file{math.h};
+the @code{cabs} functions are declared in @file{complex.h}.
 
 @deftypefun int abs (int @var{number})
 @deftypefunx {long int} labs (long int @var{number})
@@ -1254,7 +1262,11 @@ See @ref{Integers} for a description of the @code{intmax_t} type.
 @deftypefun double fabs (double @var{number})
 @deftypefunx float fabsf (float @var{number})
 @deftypefunx {long double} fabsl (long double @var{number})
+@deftypefunx _FloatN fabsfN (_Float@var{N} @var{number})
+@deftypefunx _FloatNx fabsfNx (_Float@var{N}x @var{number})
 @standards{ISO, math.h}
+@standardsx{fabsfN, TS 18661-3:2015, math.h}
+@standardsx{fabsfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 This function returns the absolute value of the floating-point number
 @var{number}.
@@ -1263,7 +1275,11 @@ This function returns the absolute value of the floating-point number
 @deftypefun double cabs (complex double @var{z})
 @deftypefunx float cabsf (complex float @var{z})
 @deftypefunx {long double} cabsl (complex long double @var{z})
+@deftypefunx _FloatN cabsfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx cabsfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cabsfN, TS 18661-3:2015, complex.h}
+@standardsx{cabsfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the absolute  value of the complex number @var{z}
 (@pxref{Complex Numbers}).  The absolute value of a complex number is:
@@ -1296,7 +1312,11 @@ All these functions are declared in @file{math.h}.
 @deftypefun double frexp (double @var{value}, int *@var{exponent})
 @deftypefunx float frexpf (float @var{value}, int *@var{exponent})
 @deftypefunx {long double} frexpl (long double @var{value}, int *@var{exponent})
+@deftypefunx _FloatN frexpfN (_Float@var{N} @var{value}, int *@var{exponent})
+@deftypefunx _FloatNx frexpfNx (_Float@var{N}x @var{value}, int *@var{exponent})
 @standards{ISO, math.h}
+@standardsx{frexpfN, TS 18661-3:2015, math.h}
+@standardsx{frexpfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are used to split the number @var{value}
 into a normalized fraction and an exponent.
@@ -1317,7 +1337,11 @@ zero is stored in @code{*@var{exponent}}.
 @deftypefun double ldexp (double @var{value}, int @var{exponent})
 @deftypefunx float ldexpf (float @var{value}, int @var{exponent})
 @deftypefunx {long double} ldexpl (long double @var{value}, int @var{exponent})
+@deftypefunx _FloatN ldexpfN (_Float@var{N} @var{value}, int @var{exponent})
+@deftypefunx _FloatNx ldexpfNx (_Float@var{N}x @var{value}, int @var{exponent})
 @standards{ISO, math.h}
+@standardsx{ldexpfN, TS 18661-3:2015, math.h}
+@standardsx{ldexpfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the result of multiplying the floating-point
 number @var{value} by 2 raised to the power @var{exponent}.  (It can
@@ -1330,6 +1354,8 @@ For example, @code{ldexp (0.8, 4)} returns @code{12.8}.
 The following functions, which come from BSD, provide facilities
 equivalent to those of @code{ldexp} and @code{frexp}.  See also the
 @w{ISO C} function @code{logb} which originally also appeared in BSD.
+The @code{_Float@var{N}} and @code{_Float@var{N}} variants of the
+following functions come from TS 18661-3:2015.
 
 @deftypefun double scalb (double @var{value}, double @var{exponent})
 @deftypefunx float scalbf (float @var{value}, float @var{exponent})
@@ -1342,7 +1368,11 @@ The @code{scalb} function is the BSD name for @code{ldexp}.
 @deftypefun double scalbn (double @var{x}, int @var{n})
 @deftypefunx float scalbnf (float @var{x}, int @var{n})
 @deftypefunx {long double} scalbnl (long double @var{x}, int @var{n})
+@deftypefunx _FloatN scalbnfN (_Float@var{N} @var{x}, int @var{n})
+@deftypefunx _FloatNx scalbnfNx (_Float@var{N}x @var{x}, int @var{n})
 @standards{BSD, math.h}
+@standardsx{scalbnfN, TS 18661-3:2015, math.h}
+@standardsx{scalbnfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{scalbn} is identical to @code{scalb}, except that the exponent
 @var{n} is an @code{int} instead of a floating-point number.
@@ -1351,7 +1381,11 @@ The @code{scalb} function is the BSD name for @code{ldexp}.
 @deftypefun double scalbln (double @var{x}, long int @var{n})
 @deftypefunx float scalblnf (float @var{x}, long int @var{n})
 @deftypefunx {long double} scalblnl (long double @var{x}, long int @var{n})
+@deftypefunx _FloatN scalblnfN (_Float@var{N} @var{x}, long int @var{n})
+@deftypefunx _FloatNx scalblnfNx (_Float@var{N}x @var{x}, long int @var{n})
 @standards{BSD, math.h}
+@standardsx{scalblnfN, TS 18661-3:2015, math.h}
+@standardsx{scalblnfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{scalbln} is identical to @code{scalb}, except that the exponent
 @var{n} is a @code{long int} instead of a floating-point number.
@@ -1416,7 +1450,11 @@ Round to nearest, ties round to even.
 @deftypefun double ceil (double @var{x})
 @deftypefunx float ceilf (float @var{x})
 @deftypefunx {long double} ceill (long double @var{x})
+@deftypefunx _FloatN ceilfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx ceilfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{ceilfN, TS 18661-3:2015, math.h}
+@standardsx{ceilfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions round @var{x} upwards to the nearest integer,
 returning that value as a @code{double}.  Thus, @code{ceil (1.5)}
@@ -1426,7 +1464,11 @@ is @code{2.0}.
 @deftypefun double floor (double @var{x})
 @deftypefunx float floorf (float @var{x})
 @deftypefunx {long double} floorl (long double @var{x})
+@deftypefunx _FloatN floorfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx floorfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{floorfN, TS 18661-3:2015, math.h}
+@standardsx{floorfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions round @var{x} downwards to the nearest
 integer, returning that value as a @code{double}.  Thus, @code{floor
@@ -1436,7 +1478,11 @@ integer, returning that value as a @code{double}.  Thus, @code{floor
 @deftypefun double trunc (double @var{x})
 @deftypefunx float truncf (float @var{x})
 @deftypefunx {long double} truncl (long double @var{x})
+@deftypefunx _FloatN truncfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx truncfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{truncfN, TS 18661-3:2015, math.h}
+@standardsx{truncfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{trunc} functions round @var{x} towards zero to the nearest
 integer (returned in floating-point format).  Thus, @code{trunc (1.5)}
@@ -1446,7 +1492,11 @@ is @code{1.0} and @code{trunc (-1.5)} is @code{-1.0}.
 @deftypefun double rint (double @var{x})
 @deftypefunx float rintf (float @var{x})
 @deftypefunx {long double} rintl (long double @var{x})
+@deftypefunx _FloatN rintfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx rintfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{rintfN, TS 18661-3:2015, math.h}
+@standardsx{rintfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions round @var{x} to an integer value according to the
 current rounding mode.  @xref{Floating Point Parameters}, for
@@ -1462,7 +1512,11 @@ inexact exception.
 @deftypefun double nearbyint (double @var{x})
 @deftypefunx float nearbyintf (float @var{x})
 @deftypefunx {long double} nearbyintl (long double @var{x})
+@deftypefunx _FloatN nearbyintfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx nearbyintfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{nearbyintfN, TS 18661-3:2015, math.h}
+@standardsx{nearbyintfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the same value as the @code{rint} functions, but
 do not raise the inexact exception if @var{x} is not an integer.
@@ -1471,7 +1525,11 @@ do not raise the inexact exception if @var{x} is not an integer.
 @deftypefun double round (double @var{x})
 @deftypefunx float roundf (float @var{x})
 @deftypefunx {long double} roundl (long double @var{x})
+@deftypefunx _FloatN roundfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx roundfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{roundfN, TS 18661-3:2015, math.h}
+@standardsx{roundfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are similar to @code{rint}, but they round halfway
 cases away from zero instead of to the nearest integer (or other
@@ -1481,16 +1539,25 @@ current rounding mode).
 @deftypefun double roundeven (double @var{x})
 @deftypefunx float roundevenf (float @var{x})
 @deftypefunx {long double} roundevenl (long double @var{x})
+@deftypefunx _FloatN roundevenfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx roundevenfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{roundevenfN, TS 18661-3:2015, math.h}
+@standardsx{roundevenfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
-These functions, from TS 18661-1:2014, are similar to @code{round},
-but they round halfway cases to even instead of away from zero.
+These functions, from TS 18661-1:2014 and TS 18661-3:2015, are similar
+to @code{round}, but they round halfway cases to even instead of away
+from zero.
 @end deftypefun
 
 @deftypefun {long int} lrint (double @var{x})
 @deftypefunx {long int} lrintf (float @var{x})
 @deftypefunx {long int} lrintl (long double @var{x})
+@deftypefunx {long int} lrintfN (_Float@var{N} @var{x})
+@deftypefunx {long int} lrintfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{lrintfN, TS 18661-3:2015, math.h}
+@standardsx{lrintfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are just like @code{rint}, but they return a
 @code{long int} instead of a floating-point number.
@@ -1499,7 +1566,11 @@ These functions are just like @code{rint}, but they return a
 @deftypefun {long long int} llrint (double @var{x})
 @deftypefunx {long long int} llrintf (float @var{x})
 @deftypefunx {long long int} llrintl (long double @var{x})
+@deftypefunx {long long int} llrintfN (_Float@var{N} @var{x})
+@deftypefunx {long long int} llrintfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{llrintfN, TS 18661-3:2015, math.h}
+@standardsx{llrintfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are just like @code{rint}, but they return a
 @code{long long int} instead of a floating-point number.
@@ -1508,7 +1579,11 @@ These functions are just like @code{rint}, but they return a
 @deftypefun {long int} lround (double @var{x})
 @deftypefunx {long int} lroundf (float @var{x})
 @deftypefunx {long int} lroundl (long double @var{x})
+@deftypefunx {long int} lroundfN (_Float@var{N} @var{x})
+@deftypefunx {long int} lroundfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{lroundfN, TS 18661-3:2015, math.h}
+@standardsx{lroundfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are just like @code{round}, but they return a
 @code{long int} instead of a floating-point number.
@@ -1517,7 +1592,11 @@ These functions are just like @code{round}, but they return a
 @deftypefun {long long int} llround (double @var{x})
 @deftypefunx {long long int} llroundf (float @var{x})
 @deftypefunx {long long int} llroundl (long double @var{x})
+@deftypefunx {long long int} llroundfN (_Float@var{N} @var{x})
+@deftypefunx {long long int} llroundfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{llroundfN, TS 18661-3:2015, math.h}
+@standardsx{llroundfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are just like @code{round}, but they return a
 @code{long long int} instead of a floating-point number.
@@ -1526,27 +1605,43 @@ These functions are just like @code{round}, but they return a
 @deftypefun intmax_t fromfp (double @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx intmax_t fromfpf (float @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx intmax_t fromfpl (long double @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx intmax_t fromfpfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx intmax_t fromfpfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx uintmax_t ufromfp (double @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx uintmax_t ufromfpf (float @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx uintmax_t ufromfpl (long double @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx uintmax_t ufromfpfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx uintmax_t ufromfpfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx intmax_t fromfpx (double @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx intmax_t fromfpxf (float @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx intmax_t fromfpxl (long double @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx intmax_t fromfpxfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx intmax_t fromfpxfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx uintmax_t ufromfpx (double @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx uintmax_t ufromfpxf (float @var{x}, int @var{round}, unsigned int @var{width})
 @deftypefunx uintmax_t ufromfpxl (long double @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx uintmax_t ufromfpxfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
+@deftypefunx uintmax_t ufromfpxfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
 @standards{ISO, math.h}
-@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
-These functions, from TS 18661-1:2014, convert a floating-point number
-to an integer according to the rounding direction @var{round} (one of
-the @code{FP_INT_*} macros).  If the integer is outside the range of a
-signed or unsigned (depending on the return type of the function) type
-of width @var{width} bits (or outside the range of the return type, if
-@var{width} is larger), or if @var{x} is infinite or NaN, or if
-@var{width} is zero, a domain error occurs and an unspecified value is
-returned.  The functions with an @samp{x} in their names raise the
-inexact exception when a domain error does not occur and the argument
-is not an integer; the other functions do not raise the inexact
+@standardsx{fromfpfN, TS 18661-3:2015, math.h}
+@standardsx{fromfpfNx, TS 18661-3:2015, math.h}
+@standardsx{ufromfpfN, TS 18661-3:2015, math.h}
+@standardsx{ufromfpfNx, TS 18661-3:2015, math.h}
+@standardsx{fromfpxfN, TS 18661-3:2015, math.h}
+@standardsx{fromfpxfNx, TS 18661-3:2015, math.h}
+@standardsx{ufromfpxfN, TS 18661-3:2015, math.h}
+@standardsx{ufromfpxfNx, TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions, from TS 18661-1:2014 and TS 18661-3:2015, convert a
+floating-point number to an integer according to the rounding direction
+@var{round} (one of the @code{FP_INT_*} macros).  If the integer is
+outside the range of a signed or unsigned (depending on the return type
+of the function) type of width @var{width} bits (or outside the range of
+the return type, if @var{width} is larger), or if @var{x} is infinite or
+NaN, or if @var{width} is zero, a domain error occurs and an unspecified
+value is returned.  The functions with an @samp{x} in their names raise
+the inexact exception when a domain error does not occur and the
+argument is not an integer; the other functions do not raise the inexact
 exception.
 @end deftypefun
 
@@ -1554,7 +1649,11 @@ exception.
 @deftypefun double modf (double @var{value}, double *@var{integer-part})
 @deftypefunx float modff (float @var{value}, float *@var{integer-part})
 @deftypefunx {long double} modfl (long double @var{value}, long double *@var{integer-part})
+@deftypefunx _FloatN modffN (_Float@var{N} @var{value}, _Float@var{N} *@var{integer-part})
+@deftypefunx _FloatNx modffNx (_Float@var{N}x @var{value}, _Float@var{N}x *@var{integer-part})
 @standards{ISO, math.h}
+@standardsx{modffN, TS 18661-3:2015, math.h}
+@standardsx{modffNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions break the argument @var{value} into an integer part and a
 fractional part (between @code{-1} and @code{1}, exclusive).  Their sum
@@ -1576,7 +1675,11 @@ suits your problem.
 @deftypefun double fmod (double @var{numerator}, double @var{denominator})
 @deftypefunx float fmodf (float @var{numerator}, float @var{denominator})
 @deftypefunx {long double} fmodl (long double @var{numerator}, long double @var{denominator})
+@deftypefunx _FloatN fmodfN (_Float@var{N} @var{numerator}, _Float@var{N} @var{denominator})
+@deftypefunx _FloatNx fmodfNx (_Float@var{N}x @var{numerator}, _Float@var{N}x @var{denominator})
 @standards{ISO, math.h}
+@standardsx{fmodfN, TS 18661-3:2015, math.h}
+@standardsx{fmodfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the remainder from the division of
 @var{numerator} by @var{denominator}.  Specifically, the return value is
@@ -1594,7 +1697,11 @@ If @var{denominator} is zero, @code{fmod} signals a domain error.
 @deftypefun double remainder (double @var{numerator}, double @var{denominator})
 @deftypefunx float remainderf (float @var{numerator}, float @var{denominator})
 @deftypefunx {long double} remainderl (long double @var{numerator}, long double @var{denominator})
+@deftypefunx _FloatN remainderfN (_Float@var{N} @var{numerator}, _Float@var{N} @var{denominator})
+@deftypefunx _FloatNx remainderfNx (_Float@var{N}x @var{numerator}, _Float@var{N}x @var{denominator})
 @standards{ISO, math.h}
+@standardsx{remainderfN, TS 18661-3:2015, math.h}
+@standardsx{remainderfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are like @code{fmod} except that they round the
 internal quotient @var{n} to the nearest integer instead of towards zero
@@ -1630,7 +1737,11 @@ bits.
 @deftypefun double copysign (double @var{x}, double @var{y})
 @deftypefunx float copysignf (float @var{x}, float @var{y})
 @deftypefunx {long double} copysignl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN copysignfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx copysignfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{copysignfN, TS 18661-3:2015, math.h}
+@standardsx{copysignfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return @var{x} but with the sign of @var{y}.  They work
 even if @var{x} or @var{y} are NaN or zero.  Both of these can carry a
@@ -1659,7 +1770,11 @@ false, but @code{signbit (-0.0)} will return a nonzero value.
 @deftypefun double nextafter (double @var{x}, double @var{y})
 @deftypefunx float nextafterf (float @var{x}, float @var{y})
 @deftypefunx {long double} nextafterl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN nextafterfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx nextafterfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{nextafterfN, TS 18661-3:2015, math.h}
+@standardsx{nextafterfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{nextafter} function returns the next representable neighbor of
 @var{x} in the direction towards @var{y}.  The size of the step between
@@ -1688,7 +1803,11 @@ double}.
 @deftypefun double nextup (double @var{x})
 @deftypefunx float nextupf (float @var{x})
 @deftypefunx {long double} nextupl (long double @var{x})
+@deftypefunx _FloatN nextupfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx nextupfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{nextupfN, TS 18661-3:2015, math.h}
+@standardsx{nextupfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{nextup} function returns the next representable neighbor of @var{x}
 in the direction of positive infinity.  If @var{x} is the smallest negative
@@ -1696,14 +1815,18 @@ subnormal number in the type of @var{x} the function returns @code{-0}.  If
 @math{@var{x} = @code{0}} the function returns the smallest positive subnormal
 number in the type of @var{x}.  If @var{x} is NaN, NaN is returned.
 If @var{x} is @math{+@infinity{}}, @math{+@infinity{}} is returned.
-@code{nextup} is from TS 18661-1:2014.
+@code{nextup} is from TS 18661-1:2014 and TS 18661-3:2015.
 @code{nextup} never raises an exception except for signaling NaNs.
 @end deftypefun
 
 @deftypefun double nextdown (double @var{x})
 @deftypefunx float nextdownf (float @var{x})
 @deftypefunx {long double} nextdownl (long double @var{x})
+@deftypefunx _FloatN nextdownfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx nextdownfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{nextdownfN, TS 18661-3:2015, math.h}
+@standardsx{nextdownfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{nextdown} function returns the next representable neighbor of @var{x}
 in the direction of negative infinity.  If @var{x} is the smallest positive
@@ -1711,7 +1834,7 @@ subnormal number in the type of @var{x} the function returns @code{+0}.  If
 @math{@var{x} = @code{0}} the function returns the smallest negative subnormal
 number in the type of @var{x}.  If @var{x} is NaN, NaN is returned.
 If @var{x} is @math{-@infinity{}}, @math{-@infinity{}} is returned.
-@code{nextdown} is from TS 18661-1:2014.
+@code{nextdown} is from TS 18661-1:2014 and TS 18661-3:2015.
 @code{nextdown} never raises an exception except for signaling NaNs.
 @end deftypefun
 
@@ -1719,7 +1842,11 @@ If @var{x} is @math{-@infinity{}}, @math{-@infinity{}} is returned.
 @deftypefun double nan (const char *@var{tagp})
 @deftypefunx float nanf (const char *@var{tagp})
 @deftypefunx {long double} nanl (const char *@var{tagp})
+@deftypefunx _FloatN nanfN (const char *@var{tagp})
+@deftypefunx _FloatNx nanfNx (const char *@var{tagp})
 @standards{ISO, math.h}
+@standardsx{nanfN, TS 18661-3:2015, math.h}
+@standardsx{nanfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{@mtslocale{}}@assafe{}@acsafe{}}
 @c The unsafe-but-ruled-safe locale use comes from strtod.
 The @code{nan} function returns a representation of NaN, provided that
@@ -1735,13 +1862,17 @@ selects one.  On other systems it may do nothing.
 @deftypefun int canonicalize (double *@var{cx}, const double *@var{x})
 @deftypefunx int canonicalizef (float *@var{cx}, const float *@var{x})
 @deftypefunx int canonicalizel (long double *@var{cx}, const long double *@var{x})
+@deftypefunx int canonicalizefN (_Float@var{N} *@var{cx}, const _Float@var{N} *@var{x})
+@deftypefunx int canonicalizefNx (_Float@var{N}x *@var{cx}, const _Float@var{N}x *@var{x})
 @standards{ISO, math.h}
+@standardsx{canonicalizefN, TS 18661-3:2015, math.h}
+@standardsx{canonicalizefNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 In some floating-point formats, some values have canonical (preferred)
 and noncanonical encodings (for IEEE interchange binary formats, all
 encodings are canonical).  These functions, defined by TS
-18661-1:2014, attempt to produce a canonical version of the
-floating-point value pointed to by @var{x}; if that value is a
+18661-1:2014 and TS 18661-3:2015, attempt to produce a canonical version
+of the floating-point value pointed to by @var{x}; if that value is a
 signaling NaN, they raise the invalid exception and produce a quiet
 NaN.  If a canonical value is produced, it is stored in the object
 pointed to by @var{cx}, and these functions return zero.  Otherwise
@@ -1760,42 +1891,56 @@ produced as output.
 @deftypefun double getpayload (const double *@var{x})
 @deftypefunx float getpayloadf (const float *@var{x})
 @deftypefunx {long double} getpayloadl (const long double *@var{x})
+@deftypefunx _FloatN getpayloadfN (const _Float@var{N} *@var{x})
+@deftypefunx _FloatNx getpayloadfNx (const _Float@var{N}x *@var{x})
 @standards{ISO, math.h}
+@standardsx{getpayloadfN, TS 18661-3:2015, math.h}
+@standardsx{getpayloadfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 IEEE 754 defines the @dfn{payload} of a NaN to be an integer value
 encoded in the representation of the NaN.  Payloads are typically
 propagated from NaN inputs to the result of a floating-point
-operation.  These functions, defined by TS 18661-1:2014, return the
-payload of the NaN pointed to by @var{x} (returned as a positive
-integer, or positive zero, represented as a floating-point number); if
-@var{x} is not a NaN, they return an unspecified value.  They raise no
-floating-point exceptions even for signaling NaNs.
+operation.  These functions, defined by TS 18661-1:2014 and TS
+18661-3:2015, return the payload of the NaN pointed to by @var{x}
+(returned as a positive integer, or positive zero, represented as a
+floating-point number); if @var{x} is not a NaN, they return an
+unspecified value.  They raise no floating-point exceptions even for
+signaling NaNs.
 @end deftypefun
 
 @deftypefun int setpayload (double *@var{x}, double @var{payload})
 @deftypefunx int setpayloadf (float *@var{x}, float @var{payload})
 @deftypefunx int setpayloadl (long double *@var{x}, long double @var{payload})
+@deftypefunx int setpayloadfN (_Float@var{N} *@var{x}, _Float@var{N} @var{payload})
+@deftypefunx int setpayloadfNx (_Float@var{N}x *@var{x}, _Float@var{N}x @var{payload})
 @standards{ISO, math.h}
+@standardsx{setpayloadfN, TS 18661-3:2015, math.h}
+@standardsx{setpayloadfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
-These functions, defined by TS 18661-1:2014, set the object pointed to
-by @var{x} to a quiet NaN with payload @var{payload} and a zero sign
-bit and return zero.  If @var{payload} is not a positive-signed
-integer that is a valid payload for a quiet NaN of the given type, the
-object pointed to by @var{x} is set to positive zero and a nonzero
-value is returned.  They raise no floating-point exceptions.
+These functions, defined by TS 18661-1:2014 and TS 18661-3:2015, set the
+object pointed to by @var{x} to a quiet NaN with payload @var{payload}
+and a zero sign bit and return zero.  If @var{payload} is not a
+positive-signed integer that is a valid payload for a quiet NaN of the
+given type, the object pointed to by @var{x} is set to positive zero and
+a nonzero value is returned.  They raise no floating-point exceptions.
 @end deftypefun
 
 @deftypefun int setpayloadsig (double *@var{x}, double @var{payload})
 @deftypefunx int setpayloadsigf (float *@var{x}, float @var{payload})
 @deftypefunx int setpayloadsigl (long double *@var{x}, long double @var{payload})
+@deftypefunx int setpayloadsigfN (_Float@var{N} *@var{x}, _Float@var{N} @var{payload})
+@deftypefunx int setpayloadsigfNx (_Float@var{N}x *@var{x}, _Float@var{N}x @var{payload})
 @standards{ISO, math.h}
+@standardsx{setpayloadsigfN, TS 18661-3:2015, math.h}
+@standardsx{setpayloadsigfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
-These functions, defined by TS 18661-1:2014, set the object pointed to
-by @var{x} to a signaling NaN with payload @var{payload} and a zero
-sign bit and return zero.  If @var{payload} is not a positive-signed
-integer that is a valid payload for a signaling NaN of the given type,
-the object pointed to by @var{x} is set to positive zero and a nonzero
-value is returned.  They raise no floating-point exceptions.
+These functions, defined by TS 18661-1:2014 and TS 18661-3:2015, set the
+object pointed to by @var{x} to a signaling NaN with payload
+@var{payload} and a zero sign bit and return zero.  If @var{payload} is
+not a positive-signed integer that is a valid payload for a signaling
+NaN of the given type, the object pointed to by @var{x} is set to
+positive zero and a nonzero value is returned.  They raise no
+floating-point exceptions.
 @end deftypefun
 
 @node FP Comparison Functions
@@ -1886,7 +2031,11 @@ NaN.
 @deftypefun int totalorder (double @var{x}, double @var{y})
 @deftypefunx int totalorderf (float @var{x}, float @var{y})
 @deftypefunx int totalorderl (long double @var{x}, long double @var{y})
+@deftypefunx int totalorderfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx int totalorderfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{TS 18661-1:2014, math.h}
+@standardsx{totalorderfN, TS 18661-3:2015, math.h}
+@standardsx{totalorderfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions determine whether the total order relationship,
 defined in IEEE 754-2008, is true for @var{x} and @var{y}, returning
@@ -1905,7 +2054,11 @@ payload.
 @deftypefun int totalordermag (double @var{x}, double @var{y})
 @deftypefunx int totalordermagf (float @var{x}, float @var{y})
 @deftypefunx int totalordermagl (long double @var{x}, long double @var{y})
+@deftypefunx int totalordermagfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx int totalordermagfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{TS 18661-1:2014, math.h}
+@standardsx{totalordermagfN, TS 18661-3:2015, math.h}
+@standardsx{totalordermagfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions determine whether the total order relationship,
 defined in IEEE 754-2008, is true for the absolute values of @var{x}
@@ -1936,7 +2089,11 @@ perform these operations faster than the equivalent C code.
 @deftypefun double fmin (double @var{x}, double @var{y})
 @deftypefunx float fminf (float @var{x}, float @var{y})
 @deftypefunx {long double} fminl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN fminfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx fminfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{fminfN, TS 18661-3:2015, math.h}
+@standardsx{fminfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{fmin} function returns the lesser of the two values @var{x}
 and @var{y}.  It is similar to the expression
@@ -1952,7 +2109,11 @@ are NaN, NaN is returned.
 @deftypefun double fmax (double @var{x}, double @var{y})
 @deftypefunx float fmaxf (float @var{x}, float @var{y})
 @deftypefunx {long double} fmaxl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN fmaxfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx fmaxfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{fmaxfN, TS 18661-3:2015, math.h}
+@standardsx{fmaxfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{fmax} function returns the greater of the two values @var{x}
 and @var{y}.
@@ -1964,18 +2125,26 @@ are NaN, NaN is returned.
 @deftypefun double fminmag (double @var{x}, double @var{y})
 @deftypefunx float fminmagf (float @var{x}, float @var{y})
 @deftypefunx {long double} fminmagl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN fminmagfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx fminmagfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{fminmagfN, TS 18661-3:2015, math.h}
+@standardsx{fminmagfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
-These functions, from TS 18661-1:2014, return whichever of the two
-values @var{x} and @var{y} has the smaller absolute value.  If both
-have the same absolute value, or either is NaN, they behave the same
-as the @code{fmin} functions.
+These functions, from TS 18661-1:2014 and TS 18661-3:2015, return
+whichever of the two values @var{x} and @var{y} has the smaller absolute
+value.  If both have the same absolute value, or either is NaN, they
+behave the same as the @code{fmin} functions.
 @end deftypefun
 
 @deftypefun double fmaxmag (double @var{x}, double @var{y})
 @deftypefunx float fmaxmagf (float @var{x}, float @var{y})
 @deftypefunx {long double} fmaxmagl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN fmaxmagfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx fmaxmagfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{fmaxmagfN, TS 18661-3:2015, math.h}
+@standardsx{fmaxmagfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions, from TS 18661-1:2014, return whichever of the two
 values @var{x} and @var{y} has the greater absolute value.  If both
@@ -1986,7 +2155,11 @@ as the @code{fmax} functions.
 @deftypefun double fdim (double @var{x}, double @var{y})
 @deftypefunx float fdimf (float @var{x}, float @var{y})
 @deftypefunx {long double} fdiml (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN fdimfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx fdimfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{fdimfN, TS 18661-3:2015, math.h}
+@standardsx{fdimfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{fdim} function returns the positive difference between
 @var{x} and @var{y}.  The positive difference is @math{@var{x} -
@@ -1998,7 +2171,11 @@ If @var{x}, @var{y}, or both are NaN, NaN is returned.
 @deftypefun double fma (double @var{x}, double @var{y}, double @var{z})
 @deftypefunx float fmaf (float @var{x}, float @var{y}, float @var{z})
 @deftypefunx {long double} fmal (long double @var{x}, long double @var{y}, long double @var{z})
+@deftypefunx _FloatN fmafN (_Float@var{N} @var{x}, _Float@var{N} @var{y}, _Float@var{N} @var{z})
+@deftypefunx _FloatNx fmafNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y}, _Float@var{N}x @var{z})
 @standards{ISO, math.h}
+@standardsx{fmafN, TS 18661-3:2015, math.h}
+@standardsx{fmafNx, TS 18661-3:2015, math.h}
 @cindex butterfly
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 The @code{fma} function performs floating-point multiply-add.  This is
@@ -2033,6 +2210,11 @@ if @file{complex.h} has been included.  There are three complex types,
 corresponding to the three real types:  @code{float complex},
 @code{double complex}, and @code{long double complex}.
 
+Likewise, on machines that have support for @code{_Float@var{N}} or
+@code{_Float@var{N}x} enabled, the complex types @code{_Float@var{N}
+complex} and @code{_Float@var{N}x complex} are also available if
+@file{complex.h} has been included; @pxref{Mathematics}.
+
 To construct complex numbers you need a way to indicate the imaginary
 part of a number.  There is no standard notation for an imaginary
 floating point constant.  Instead, @file{complex.h} defines two macros
@@ -2126,7 +2308,11 @@ available in three variants, one for each of the three complex types.
 @deftypefun double creal (complex double @var{z})
 @deftypefunx float crealf (complex float @var{z})
 @deftypefunx {long double} creall (complex long double @var{z})
+@deftypefunx _FloatN crealfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx crealfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{crealfN, TS 18661-3:2015, complex.h}
+@standardsx{crealfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the real part of the complex number @var{z}.
 @end deftypefun
@@ -2134,7 +2320,11 @@ These functions return the real part of the complex number @var{z}.
 @deftypefun double cimag (complex double @var{z})
 @deftypefunx float cimagf (complex float @var{z})
 @deftypefunx {long double} cimagl (complex long double @var{z})
+@deftypefunx _FloatN cimagfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx cimagfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cimagfN, TS 18661-3:2015, complex.h}
+@standardsx{cimagfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the imaginary part of the complex number @var{z}.
 @end deftypefun
@@ -2142,7 +2332,11 @@ These functions return the imaginary part of the complex number @var{z}.
 @deftypefun {complex double} conj (complex double @var{z})
 @deftypefunx {complex float} conjf (complex float @var{z})
 @deftypefunx {complex long double} conjl (complex long double @var{z})
+@deftypefunx {complex _FloatN} conjfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} conjfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{conjfN, TS 18661-3:2015, complex.h}
+@standardsx{conjfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the conjugate value of the complex number
 @var{z}.  The conjugate of a complex number has the same real part and a
@@ -2152,7 +2346,11 @@ negated imaginary part.  In other words, @samp{conj(a + bi) = a + -bi}.
 @deftypefun double carg (complex double @var{z})
 @deftypefunx float cargf (complex float @var{z})
 @deftypefunx {long double} cargl (complex long double @var{z})
+@deftypefunx _FloatN cargfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx cargfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cargfN, TS 18661-3:2015, complex.h}
+@standardsx{cargfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the argument of the complex number @var{z}.
 The argument of a complex number is the angle in the complex plane
@@ -2166,7 +2364,11 @@ number.  This angle is measured in the usual fashion and ranges from
 @deftypefun {complex double} cproj (complex double @var{z})
 @deftypefunx {complex float} cprojf (complex float @var{z})
 @deftypefunx {complex long double} cprojl (complex long double @var{z})
+@deftypefunx {complex _FloatN} cprojfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cprojfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cprojfN, TS 18661-3:2015, complex.h}
+@standardsx{cprojfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the projection of the complex value @var{z} onto
 the Riemann sphere.  Values with an infinite imaginary part are projected
diff --git a/manual/math.texi b/manual/math.texi
index 912e740..5bd3341 100644
--- a/manual/math.texi
+++ b/manual/math.texi
@@ -59,7 +59,11 @@ On some machines, @theglibc{} also provides @code{_Float@var{N}} and
 are not machine-dependent.  When such a type, such as @code{_Float128},
 is supported by @theglibc{}, extra variants for most of the mathematical
 functions provided for @code{double}, @code{float}, and @code{long
-double} are also provided for the supported type.
+double} are also provided for the supported type.  Throughout this
+manual, the @code{_Float@var{N}} and @code{_Float@var{N}x} variants of
+these functions are described along with the @code{double},
+@code{float}, and @code{long double} variants and they come from
+@w{ISO/IEC TS 18661-3}, unless explicitly stated otherwise.
 
 Currently, support for @code{_Float@var{N}} or @code{_Float@var{N}x}
 types is not provided for any machine.
@@ -128,6 +132,13 @@ also defines these constants with type @code{long double}.  The
 names: @code{M_El}, @code{M_PIl}, and so forth.  These are only
 available if @code{_GNU_SOURCE} is defined.
 
+Likewise, @theglibc{} also defines these constants with the types
+@code{_Float@var{N}} and @code{_Float@var{N}x} for the machines that
+have support for such types enabled (@pxref{Mathematics}) and if
+@code{_GNU_SOURCE} is defined.  When available, the macros names are
+appended with @samp{f@var{N}} or @samp{f@var{N}x}, such as @samp{f128}
+for the type @code{_Float128}.
+
 @vindex PI
 @emph{Note:} Some programs use a constant named @code{PI} which has the
 same value as @code{M_PI}.  This constant is not standard; it may have
@@ -162,7 +173,11 @@ You can also compute the value of pi with the expression @code{acos
 @deftypefun double sin (double @var{x})
 @deftypefunx float sinf (float @var{x})
 @deftypefunx {long double} sinl (long double @var{x})
+@deftypefunx _FloatN sinfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx sinfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{sinfN, TS 18661-3:2015, math.h}
+@standardsx{sinfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the sine of @var{x}, where @var{x} is given in
 radians.  The return value is in the range @code{-1} to @code{1}.
@@ -171,7 +186,11 @@ radians.  The return value is in the range @code{-1} to @code{1}.
 @deftypefun double cos (double @var{x})
 @deftypefunx float cosf (float @var{x})
 @deftypefunx {long double} cosl (long double @var{x})
+@deftypefunx _FloatN cosfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx cosfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{cosfN, TS 18661-3:2015, math.h}
+@standardsx{cosfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the cosine of @var{x}, where @var{x} is given in
 radians.  The return value is in the range @code{-1} to @code{1}.
@@ -180,7 +199,11 @@ radians.  The return value is in the range @code{-1} to @code{1}.
 @deftypefun double tan (double @var{x})
 @deftypefunx float tanf (float @var{x})
 @deftypefunx {long double} tanl (long double @var{x})
+@deftypefunx _FloatN tanfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx tanfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{tanfN, TS 18661-3:2015, math.h}
+@standardsx{tanfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the tangent of @var{x}, where @var{x} is given in
 radians.
@@ -198,6 +221,8 @@ function to do that.
 @deftypefun void sincos (double @var{x}, double *@var{sinx}, double *@var{cosx})
 @deftypefunx void sincosf (float @var{x}, float *@var{sinx}, float *@var{cosx})
 @deftypefunx void sincosl (long double @var{x}, long double *@var{sinx}, long double *@var{cosx})
+@deftypefunx _FloatN sincosfN (_Float@var{N} @var{x}, _Float@var{N} *@var{sinx}, _Float@var{N} *@var{cosx})
+@deftypefunx _FloatNx sincosfNx (_Float@var{N}x @var{x}, _Float@var{N}x *@var{sinx}, _Float@var{N}x *@var{cosx})
 @standards{GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the sine of @var{x} in @code{*@var{sinx}} and the
@@ -205,8 +230,9 @@ cosine of @var{x} in @code{*@var{cosx}}, where @var{x} is given in
 radians.  Both values, @code{*@var{sinx}} and @code{*@var{cosx}}, are in
 the range of @code{-1} to @code{1}.
 
-This function is a GNU extension.  Portable programs should be prepared
-to cope with its absence.
+All these functions, including the @code{_Float@var{N}} and
+@code{_Float@var{N}x} variants, are GNU extensions.  Portable programs
+should be prepared to cope with its absence.
 @end deftypefun
 
 @cindex complex trigonometric functions
@@ -222,7 +248,11 @@ the implementation.)
 @deftypefun {complex double} csin (complex double @var{z})
 @deftypefunx {complex float} csinf (complex float @var{z})
 @deftypefunx {complex long double} csinl (complex long double @var{z})
+@deftypefunx {complex _FloatN} csinfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} csinfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{csinfN, TS 18661-3:2015, complex.h}
+@standardsx{csinfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @c There are calls to nan* that could trigger @mtslocale if they didn't get
 @c empty strings.
@@ -240,7 +270,11 @@ $$\sin(z) = {1\over 2i} (e^{zi} - e^{-zi})$$
 @deftypefun {complex double} ccos (complex double @var{z})
 @deftypefunx {complex float} ccosf (complex float @var{z})
 @deftypefunx {complex long double} ccosl (complex long double @var{z})
+@deftypefunx {complex _FloatN} ccosfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ccosfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{ccosfN, TS 18661-3:2015, complex.h}
+@standardsx{ccosfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the complex cosine of @var{z}.
 The mathematical definition of the complex cosine is
@@ -256,7 +290,11 @@ $$\cos(z) = {1\over 2} (e^{zi} + e^{-zi})$$
 @deftypefun {complex double} ctan (complex double @var{z})
 @deftypefunx {complex float} ctanf (complex float @var{z})
 @deftypefunx {complex long double} ctanl (complex long double @var{z})
+@deftypefunx {complex _FloatN} ctanfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ctanfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{ctanfN, TS 18661-3:2015, complex.h}
+@standardsx{ctanfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the complex tangent of @var{z}.
 The mathematical definition of the complex tangent is
@@ -286,7 +324,11 @@ respectively.
 @deftypefun double asin (double @var{x})
 @deftypefunx float asinf (float @var{x})
 @deftypefunx {long double} asinl (long double @var{x})
+@deftypefunx _FloatN asinfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx asinfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{asinfN, TS 18661-3:2015, math.h}
+@standardsx{asinfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the arcsine of @var{x}---that is, the value whose
 sine is @var{x}.  The value is in units of radians.  Mathematically,
@@ -301,7 +343,11 @@ domain, @code{asin} signals a domain error.
 @deftypefun double acos (double @var{x})
 @deftypefunx float acosf (float @var{x})
 @deftypefunx {long double} acosl (long double @var{x})
+@deftypefunx _FloatN acosfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx acosfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{acosfN, TS 18661-3:2015, math.h}
+@standardsx{acosfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the arccosine of @var{x}---that is, the value
 whose cosine is @var{x}.  The value is in units of radians.
@@ -316,7 +362,11 @@ domain, @code{acos} signals a domain error.
 @deftypefun double atan (double @var{x})
 @deftypefunx float atanf (float @var{x})
 @deftypefunx {long double} atanl (long double @var{x})
+@deftypefunx _FloatN atanfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx atanfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{atanfN, TS 18661-3:2015, math.h}
+@standardsx{atanfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the arctangent of @var{x}---that is, the value
 whose tangent is @var{x}.  The value is in units of radians.
@@ -327,7 +377,11 @@ returned is the one between @code{-pi/2} and @code{pi/2} (inclusive).
 @deftypefun double atan2 (double @var{y}, double @var{x})
 @deftypefunx float atan2f (float @var{y}, float @var{x})
 @deftypefunx {long double} atan2l (long double @var{y}, long double @var{x})
+@deftypefunx _FloatN atan2fN (_Float@var{N} @var{y}, _Float@var{N} @var{x})
+@deftypefunx _FloatNx atan2fNx (_Float@var{N}x @var{y}, _Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{atan2fN, TS 18661-3:2015, math.h}
+@standardsx{atan2fNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 This function computes the arctangent of @var{y}/@var{x}, but the signs
 of both arguments are used to determine the quadrant of the result, and
@@ -351,7 +405,11 @@ If both @var{x} and @var{y} are zero, @code{atan2} returns zero.
 @deftypefun {complex double} casin (complex double @var{z})
 @deftypefunx {complex float} casinf (complex float @var{z})
 @deftypefunx {complex long double} casinl (complex long double @var{z})
+@deftypefunx {complex _FloatN} casinfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} casinfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{casinfN, TS 18661-3:2015, complex.h}
+@standardsx{casinfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the complex arcsine of @var{z}---that is, the
 value whose sine is @var{z}.  The value returned is in radians.
@@ -363,7 +421,11 @@ values of @var{z}.
 @deftypefun {complex double} cacos (complex double @var{z})
 @deftypefunx {complex float} cacosf (complex float @var{z})
 @deftypefunx {complex long double} cacosl (complex long double @var{z})
+@deftypefunx {complex _FloatN} cacosfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cacosfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cacosfN, TS 18661-3:2015, complex.h}
+@standardsx{cacosfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the complex arccosine of @var{z}---that is, the
 value whose cosine is @var{z}.  The value returned is in radians.
@@ -376,7 +438,11 @@ values of @var{z}.
 @deftypefun {complex double} catan (complex double @var{z})
 @deftypefunx {complex float} catanf (complex float @var{z})
 @deftypefunx {complex long double} catanl (complex long double @var{z})
+@deftypefunx {complex _FloatN} catanfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} catanfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{catanfN, TS 18661-3:2015, complex.h}
+@standardsx{catanfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the complex arctangent of @var{z}---that is,
 the value whose tangent is @var{z}.  The value is in units of radians.
@@ -392,7 +458,11 @@ the value whose tangent is @var{z}.  The value is in units of radians.
 @deftypefun double exp (double @var{x})
 @deftypefunx float expf (float @var{x})
 @deftypefunx {long double} expl (long double @var{x})
+@deftypefunx _FloatN expfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx expfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{expfN, TS 18661-3:2015, math.h}
+@standardsx{expfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute @code{e} (the base of natural logarithms) raised
 to the power @var{x}.
@@ -404,7 +474,11 @@ If the magnitude of the result is too large to be representable,
 @deftypefun double exp2 (double @var{x})
 @deftypefunx float exp2f (float @var{x})
 @deftypefunx {long double} exp2l (long double @var{x})
+@deftypefunx _FloatN exp2fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx exp2fNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{exp2fN, TS 18661-3:2015, math.h}
+@standardsx{exp2fNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute @code{2} raised to the power @var{x}.
 Mathematically, @code{exp2 (x)} is the same as @code{exp (x * log (2))}.
@@ -413,10 +487,14 @@ Mathematically, @code{exp2 (x)} is the same as @code{exp (x * log (2))}.
 @deftypefun double exp10 (double @var{x})
 @deftypefunx float exp10f (float @var{x})
 @deftypefunx {long double} exp10l (long double @var{x})
+@deftypefunx _FloatN exp10fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx exp10fNx (_Float@var{N}x @var{x})
 @deftypefunx double pow10 (double @var{x})
 @deftypefunx float pow10f (float @var{x})
 @deftypefunx {long double} pow10l (long double @var{x})
 @standards{ISO, math.h}
+@standardsx{exp10fN, GNU, math.h}
+@standardsx{exp10fNx, GNU, math.h}
 @standardsx{pow10, GNU, math.h}
 @standardsx{pow10f, GNU, math.h}
 @standardsx{pow10l, GNU, math.h}
@@ -424,16 +502,22 @@ Mathematically, @code{exp2 (x)} is the same as @code{exp (x * log (2))}.
 These functions compute @code{10} raised to the power @var{x}.
 Mathematically, @code{exp10 (x)} is the same as @code{exp (x * log (10))}.
 
-The @code{exp10} functions are from TS 18661-4:2015; the @code{pow10}
-names are GNU extensions.  The name @code{exp10} is
-preferred, since it is analogous to @code{exp} and @code{exp2}.
+The @code{exp10}, @code{exp10f}, and @code{exp10l} functions are from TS
+18661-4:2015; the @code{pow10} names are GNU extensions.  Likewise, the
+@code{exp10f@var{N}} and @code{exp10f@var{N}x} functions are GNU
+extensions. The name @code{exp10} is preferred, since it is analogous to
+@code{exp} and @code{exp2}.
 @end deftypefun
 
 
 @deftypefun double log (double @var{x})
 @deftypefunx float logf (float @var{x})
 @deftypefunx {long double} logl (long double @var{x})
+@deftypefunx _FloatN logfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx logfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{logfN, TS 18661-3:2015, math.h}
+@standardsx{logfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions compute the natural logarithm of @var{x}.  @code{exp (log
 (@var{x}))} equals @var{x}, exactly in mathematics and approximately in
@@ -447,7 +531,11 @@ it may signal overflow.
 @deftypefun double log10 (double @var{x})
 @deftypefunx float log10f (float @var{x})
 @deftypefunx {long double} log10l (long double @var{x})
+@deftypefunx _FloatN log10fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx log10fNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{log10fN, TS 18661-3:2015, math.h}
+@standardsx{log10fNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the base-10 logarithm of @var{x}.
 @code{log10 (@var{x})} equals @code{log (@var{x}) / log (10)}.
@@ -457,7 +545,11 @@ These functions return the base-10 logarithm of @var{x}.
 @deftypefun double log2 (double @var{x})
 @deftypefunx float log2f (float @var{x})
 @deftypefunx {long double} log2l (long double @var{x})
+@deftypefunx _FloatN log2fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx log2fNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{log2fN, TS 18661-3:2015, math.h}
+@standardsx{log2fNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the base-2 logarithm of @var{x}.
 @code{log2 (@var{x})} equals @code{log (@var{x}) / log (2)}.
@@ -466,7 +558,11 @@ These functions return the base-2 logarithm of @var{x}.
 @deftypefun double logb (double @var{x})
 @deftypefunx float logbf (float @var{x})
 @deftypefunx {long double} logbl (long double @var{x})
+@deftypefunx _FloatN logbfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx logbfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{logbfN, TS 18661-3:2015, math.h}
+@standardsx{logbfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions extract the exponent of @var{x} and return it as a
 floating-point value.  If @code{FLT_RADIX} is two, @code{logb} is equal
@@ -481,15 +577,25 @@ negative), @code{logb} returns @math{@infinity{}}.  If @var{x} is zero,
 @deftypefun int ilogb (double @var{x})
 @deftypefunx int ilogbf (float @var{x})
 @deftypefunx int ilogbl (long double @var{x})
+@deftypefunx int ilogbfN (_Float@var{N} @var{x})
+@deftypefunx int ilogbfNx (_Float@var{N}x @var{x})
 @deftypefunx {long int} llogb (double @var{x})
 @deftypefunx {long int} llogbf (float @var{x})
 @deftypefunx {long int} llogbl (long double @var{x})
+@deftypefunx {long int} llogbfN (_Float@var{N} @var{x})
+@deftypefunx {long int} llogbfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{ilogbfN, TS 18661-3:2015, math.h}
+@standardsx{ilogbfNx, TS 18661-3:2015, math.h}
+@standardsx{llogbfN, TS 18661-3:2015, math.h}
+@standardsx{llogbfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions are equivalent to the corresponding @code{logb}
 functions except that they return signed integer values.  The
-@code{ilogb} functions are from ISO C99; the @code{llogb} functions
-are from TS 18661-1:2014.
+@code{ilogb}, @code{ilogbf}, and @code{ilogbl} functions are from ISO
+C99; the @code{llogb}, @code{llogbf}, @code{llogbl} functions are from
+TS 18661-1:2014; the @code{ilogbfN}, @code{ilogbfNx}, @code{llogbfN},
+and @code{llogbfNx} functions are from TS 18661-3:2015.
 @end deftypefun
 
 @noindent
@@ -555,7 +661,11 @@ if (i == FP_ILOGB0 || i == FP_ILOGBNAN)
 @deftypefun double pow (double @var{base}, double @var{power})
 @deftypefunx float powf (float @var{base}, float @var{power})
 @deftypefunx {long double} powl (long double @var{base}, long double @var{power})
+@deftypefunx _FloatN powfN (_Float@var{N} @var{base}, _Float@var{N} @var{power})
+@deftypefunx _FloatNx powfNx (_Float@var{N}x @var{base}, _Float@var{N}x @var{power})
 @standards{ISO, math.h}
+@standardsx{powfN, TS 18661-3:2015, math.h}
+@standardsx{powfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These are general exponentiation functions, returning @var{base} raised
 to @var{power}.
@@ -570,7 +680,11 @@ underflow or overflow the destination type.
 @deftypefun double sqrt (double @var{x})
 @deftypefunx float sqrtf (float @var{x})
 @deftypefunx {long double} sqrtl (long double @var{x})
+@deftypefunx _FloatN sqrtfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx sqrtfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{sqrtfN, TS 18661-3:2015, math.h}
+@standardsx{sqrtfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the nonnegative square root of @var{x}.
 
@@ -582,7 +696,11 @@ Mathematically, it should return a complex number.
 @deftypefun double cbrt (double @var{x})
 @deftypefunx float cbrtf (float @var{x})
 @deftypefunx {long double} cbrtl (long double @var{x})
+@deftypefunx _FloatN cbrtfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx cbrtfNx (_Float@var{N}x @var{x})
 @standards{BSD, math.h}
+@standardsx{cbrtfN, TS 18661-3:2015, math.h}
+@standardsx{cbrtfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the cube root of @var{x}.  They cannot
 fail; every representable real value has a representable real cube root.
@@ -591,7 +709,11 @@ fail; every representable real value has a representable real cube root.
 @deftypefun double hypot (double @var{x}, double @var{y})
 @deftypefunx float hypotf (float @var{x}, float @var{y})
 @deftypefunx {long double} hypotl (long double @var{x}, long double @var{y})
+@deftypefunx _FloatN hypotfN (_Float@var{N} @var{x}, _Float@var{N} @var{y})
+@deftypefunx _FloatNx hypotfNx (_Float@var{N}x @var{x}, _Float@var{N}x @var{y})
 @standards{ISO, math.h}
+@standardsx{hypotfN, TS 18661-3:2015, math.h}
+@standardsx{hypotfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return @code{sqrt (@var{x}*@var{x} +
 @var{y}*@var{y})}.  This is the length of the hypotenuse of a right
@@ -604,7 +726,11 @@ much smaller.  See also the function @code{cabs} in @ref{Absolute Value}.
 @deftypefun double expm1 (double @var{x})
 @deftypefunx float expm1f (float @var{x})
 @deftypefunx {long double} expm1l (long double @var{x})
+@deftypefunx _FloatN expm1fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx expm1fNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{expm1fN, TS 18661-3:2015, math.h}
+@standardsx{expm1fNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return a value equivalent to @code{exp (@var{x}) - 1}.
 They are computed in a way that is accurate even if @var{x} is
@@ -615,7 +741,11 @@ to subtraction of two numbers that are nearly equal.
 @deftypefun double log1p (double @var{x})
 @deftypefunx float log1pf (float @var{x})
 @deftypefunx {long double} log1pl (long double @var{x})
+@deftypefunx _FloatN log1pfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx log1pfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{log1pfN, TS 18661-3:2015, math.h}
+@standardsx{log1pfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return a value equivalent to @w{@code{log (1 + @var{x})}}.
 They are computed in a way that is accurate even if @var{x} is
@@ -631,7 +761,11 @@ logarithm functions.
 @deftypefun {complex double} cexp (complex double @var{z})
 @deftypefunx {complex float} cexpf (complex float @var{z})
 @deftypefunx {complex long double} cexpl (complex long double @var{z})
+@deftypefunx {complex _FloatN} cexpfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cexpfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cexpfN, TS 18661-3:2015, complex.h}
+@standardsx{cexpfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return @code{e} (the base of natural
 logarithms) raised to the power of @var{z}.
@@ -648,7 +782,11 @@ $$\exp(z) = e^z = e^{{\rm Re}\,z} (\cos ({\rm Im}\,z) + i \sin ({\rm Im}\,z))$$
 @deftypefun {complex double} clog (complex double @var{z})
 @deftypefunx {complex float} clogf (complex float @var{z})
 @deftypefunx {complex long double} clogl (complex long double @var{z})
+@deftypefunx {complex _FloatN} clogfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} clogfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{clogfN, TS 18661-3:2015, complex.h}
+@standardsx{clogfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the natural logarithm of @var{z}.
 Mathematically, this corresponds to the value
@@ -670,6 +808,8 @@ or is very close to 0.  It is well-defined for all other values of
 @deftypefun {complex double} clog10 (complex double @var{z})
 @deftypefunx {complex float} clog10f (complex float @var{z})
 @deftypefunx {complex long double} clog10l (complex long double @var{z})
+@deftypefunx {complex _FloatN} clog10fN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} clog10fNx (complex _Float@var{N}x @var{z})
 @standards{GNU, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the base 10 logarithm of the complex value
@@ -682,13 +822,18 @@ These functions return the base 10 logarithm of the complex value
 $$\log_{10}(z) = \log_{10}|z| + i \arg z / \log (10)$$
 @end tex
 
-These functions are GNU extensions.
+All these functions, including the @code{_Float@var{N}} and
+@code{_Float@var{N}x} variants, are GNU extensions.
 @end deftypefun
 
 @deftypefun {complex double} csqrt (complex double @var{z})
 @deftypefunx {complex float} csqrtf (complex float @var{z})
 @deftypefunx {complex long double} csqrtl (complex long double @var{z})
+@deftypefunx {complex _FloatN} csqrtfN (_Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} csqrtfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{csqrtfN, TS 18661-3:2015, complex.h}
+@standardsx{csqrtfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the complex square root of the argument @var{z}.  Unlike
 the real-valued functions, they are defined for all values of @var{z}.
@@ -697,7 +842,11 @@ the real-valued functions, they are defined for all values of @var{z}.
 @deftypefun {complex double} cpow (complex double @var{base}, complex double @var{power})
 @deftypefunx {complex float} cpowf (complex float @var{base}, complex float @var{power})
 @deftypefunx {complex long double} cpowl (complex long double @var{base}, complex long double @var{power})
+@deftypefunx {complex _FloatN} cpowfN (complex _Float@var{N} @var{base}, complex _Float@var{N} @var{power})
+@deftypefunx {complex _FloatNx} cpowfNx (complex _Float@var{N}x @var{base}, complex _Float@var{N}x @var{power})
 @standards{ISO, complex.h}
+@standardsx{cpowfN, TS 18661-3:2015, complex.h}
+@standardsx{cpowfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return @var{base} raised to the power of
 @var{power}.  This is equivalent to @w{@code{cexp (y * clog (x))}}
@@ -713,7 +862,11 @@ see @ref{Exponents and Logarithms}.
 @deftypefun double sinh (double @var{x})
 @deftypefunx float sinhf (float @var{x})
 @deftypefunx {long double} sinhl (long double @var{x})
+@deftypefunx _FloatN sinhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx sinhfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{sinhfN, TS 18661-3:2015, math.h}
+@standardsx{sinhfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the hyperbolic sine of @var{x}, defined
 mathematically as @w{@code{(exp (@var{x}) - exp (-@var{x})) / 2}}.  They
@@ -723,7 +876,11 @@ may signal overflow if @var{x} is too large.
 @deftypefun double cosh (double @var{x})
 @deftypefunx float coshf (float @var{x})
 @deftypefunx {long double} coshl (long double @var{x})
+@deftypefunx _FloatN coshfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx coshfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{coshfN, TS 18661-3:2015, math.h}
+@standardsx{coshfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the hyperbolic cosine of @var{x},
 defined mathematically as @w{@code{(exp (@var{x}) + exp (-@var{x})) / 2}}.
@@ -733,7 +890,11 @@ They may signal overflow if @var{x} is too large.
 @deftypefun double tanh (double @var{x})
 @deftypefunx float tanhf (float @var{x})
 @deftypefunx {long double} tanhl (long double @var{x})
+@deftypefunx _FloatN tanhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx tanhfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{tanhfN, TS 18661-3:2015, math.h}
+@standardsx{tanhfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the hyperbolic tangent of @var{x},
 defined mathematically as @w{@code{sinh (@var{x}) / cosh (@var{x})}}.
@@ -748,7 +909,11 @@ complex arguments.
 @deftypefun {complex double} csinh (complex double @var{z})
 @deftypefunx {complex float} csinhf (complex float @var{z})
 @deftypefunx {complex long double} csinhl (complex long double @var{z})
+@deftypefunx {complex _FloatN} csinhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} csinhfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{csinhfN, TS 18661-3:2015, complex.h}
+@standardsx{csinhfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the complex hyperbolic sine of @var{z}, defined
 mathematically as @w{@code{(exp (@var{z}) - exp (-@var{z})) / 2}}.
@@ -757,7 +922,11 @@ mathematically as @w{@code{(exp (@var{z}) - exp (-@var{z})) / 2}}.
 @deftypefun {complex double} ccosh (complex double @var{z})
 @deftypefunx {complex float} ccoshf (complex float @var{z})
 @deftypefunx {complex long double} ccoshl (complex long double @var{z})
+@deftypefunx {complex _FloatN} ccoshfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ccoshfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{ccoshfN, TS 18661-3:2015, complex.h}
+@standardsx{ccoshfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the complex hyperbolic cosine of @var{z}, defined
 mathematically as @w{@code{(exp (@var{z}) + exp (-@var{z})) / 2}}.
@@ -766,7 +935,11 @@ mathematically as @w{@code{(exp (@var{z}) + exp (-@var{z})) / 2}}.
 @deftypefun {complex double} ctanh (complex double @var{z})
 @deftypefunx {complex float} ctanhf (complex float @var{z})
 @deftypefunx {complex long double} ctanhl (complex long double @var{z})
+@deftypefunx {complex _FloatN} ctanhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ctanhfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{ctanhfN, TS 18661-3:2015, complex.h}
+@standardsx{ctanhfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the complex hyperbolic tangent of @var{z},
 defined mathematically as @w{@code{csinh (@var{z}) / ccosh (@var{z})}}.
@@ -778,7 +951,11 @@ defined mathematically as @w{@code{csinh (@var{z}) / ccosh (@var{z})}}.
 @deftypefun double asinh (double @var{x})
 @deftypefunx float asinhf (float @var{x})
 @deftypefunx {long double} asinhl (long double @var{x})
+@deftypefunx _FloatN asinhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx asinhfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{asinhfN, TS 18661-3:2015, math.h}
+@standardsx{asinhfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the inverse hyperbolic sine of @var{x}---the
 value whose hyperbolic sine is @var{x}.
@@ -787,7 +964,11 @@ value whose hyperbolic sine is @var{x}.
 @deftypefun double acosh (double @var{x})
 @deftypefunx float acoshf (float @var{x})
 @deftypefunx {long double} acoshl (long double @var{x})
+@deftypefunx _FloatN acoshfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx acoshfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{acoshfN, TS 18661-3:2015, math.h}
+@standardsx{acoshfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the inverse hyperbolic cosine of @var{x}---the
 value whose hyperbolic cosine is @var{x}.  If @var{x} is less than
@@ -797,7 +978,11 @@ value whose hyperbolic cosine is @var{x}.  If @var{x} is less than
 @deftypefun double atanh (double @var{x})
 @deftypefunx float atanhf (float @var{x})
 @deftypefunx {long double} atanhl (long double @var{x})
+@deftypefunx _FloatN atanhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx atanhfNx (_Float@var{N}x @var{x})
 @standards{ISO, math.h}
+@standardsx{atanhfN, TS 18661-3:2015, math.h}
+@standardsx{atanhfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the inverse hyperbolic tangent of @var{x}---the
 value whose hyperbolic tangent is @var{x}.  If the absolute value of
@@ -810,7 +995,11 @@ if it is equal to 1, @code{atanh} returns infinity.
 @deftypefun {complex double} casinh (complex double @var{z})
 @deftypefunx {complex float} casinhf (complex float @var{z})
 @deftypefunx {complex long double} casinhl (complex long double @var{z})
+@deftypefunx {complex _FloatN} casinhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} casinhfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{casinhfN, TS 18661-3:2015, complex.h}
+@standardsx{casinhfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the inverse complex hyperbolic sine of
 @var{z}---the value whose complex hyperbolic sine is @var{z}.
@@ -819,7 +1008,11 @@ These functions return the inverse complex hyperbolic sine of
 @deftypefun {complex double} cacosh (complex double @var{z})
 @deftypefunx {complex float} cacoshf (complex float @var{z})
 @deftypefunx {complex long double} cacoshl (complex long double @var{z})
+@deftypefunx {complex _FloatN} cacoshfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cacoshfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{cacoshfN, TS 18661-3:2015, complex.h}
+@standardsx{cacoshfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the inverse complex hyperbolic cosine of
 @var{z}---the value whose complex hyperbolic cosine is @var{z}.  Unlike
@@ -829,7 +1022,11 @@ the real-valued functions, there are no restrictions on the value of @var{z}.
 @deftypefun {complex double} catanh (complex double @var{z})
 @deftypefunx {complex float} catanhf (complex float @var{z})
 @deftypefunx {complex long double} catanhl (complex long double @var{z})
+@deftypefunx {complex _FloatN} catanhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} catanhfNx (complex _Float@var{N}x @var{z})
 @standards{ISO, complex.h}
+@standardsx{catanhfN, TS 18661-3:2015, complex.h}
+@standardsx{catanhfNx, TS 18661-3:2015, complex.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 These functions return the inverse complex hyperbolic tangent of
 @var{z}---the value whose complex hyperbolic tangent is @var{z}.  Unlike
@@ -849,7 +1046,11 @@ useful.  Currently they only have real-valued versions.
 @deftypefun double erf (double @var{x})
 @deftypefunx float erff (float @var{x})
 @deftypefunx {long double} erfl (long double @var{x})
+@deftypefunx _FloatN erffN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx erffNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{erffN, TS 18661-3:2015, math.h}
+@standardsx{erffNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{erf} returns the error function of @var{x}.  The error
 function is defined as
@@ -866,7 +1067,11 @@ erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt
 @deftypefun double erfc (double @var{x})
 @deftypefunx float erfcf (float @var{x})
 @deftypefunx {long double} erfcl (long double @var{x})
+@deftypefunx _FloatN erfcfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx erfcfNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{erfcfN, TS 18661-3:2015, math.h}
+@standardsx{erfcfNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{erfc} returns @code{1.0 - erf(@var{x})}, but computed in a
 fashion that avoids round-off error when @var{x} is large.
@@ -875,7 +1080,11 @@ fashion that avoids round-off error when @var{x} is large.
 @deftypefun double lgamma (double @var{x})
 @deftypefunx float lgammaf (float @var{x})
 @deftypefunx {long double} lgammal (long double @var{x})
+@deftypefunx _FloatN lgammafN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx lgammafNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{lgammafN, TS 18661-3:2015, math.h}
+@standardsx{lgammafNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtunsafe{@mtasurace{:signgam}}@asunsafe{}@acsafe{}}
 @code{lgamma} returns the natural logarithm of the absolute value of
 the gamma function of @var{x}.  The gamma function is defined as
@@ -909,11 +1118,18 @@ singularity.
 @deftypefun double lgamma_r (double @var{x}, int *@var{signp})
 @deftypefunx float lgammaf_r (float @var{x}, int *@var{signp})
 @deftypefunx {long double} lgammal_r (long double @var{x}, int *@var{signp})
+@deftypefunx _FloatN lgammafN_r (_Float@var{N} @var{x}, int *@var{signp})
+@deftypefunx _FloatNx lgammafNx_r (_Float@var{N}x @var{x}, int *@var{signp})
 @standards{XPG, math.h}
+@standardsx{lgammafN_r, GNU, math.h}
+@standardsx{lgammafNx_r, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{lgamma_r} is just like @code{lgamma}, but it stores the sign of
 the intermediate result in the variable pointed to by @var{signp}
 instead of in the @var{signgam} global.  This means it is reentrant.
+
+The @code{lgammaf@var{N}_r} and @code{lgammaf@var{N}x_r} functions are
+GNU extensions.
 @end deftypefun
 
 @deftypefun double gamma (double @var{x})
@@ -930,12 +1146,16 @@ standardized in @w{ISO C99} while @code{gamma} is not.
 @deftypefun double tgamma (double @var{x})
 @deftypefunx float tgammaf (float @var{x})
 @deftypefunx {long double} tgammal (long double @var{x})
+@deftypefunx _FloatN tgammafN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx tgammafNx (_Float@var{N}x @var{x})
 @standardsx{tgamma, XPG, math.h}
 @standardsx{tgamma, ISO, math.h}
 @standardsx{tgammaf, XPG, math.h}
 @standardsx{tgammaf, ISO, math.h}
 @standardsx{tgammal, XPG, math.h}
 @standardsx{tgammal, ISO, math.h}
+@standardsx{tgammafN, TS 18661-3:2015, math.h}
+@standardsx{tgammafNx, TS 18661-3:2015, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{tgamma} applies the gamma function to @var{x}.  The gamma
 function is defined as
@@ -948,67 +1168,111 @@ gamma (x) = integral from 0 to @infinity{} of t^(x-1) e^-t dt
 @end smallexample
 @end ifnottex
 
-This function was introduced in @w{ISO C99}.
+This function was introduced in @w{ISO C99}.  The @code{_Float@var{N}}
+and @code{_Float@var{N}x} variants were introduced in @w{ISO/IEC TS
+18661-3}.
 @end deftypefun
 
 @deftypefun double j0 (double @var{x})
 @deftypefunx float j0f (float @var{x})
 @deftypefunx {long double} j0l (long double @var{x})
+@deftypefunx _FloatN j0fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx j0fNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{j0fN, GNU, math.h}
+@standardsx{j0fNx, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{j0} returns the Bessel function of the first kind of order 0 of
 @var{x}.  It may signal underflow if @var{x} is too large.
+
+The @code{_Float@var{N}} and @code{_Float@var{N}x} variants are GNU
+extensions.
 @end deftypefun
 
 @deftypefun double j1 (double @var{x})
 @deftypefunx float j1f (float @var{x})
 @deftypefunx {long double} j1l (long double @var{x})
+@deftypefunx _FloatN j1fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx j1fNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{j1fN, GNU, math.h}
+@standardsx{j1fNx, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{j1} returns the Bessel function of the first kind of order 1 of
 @var{x}.  It may signal underflow if @var{x} is too large.
+
+The @code{_Float@var{N}} and @code{_Float@var{N}x} variants are GNU
+extensions.
 @end deftypefun
 
 @deftypefun double jn (int @var{n}, double @var{x})
 @deftypefunx float jnf (int @var{n}, float @var{x})
 @deftypefunx {long double} jnl (int @var{n}, long double @var{x})
+@deftypefunx _FloatN jnfN (int @var{n}, _Float@var{N} @var{x})
+@deftypefunx _FloatNx jnfNx (int @var{n}, _Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{jnfN, GNU, math.h}
+@standardsx{jnfNx, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{jn} returns the Bessel function of the first kind of order
 @var{n} of @var{x}.  It may signal underflow if @var{x} is too large.
+
+The @code{_Float@var{N}} and @code{_Float@var{N}x} variants are GNU
+extensions.
 @end deftypefun
 
 @deftypefun double y0 (double @var{x})
 @deftypefunx float y0f (float @var{x})
 @deftypefunx {long double} y0l (long double @var{x})
+@deftypefunx _FloatN y0fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx y0fNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{y0fN, GNU, math.h}
+@standardsx{y0fNx, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{y0} returns the Bessel function of the second kind of order 0 of
 @var{x}.  It may signal underflow if @var{x} is too large.  If @var{x}
 is negative, @code{y0} signals a domain error; if it is zero,
 @code{y0} signals overflow and returns @math{-@infinity}.
+
+The @code{_Float@var{N}} and @code{_Float@var{N}x} variants are GNU
+extensions.
 @end deftypefun
 
 @deftypefun double y1 (double @var{x})
 @deftypefunx float y1f (float @var{x})
 @deftypefunx {long double} y1l (long double @var{x})
+@deftypefunx _FloatN y1fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx y1fNx (_Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{y1fN, GNU, math.h}
+@standardsx{y1fNx, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{y1} returns the Bessel function of the second kind of order 1 of
 @var{x}.  It may signal underflow if @var{x} is too large.  If @var{x}
 is negative, @code{y1} signals a domain error; if it is zero,
 @code{y1} signals overflow and returns @math{-@infinity}.
+
+The @code{_Float@var{N}} and @code{_Float@var{N}x} variants are GNU
+extensions.
 @end deftypefun
 
 @deftypefun double yn (int @var{n}, double @var{x})
 @deftypefunx float ynf (int @var{n}, float @var{x})
 @deftypefunx {long double} ynl (int @var{n}, long double @var{x})
+@deftypefunx _FloatN ynfN (int @var{n}, _Float@var{N} @var{x})
+@deftypefunx _FloatNx ynfNx (int @var{n}, _Float@var{N}x @var{x})
 @standards{SVID, math.h}
+@standardsx{ynfN, GNU, math.h}
+@standardsx{ynfNx, GNU, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
 @code{yn} returns the Bessel function of the second kind of order @var{n} of
 @var{x}.  It may signal underflow if @var{x} is too large.  If @var{x}
 is negative, @code{yn} signals a domain error; if it is zero,
 @code{yn} signals overflow and returns @math{-@infinity}.
+
+The @code{_Float@var{N}} and @code{_Float@var{N}x} variants are GNU
+extensions.
 @end deftypefun
 
 @node Errors in Math Functions
