diff --git a/manual/arith.texi b/manual/arith.texi
index e403cb5..019d4ae 100644
--- a/manual/arith.texi
+++ b/manual/arith.texi
@@ -691,6 +691,16 @@ These macros, defined by TS 18661-1:2014, are constant expressions for
 signaling NaNs.
 @end deftypevr
 
+@deftypevr Macro _FloatN SNANFN
+@deftypevrx Macro _FloatNx SNANFNx
+@standards{TS 18661-3:2015, math.h}
+These macros are like @code{SNAN}, except for the type of the
+floating-point number that they produce.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypevr
+
 @deftypevr Macro int FE_SNANS_ALWAYS_SIGNAL
 @standards{ISO, fenv.h}
 This macro, defined by TS 18661-1:2014, is defined to @code{1} in
@@ -928,6 +938,19 @@ Mathematical functions return the appropriately typed version of
 to be represented.
 @end deftypevr
 
+@comment math.h
+@comment ISO/IEC TS 18661-3
+@deftypevr Macro _FloatN HUGE_VAL_FN
+@comment math.h
+@comment ISO/IEC TS 18661-3
+@deftypevrx Macro _FloatNx HUGE_VAL_FNx
+These macros are like @code{HUGE_VAL}, except for the type of the
+floating-point number that they produce.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypevr
+
 @node Rounding
 @section Rounding Modes
 
@@ -1260,6 +1283,17 @@ This function returns the absolute value of the floating-point number
 @var{number}.
 @end deftypefun
 
+@deftypefun _FloatN fabsfN (_Float@var{N} @var{number})
+@deftypefunx _FloatNx fabsfNx (_Float@var{N}x @var{number})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fabs}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double cabs (complex double @var{z})
 @deftypefunx float cabsf (complex float @var{z})
 @deftypefunx {long double} cabsl (complex long double @var{z})
@@ -1278,6 +1312,17 @@ take advantage of hardware support for this operation.  See @code{hypot}
 in @ref{Exponents and Logarithms}.
 @end deftypefun
 
+@deftypefun _FloatN cabsfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx cabsfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cabs}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Normalization Functions
 @subsection Normalization Functions
 @cindex normalization functions (floating-point)
@@ -1314,6 +1359,17 @@ If @var{value} is zero, then the return value is zero and
 zero is stored in @code{*@var{exponent}}.
 @end deftypefun
 
+@deftypefun _FloatN frexpfN (_Float@var{N} @var{value}, int *@var{exponent})
+@deftypefunx _FloatNx frexpfNx (_Float@var{N}x @var{value}, int *@var{exponent})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{frexp}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1327,6 +1383,17 @@ by @code{frexp}.)
 For example, @code{ldexp (0.8, 4)} returns @code{12.8}.
 @end deftypefun
 
+@deftypefun _FloatN ldexpfN (_Float@var{N} @var{value}, int @var{exponent})
+@deftypefunx _FloatNx ldexpfNx (_Float@var{N}x @var{value}, int @var{exponent})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ldexp}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 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.
@@ -1348,6 +1415,17 @@ The @code{scalb} function is the BSD name for @code{ldexp}.
 @var{n} is an @code{int} instead of a floating-point number.
 @end deftypefun
 
+@deftypefun _FloatN scalbnfN (_Float@var{N} @var{x}, int @var{n})
+@deftypefunx _FloatNx scalbnfNx (_Float@var{N}x @var{x}, int @var{n})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{scalbn}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1357,6 +1435,17 @@ The @code{scalb} function is the BSD name for @code{ldexp}.
 @var{n} is a @code{long int} instead of a floating-point number.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{scalbln}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double significand (double @var{x})
 @deftypefunx float significandf (float @var{x})
 @deftypefunx {long double} significandl (long double @var{x})
@@ -1423,6 +1512,17 @@ returning that value as a @code{double}.  Thus, @code{ceil (1.5)}
 is @code{2.0}.
 @end deftypefun
 
+@deftypefun _FloatN ceilfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx ceilfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ceil}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double floor (double @var{x})
 @deftypefunx float floorf (float @var{x})
 @deftypefunx {long double} floorl (long double @var{x})
@@ -1433,6 +1533,17 @@ integer, returning that value as a @code{double}.  Thus, @code{floor
 (1.5)} is @code{1.0} and @code{floor (-1.5)} is @code{-2.0}.
 @end deftypefun
 
+@deftypefun _FloatN floorfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx floorfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{floor}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double trunc (double @var{x})
 @deftypefunx float truncf (float @var{x})
 @deftypefunx {long double} truncl (long double @var{x})
@@ -1443,6 +1554,17 @@ integer (returned in floating-point format).  Thus, @code{trunc (1.5)}
 is @code{1.0} and @code{trunc (-1.5)} is @code{-1.0}.
 @end deftypefun
 
+@deftypefun _FloatN truncfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx truncfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{trunc}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double rint (double @var{x})
 @deftypefunx float rintf (float @var{x})
 @deftypefunx {long double} rintl (long double @var{x})
@@ -1459,6 +1581,17 @@ If @var{x} was not initially an integer, these functions raise the
 inexact exception.
 @end deftypefun
 
+@deftypefun _FloatN rintfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx rintfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{rint}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double nearbyint (double @var{x})
 @deftypefunx float nearbyintf (float @var{x})
 @deftypefunx {long double} nearbyintl (long double @var{x})
@@ -1468,6 +1601,17 @@ 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.
 @end deftypefun
 
+@deftypefun _FloatN nearbyintfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx nearbyintfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{nearbyint}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double round (double @var{x})
 @deftypefunx float roundf (float @var{x})
 @deftypefunx {long double} roundl (long double @var{x})
@@ -1478,6 +1622,17 @@ cases away from zero instead of to the nearest integer (or other
 current rounding mode).
 @end deftypefun
 
+@deftypefun _FloatN roundfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx roundfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{round}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double roundeven (double @var{x})
 @deftypefunx float roundevenf (float @var{x})
 @deftypefunx {long double} roundevenl (long double @var{x})
@@ -1487,6 +1642,17 @@ These functions, from TS 18661-1:2014, are similar to @code{round},
 but they round halfway cases to even instead of away from zero.
 @end deftypefun
 
+@deftypefun _FloatN roundevenfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx roundevenfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{roundeven}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun {long int} lrint (double @var{x})
 @deftypefunx {long int} lrintf (float @var{x})
 @deftypefunx {long int} lrintl (long double @var{x})
@@ -1496,6 +1662,17 @@ These functions are just like @code{rint}, but they return a
 @code{long int} instead of a floating-point number.
 @end deftypefun
 
+@deftypefun {long int} lrintfN (_Float@var{N} @var{x})
+@deftypefunx {long int} lrintfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{lrint}, except for the floating-point
+argument.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1505,6 +1682,17 @@ These functions are just like @code{rint}, but they return a
 @code{long long int} instead of a floating-point number.
 @end deftypefun
 
+@deftypefun {long long int} llrintfN (_Float@var{N} @var{x})
+@deftypefunx {long long int} llrintfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{llrint}, except for the floating-point
+argument.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun {long int} lround (double @var{x})
 @deftypefunx {long int} lroundf (float @var{x})
 @deftypefunx {long int} lroundl (long double @var{x})
@@ -1514,6 +1702,17 @@ These functions are just like @code{round}, but they return a
 @code{long int} instead of a floating-point number.
 @end deftypefun
 
+@deftypefun {long int} lroundfN (_Float@var{N} @var{x})
+@deftypefunx {long int} lroundfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{lround}, except for the floating-point
+argument.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1523,6 +1722,17 @@ These functions are just like @code{round}, but they return a
 @code{long long int} instead of a floating-point number.
 @end deftypefun
 
+@deftypefun {long long int} llroundfN (_Float@var{N} @var{x})
+@deftypefunx {long long int} llroundfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{llround}, except for the floating-point
+argument.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1550,6 +1760,23 @@ is not an integer; the other functions do not raise the inexact
 exception.
 @end deftypefun
 
+@deftypefun {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} 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} 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} 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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fromfp}, @code{ufromfp}, @code{fromfpx},
+and @code{ufromfpx}, except for the floating-point argument.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @deftypefun double modf (double @var{value}, double *@var{integer-part})
 @deftypefunx float modff (float @var{value}, float *@var{integer-part})
@@ -1566,6 +1793,17 @@ returns the fractional part.  For example, @code{modf (2.5, &intpart)}
 returns @code{0.5} and stores @code{2.0} into @code{intpart}.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{modf}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Remainder Functions
 @subsection Remainder Functions
 
@@ -1591,6 +1829,17 @@ less than the magnitude of the @var{denominator}.
 If @var{denominator} is zero, @code{fmod} signals a domain error.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fmod}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1610,6 +1859,17 @@ absolute value of the @var{denominator}.  The difference between
 If @var{denominator} is zero, @code{remainder} signals a domain error.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{remainder}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double drem (double @var{numerator}, double @var{denominator})
 @deftypefunx float dremf (float @var{numerator}, float @var{denominator})
 @deftypefunx {long double} dreml (long double @var{numerator}, long double @var{denominator})
@@ -1644,6 +1904,17 @@ This function is defined in @w{IEC 559} (and the appendix with
 recommended functions in @w{IEEE 754}/@w{IEEE 854}).
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{copysign}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun int signbit (@emph{float-type} @var{x})
 @standards{ISO, math.h}
 @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
@@ -1675,6 +1946,17 @@ This function is defined in @w{IEC 559} (and the appendix with
 recommended functions in @w{IEEE 754}/@w{IEEE 854}).
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{nextafter}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double nexttoward (double @var{x}, long double @var{y})
 @deftypefunx float nexttowardf (float @var{x}, long double @var{y})
 @deftypefunx {long double} nexttowardl (long double @var{x}, long double @var{y})
@@ -1700,6 +1982,17 @@ If @var{x} is @math{+@infinity{}}, @math{+@infinity{}} is returned.
 @code{nextup} never raises an exception except for signaling NaNs.
 @end deftypefun
 
+@deftypefun _FloatN nextupfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx nextupfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{nextup}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double nextdown (double @var{x})
 @deftypefunx float nextdownf (float @var{x})
 @deftypefunx {long double} nextdownl (long double @var{x})
@@ -1715,6 +2008,17 @@ If @var{x} is @math{-@infinity{}}, @math{-@infinity{}} is returned.
 @code{nextdown} never raises an exception except for signaling NaNs.
 @end deftypefun
 
+@deftypefun _FloatN nextdownfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx nextdownfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{nextdown}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex NaN
 @deftypefun double nan (const char *@var{tagp})
 @deftypefunx float nanf (const char *@var{tagp})
@@ -1732,6 +2036,16 @@ The argument @var{tagp} is used in an unspecified manner.  On @w{IEEE
 selects one.  On other systems it may do nothing.
 @end deftypefun
 
+@deftypefun _FloatN nanfN (const char *@var{tagp})
+@deftypefunx _FloatNx nanfNx (const char *@var{tagp})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{nan}, except for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1757,6 +2071,17 @@ corresponding quiet NaN, if that value is a signaling NaN) may be
 produced as output.
 @end deftypefun
 
+@deftypefun 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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{canonicalize}, except for the
+floating-point arguments.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double getpayload (const double *@var{x})
 @deftypefunx float getpayloadf (const float *@var{x})
 @deftypefunx {long double} getpayloadl (const long double *@var{x})
@@ -1772,6 +2097,17 @@ integer, or positive zero, represented as a floating-point number); if
 floating-point exceptions even for signaling NaNs.
 @end deftypefun
 
+@deftypefun _FloatN getpayloadfN (const _Float@var{N} *@var{x})
+@deftypefunx _FloatNx getpayloadfNx (const _Float@var{N}x *@var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{getpayload}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@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})
@@ -1785,6 +2121,17 @@ 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 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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{setpayload}, except for the floating-point
+arguments.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@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})
@@ -1798,6 +2145,17 @@ 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 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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{setpayloadsig}, except for the floating-point
+arguments.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node FP Comparison Functions
 @subsection Floating-Point Comparison Functions
 @cindex unordered comparison
@@ -1902,6 +2260,17 @@ increasing payload; positive quiet NaNs, in order of increasing
 payload.
 @end deftypefun
 
+@deftypefun 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-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{totalorder}, except for the floating-point
+arguments.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1913,6 +2282,17 @@ and @var{y}, returning nonzero if it is true and zero if it is false.
 No exceptions are raised even for signaling NaNs.
 @end deftypefun
 
+@deftypefun 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-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{totalordermag}, except for the floating-point
+arguments.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 Not all machines provide hardware support for these operations.  On
 machines that don't, the macros can be very slow.  Therefore, you should
 not use these functions when NaN is not a concern.
@@ -1949,6 +2329,17 @@ If an argument is NaN, the other argument is returned.  If both arguments
 are NaN, NaN is returned.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fmin}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1961,6 +2352,17 @@ If an argument is NaN, the other argument is returned.  If both arguments
 are NaN, NaN is returned.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fmax}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1972,6 +2374,17 @@ have the same absolute value, or either is NaN, they behave the same
 as the @code{fmin} functions.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fminmag}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@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})
@@ -1983,6 +2396,17 @@ have the same absolute value, or either is NaN, they behave the same
 as the @code{fmax} functions.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fmaxmag}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -1995,6 +2419,17 @@ The @code{fdim} function returns the positive difference between
 If @var{x}, @var{y}, or both are NaN, NaN is returned.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fdim}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -2022,6 +2457,17 @@ In @theglibc{}, this always means the operation is implemented in
 hardware.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{fma}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Complex Numbers
 @section Complex Numbers
 @pindex complex.h
@@ -2033,6 +2479,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
@@ -2131,6 +2582,17 @@ available in three variants, one for each of the three complex types.
 These functions return the real part of the complex number @var{z}.
 @end deftypefun
 
+@deftypefun _FloatN crealfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx crealfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{creal}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double cimag (complex double @var{z})
 @deftypefunx float cimagf (complex float @var{z})
 @deftypefunx {long double} cimagl (complex long double @var{z})
@@ -2139,6 +2601,17 @@ These functions return the real part of the complex number @var{z}.
 These functions return the imaginary part of the complex number @var{z}.
 @end deftypefun
 
+@deftypefun _FloatN cimagfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx cimagfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cimag}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -2149,6 +2622,17 @@ These functions return the conjugate value of the complex number
 negated imaginary part.  In other words, @samp{conj(a + bi) = a + -bi}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} conjfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} conjfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{conj}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double carg (complex double @var{z})
 @deftypefunx float cargf (complex float @var{z})
 @deftypefunx {long double} cargl (complex long double @var{z})
@@ -2163,6 +2647,17 @@ number.  This angle is measured in the usual fashion and ranges from
 @code{carg} has a branch cut along the negative real axis.
 @end deftypefun
 
+@deftypefun _FloatN cargfN (complex _Float@var{N} @var{z})
+@deftypefunx _FloatNx cargfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{carg}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -2178,6 +2673,17 @@ INFINITY + I * copysign (0.0, cimag (z))
 @end smallexample
 @end deftypefun
 
+@deftypefun {complex _FloatN} cprojfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cprojfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cproj}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Parsing of Numbers
 @section Parsing of Numbers
 @cindex parsing numbers (in formatted input)
diff --git a/manual/math.texi b/manual/math.texi
index 912e740..44518ab 100644
--- a/manual/math.texi
+++ b/manual/math.texi
@@ -128,6 +128,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
@@ -168,6 +175,17 @@ 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}.
 @end deftypefun
 
+@deftypefun _FloatN sinfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx sinfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{sin}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double cos (double @var{x})
 @deftypefunx float cosf (float @var{x})
 @deftypefunx {long double} cosl (long double @var{x})
@@ -177,6 +195,17 @@ 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}.
 @end deftypefun
 
+@deftypefun _FloatN cosfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx cosfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cos}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double tan (double @var{x})
 @deftypefunx float tanf (float @var{x})
 @deftypefunx {long double} tanl (long double @var{x})
@@ -195,6 +224,17 @@ and cosine of the same angle are needed at the same time.  It is more
 efficient to compute them simultaneously, so the library provides a
 function to do that.
 
+@deftypefun _FloatN tanfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx tanfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{tan}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -209,6 +249,18 @@ This function is a GNU extension.  Portable programs should be prepared
 to cope with its absence.
 @end deftypefun
 
+@deftypefun _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 are like @code{sincos}, except for the floating-point
+arguments and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex complex trigonometric functions
 
 @w{ISO C99} defines variants of the trig functions which work on
@@ -237,6 +289,17 @@ $$\sin(z) = {1\over 2i} (e^{zi} - e^{-zi})$$
 @end tex
 @end deftypefun
 
+@deftypefun {complex _FloatN} csinfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} csinfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{csin}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -253,6 +316,17 @@ $$\cos(z) = {1\over 2} (e^{zi} + e^{-zi})$$
 @end tex
 @end deftypefun
 
+@deftypefun {complex _FloatN} ccosfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ccosfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ccos}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -274,6 +348,17 @@ integer.  @code{ctan} may signal overflow if @var{z} is too close to a
 pole.
 @end deftypefun
 
+@deftypefun {complex _FloatN} ctanfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ctanfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ctan}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @node Inverse Trig Functions
 @section Inverse Trigonometric Functions
@@ -298,6 +383,17 @@ over the domain @code{-1} to @code{1}.  If @var{x} is outside the
 domain, @code{asin} signals a domain error.
 @end deftypefun
 
+@deftypefun _FloatN asinfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx asinfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{asin}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double acos (double @var{x})
 @deftypefunx float acosf (float @var{x})
 @deftypefunx {long double} acosl (long double @var{x})
@@ -313,6 +409,17 @@ over the domain @code{-1} to @code{1}.  If @var{x} is outside the
 domain, @code{acos} signals a domain error.
 @end deftypefun
 
+@deftypefun _FloatN acosfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx acosfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{acos}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double atan (double @var{x})
 @deftypefunx float atanf (float @var{x})
 @deftypefunx {long double} atanl (long double @var{x})
@@ -324,6 +431,17 @@ Mathematically, there are infinitely many such values; the one actually
 returned is the one between @code{-pi/2} and @code{pi/2} (inclusive).
 @end deftypefun
 
+@deftypefun _FloatN atanfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx atanfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{atan}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -345,6 +463,17 @@ Logarithms}.)
 If both @var{x} and @var{y} are zero, @code{atan2} returns zero.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{atan2}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex inverse complex trigonometric functions
 @w{ISO C99} defines complex versions of the inverse trig functions.
 
@@ -360,6 +489,17 @@ Unlike the real-valued functions, @code{casin} is defined for all
 values of @var{z}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} casinfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} casinfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{casin}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -372,6 +512,17 @@ Unlike the real-valued functions, @code{cacos} is defined for all
 values of @var{z}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} cacosfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cacosfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cacos}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @deftypefun {complex double} catan (complex double @var{z})
 @deftypefunx {complex float} catanf (complex float @var{z})
@@ -382,6 +533,17 @@ 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.
 @end deftypefun
 
+@deftypefun {complex _FloatN} catanfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} catanfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{catan}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @node Exponents and Logarithms
 @section Exponentiation and Logarithms
@@ -401,6 +563,17 @@ If the magnitude of the result is too large to be representable,
 @code{exp} signals overflow.
 @end deftypefun
 
+@deftypefun _FloatN expfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx expfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{exp}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double exp2 (double @var{x})
 @deftypefunx float exp2f (float @var{x})
 @deftypefunx {long double} exp2l (long double @var{x})
@@ -410,6 +583,17 @@ These functions compute @code{2} raised to the power @var{x}.
 Mathematically, @code{exp2 (x)} is the same as @code{exp (x * log (2))}.
 @end deftypefun
 
+@deftypefun _FloatN exp2fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx exp2fNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{exp2}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double exp10 (double @var{x})
 @deftypefunx float exp10f (float @var{x})
 @deftypefunx {long double} exp10l (long double @var{x})
@@ -429,6 +613,18 @@ names are GNU extensions.  The name @code{exp10} is
 preferred, since it is analogous to @code{exp} and @code{exp2}.
 @end deftypefun
 
+@deftypefun _FloatN exp10fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx exp10fNx (_Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{exp10}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @deftypefun double log (double @var{x})
 @deftypefunx float logf (float @var{x})
@@ -444,6 +640,17 @@ is zero, it returns negative infinity; if @var{x} is too close to zero,
 it may signal overflow.
 @end deftypefun
 
+@deftypefun _FloatN logfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx logfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{log}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double log10 (double @var{x})
 @deftypefunx float log10f (float @var{x})
 @deftypefunx {long double} log10l (long double @var{x})
@@ -454,6 +661,17 @@ These functions return the base-10 logarithm of @var{x}.
 
 @end deftypefun
 
+@deftypefun _FloatN log10fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx log10fNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{log10}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double log2 (double @var{x})
 @deftypefunx float log2f (float @var{x})
 @deftypefunx {long double} log2l (long double @var{x})
@@ -463,6 +681,17 @@ These functions return the base-2 logarithm of @var{x}.
 @code{log2 (@var{x})} equals @code{log (@var{x}) / log (2)}.
 @end deftypefun
 
+@deftypefun _FloatN log2fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx log2fNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{log2}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double logb (double @var{x})
 @deftypefunx float logbf (float @var{x})
 @deftypefunx {long double} logbl (long double @var{x})
@@ -478,6 +707,17 @@ negative), @code{logb} returns @math{@infinity{}}.  If @var{x} is zero,
 @code{logb} returns @math{@infinity{}}.  It does not signal.
 @end deftypefun
 
+@deftypefun _FloatN logbfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx logbfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{logb}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun int ilogb (double @var{x})
 @deftypefunx int ilogbf (float @var{x})
 @deftypefunx int ilogbl (long double @var{x})
@@ -492,6 +732,19 @@ functions except that they return signed integer values.  The
 are from TS 18661-1:2014.
 @end deftypefun
 
+@deftypefun int ilogbfN (_Float@var{N} @var{x})
+@deftypefunx int ilogbfNx (_Float@var{N}x @var{x})
+@deftypefunx {long int} llogbfN (_Float@var{N} @var{x})
+@deftypefunx {long int} llogbfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ilogb} and @code{llogb}, except for the
+type of the floating-point argument.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @noindent
 Since integers cannot represent infinity and NaN, @code{ilogb} instead
 returns an integer that can't be the exponent of a normal floating-point
@@ -566,6 +819,17 @@ do that, so instead it signals a domain error. @code{pow} may also
 underflow or overflow the destination type.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{pow}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex square root function
 @deftypefun double sqrt (double @var{x})
 @deftypefunx float sqrtf (float @var{x})
@@ -578,6 +842,17 @@ If @var{x} is negative, @code{sqrt} signals a domain error.
 Mathematically, it should return a complex number.
 @end deftypefun
 
+@deftypefun _FloatN sqrtfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx sqrtfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{sqrt}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex cube root function
 @deftypefun double cbrt (double @var{x})
 @deftypefunx float cbrtf (float @var{x})
@@ -588,6 +863,17 @@ These functions return the cube root of @var{x}.  They cannot
 fail; every representable real value has a representable real cube root.
 @end deftypefun
 
+@deftypefun _FloatN cbrtfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx cbrtfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cbrt}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -601,6 +887,17 @@ instead of the direct formula is wise, since the error is
 much smaller.  See also the function @code{cabs} in @ref{Absolute Value}.
 @end deftypefun
 
+@deftypefun _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{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{hypot}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double expm1 (double @var{x})
 @deftypefunx float expm1f (float @var{x})
 @deftypefunx {long double} expm1l (long double @var{x})
@@ -612,6 +909,17 @@ near zero---a case where @code{exp (@var{x}) - 1} would be inaccurate owing
 to subtraction of two numbers that are nearly equal.
 @end deftypefun
 
+@deftypefun _FloatN expm1fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx expm1fNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{expm1}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double log1p (double @var{x})
 @deftypefunx float log1pf (float @var{x})
 @deftypefunx {long double} log1pl (long double @var{x})
@@ -622,6 +930,17 @@ They are computed in a way that is accurate even if @var{x} is
 near zero.
 @end deftypefun
 
+@deftypefun _FloatN log1pfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx log1pfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{log1p}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex complex exponentiation functions
 @cindex complex logarithm functions
 
@@ -645,6 +964,17 @@ $$\exp(z) = e^z = e^{{\rm Re}\,z} (\cos ({\rm Im}\,z) + i \sin ({\rm Im}\,z))$$
 @end tex
 @end deftypefun
 
+@deftypefun {complex _FloatN} cexpfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cexpfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cexp}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -666,6 +996,17 @@ or is very close to 0.  It is well-defined for all other values of
 @var{z}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} clogfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} clogfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{clog}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @deftypefun {complex double} clog10 (complex double @var{z})
 @deftypefunx {complex float} clog10f (complex float @var{z})
@@ -685,6 +1026,18 @@ $$\log_{10}(z) = \log_{10}|z| + i \arg z / \log (10)$$
 These functions are GNU extensions.
 @end deftypefun
 
+@deftypefun {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 are like @code{clog10}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@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})
@@ -694,6 +1047,17 @@ 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}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} csqrtfN (_Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} csqrtfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{csqrt}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -703,6 +1067,17 @@ These functions return @var{base} raised to the power of
 @var{power}.  This is equivalent to @w{@code{cexp (y * clog (x))}}
 @end deftypefun
 
+@deftypefun {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{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cpow}, except for the floating-point
+arguments and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Hyperbolic Functions
 @section Hyperbolic Functions
 @cindex hyperbolic functions
@@ -720,6 +1095,17 @@ mathematically as @w{@code{(exp (@var{x}) - exp (-@var{x})) / 2}}.  They
 may signal overflow if @var{x} is too large.
 @end deftypefun
 
+@deftypefun _FloatN sinhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx sinhfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{sinh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double cosh (double @var{x})
 @deftypefunx float coshf (float @var{x})
 @deftypefunx {long double} coshl (long double @var{x})
@@ -730,6 +1116,17 @@ defined mathematically as @w{@code{(exp (@var{x}) + exp (-@var{x})) / 2}}.
 They may signal overflow if @var{x} is too large.
 @end deftypefun
 
+@deftypefun _FloatN coshfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx coshfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cosh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double tanh (double @var{x})
 @deftypefunx float tanhf (float @var{x})
 @deftypefunx {long double} tanhl (long double @var{x})
@@ -740,6 +1137,17 @@ defined mathematically as @w{@code{sinh (@var{x}) / cosh (@var{x})}}.
 They may signal overflow if @var{x} is too large.
 @end deftypefun
 
+@deftypefun _FloatN tanhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx tanhfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{tanh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex hyperbolic functions
 
 There are counterparts for the hyperbolic functions which take
@@ -754,6 +1162,17 @@ These functions return the complex hyperbolic sine of @var{z}, defined
 mathematically as @w{@code{(exp (@var{z}) - exp (-@var{z})) / 2}}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} csinhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} csinhfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{csinh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -763,6 +1182,17 @@ These functions return the complex hyperbolic cosine of @var{z}, defined
 mathematically as @w{@code{(exp (@var{z}) + exp (-@var{z})) / 2}}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} ccoshfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ccoshfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ccosh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -772,6 +1202,17 @@ These functions return the complex hyperbolic tangent of @var{z},
 defined mathematically as @w{@code{csinh (@var{z}) / ccosh (@var{z})}}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} ctanhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} ctanhfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{ctanh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 
 @cindex inverse hyperbolic functions
 
@@ -784,6 +1225,17 @@ These functions return the inverse hyperbolic sine of @var{x}---the
 value whose hyperbolic sine is @var{x}.
 @end deftypefun
 
+@deftypefun _FloatN asinhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx asinhfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{asinh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double acosh (double @var{x})
 @deftypefunx float acoshf (float @var{x})
 @deftypefunx {long double} acoshl (long double @var{x})
@@ -794,6 +1246,17 @@ value whose hyperbolic cosine is @var{x}.  If @var{x} is less than
 @code{1}, @code{acosh} signals a domain error.
 @end deftypefun
 
+@deftypefun _FloatN acoshfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx acoshfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{acosh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double atanh (double @var{x})
 @deftypefunx float atanhf (float @var{x})
 @deftypefunx {long double} atanhl (long double @var{x})
@@ -805,6 +1268,17 @@ value whose hyperbolic tangent is @var{x}.  If the absolute value of
 if it is equal to 1, @code{atanh} returns infinity.
 @end deftypefun
 
+@deftypefun _FloatN atanhfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx atanhfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{atanh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @cindex inverse complex hyperbolic functions
 
 @deftypefun {complex double} casinh (complex double @var{z})
@@ -816,6 +1290,17 @@ These functions return the inverse complex hyperbolic sine of
 @var{z}---the value whose complex hyperbolic sine is @var{z}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} casinhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} casinhfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{casinh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -826,6 +1311,17 @@ These functions return the inverse complex hyperbolic cosine of
 the real-valued functions, there are no restrictions on the value of @var{z}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} cacoshfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} cacoshfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{cacosh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -837,6 +1333,17 @@ the real-valued functions, there are no restrictions on the value of
 @var{z}.
 @end deftypefun
 
+@deftypefun {complex _FloatN} catanhfN (complex _Float@var{N} @var{z})
+@deftypefunx {complex _FloatNx} catanhfNx (complex _Float@var{N}x @var{z})
+@standards{TS 18661-3:2015, complex.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{catanh}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Special Functions
 @section Special Functions
 @cindex special functions
@@ -863,6 +1370,17 @@ erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt
 @end ifnottex
 @end deftypefun
 
+@deftypefun _FloatN erffN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx erffNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{erf}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double erfc (double @var{x})
 @deftypefunx float erfcf (float @var{x})
 @deftypefunx {long double} erfcl (long double @var{x})
@@ -872,6 +1390,17 @@ erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt
 fashion that avoids round-off error when @var{x} is large.
 @end deftypefun
 
+@deftypefun _FloatN erfcfN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx erfcfNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{erfc}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double lgamma (double @var{x})
 @deftypefunx float lgammaf (float @var{x})
 @deftypefunx {long double} lgammal (long double @var{x})
@@ -906,6 +1435,17 @@ The gamma function has singularities at the non-positive integers.
 singularity.
 @end deftypefun
 
+@deftypefun _FloatN lgammafN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx lgammafNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{lgamma}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @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})
@@ -916,6 +1456,18 @@ the intermediate result in the variable pointed to by @var{signp}
 instead of in the @var{signgam} global.  This means it is reentrant.
 @end deftypefun
 
+@deftypefun _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{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{lgamma_r}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double gamma (double @var{x})
 @deftypefunx float gammaf (float @var{x})
 @deftypefunx {long double} gammal (long double @var{x})
@@ -951,6 +1503,17 @@ gamma (x) = integral from 0 to @infinity{} of t^(x-1) e^-t dt
 This function was introduced in @w{ISO C99}.
 @end deftypefun
 
+@deftypefun _FloatN tgammafN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx tgammafNx (_Float@var{N}x @var{x})
+@standards{TS 18661-3:2015, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{tgamma}, except for the floating-point
+argument and for the return type.
+
+They were introduced in @w{ISO/IEC TS 18661-3} and are available on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double j0 (double @var{x})
 @deftypefunx float j0f (float @var{x})
 @deftypefunx {long double} j0l (long double @var{x})
@@ -960,6 +1523,18 @@ This function was introduced in @w{ISO C99}.
 @var{x}.  It may signal underflow if @var{x} is too large.
 @end deftypefun
 
+@deftypefun _FloatN j0fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx j0fNx (_Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{j0}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double j1 (double @var{x})
 @deftypefunx float j1f (float @var{x})
 @deftypefunx {long double} j1l (long double @var{x})
@@ -969,6 +1544,18 @@ This function was introduced in @w{ISO C99}.
 @var{x}.  It may signal underflow if @var{x} is too large.
 @end deftypefun
 
+@deftypefun _FloatN j1fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx j1fNx (_Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{j1}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@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})
@@ -978,6 +1565,18 @@ This function was introduced in @w{ISO C99}.
 @var{n} of @var{x}.  It may signal underflow if @var{x} is too large.
 @end deftypefun
 
+@deftypefun _FloatN jnfN (int @var{n}, _Float@var{N} @var{x})
+@deftypefunx _FloatNx jnfNx (int @var{n}, _Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{jn}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double y0 (double @var{x})
 @deftypefunx float y0f (float @var{x})
 @deftypefunx {long double} y0l (long double @var{x})
@@ -989,6 +1588,18 @@ is negative, @code{y0} signals a domain error; if it is zero,
 @code{y0} signals overflow and returns @math{-@infinity}.
 @end deftypefun
 
+@deftypefun _FloatN y0fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx y0fNx (_Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{y0}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @deftypefun double y1 (double @var{x})
 @deftypefunx float y1f (float @var{x})
 @deftypefunx {long double} y1l (long double @var{x})
@@ -1000,6 +1611,18 @@ is negative, @code{y1} signals a domain error; if it is zero,
 @code{y1} signals overflow and returns @math{-@infinity}.
 @end deftypefun
 
+@deftypefun _FloatN y1fN (_Float@var{N} @var{x})
+@deftypefunx _FloatNx y1fNx (_Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{y1}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@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})
@@ -1011,6 +1634,18 @@ is negative, @code{yn} signals a domain error; if it is zero,
 @code{yn} signals overflow and returns @math{-@infinity}.
 @end deftypefun
 
+@deftypefun _FloatN ynfN (int @var{n}, _Float@var{N} @var{x})
+@deftypefunx _FloatNx ynfNx (int @var{n}, _Float@var{N}x @var{x})
+@standards{GNU, math.h}
+@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
+These functions are like @code{yn}, except for the floating-point
+argument and for the return type.
+
+They are not defined in any standard and are available to provided
+completeness for the non-deprecated interface of math functions on
+machines that support the related types; @pxref{Mathematics}.
+@end deftypefun
+
 @node Errors in Math Functions
 @section Known Maximum Errors in Math Functions
 @cindex math errors
