diff mbox

[v2,3/6] Document _FloatN and _FloatNx versions of math functions

Message ID 1498067125-30472-4-git-send-email-gftg@linux.vnet.ibm.com
State Superseded
Delegated to: Joseph Myers
Headers

Commit Message

Gabriel F T Gomes June 21, 2017, 5:45 p.m. UTC 
  Changes since v1:

  - Document a lot of functions and macros that were missing documentation.
  - Update for the use of @standards.

-- 8< --
The functions defined in ISO/IEC TS 18661-3 take floating-point arguments
and return floating-point numbers of _FloatN and _FloatNx types.  Apart
from the type, these functions behave the same as their float, double, and
long double counterparts.  This patch adds the newer functions to the
manual.

2017-06-12  Gabriel F. T. Gomes  <gftg@linux.vnet.ibm.com>

	* manual/arith.texi (Infinity and NaN): Document SNANFN and SNANFNx.
	(Error Reporting by Mathematical Functions): Document HUGE_VAL_FN
	and HUGE_VAL_FNx.
	(Absolute Value): Document fabsfN, fabsfNx, cabsfN, cabsfNx.
	(Normalization Functions): Document frexpfN, frexpfNx, ldexpfN,
	ldexpfNx, scalbnfN, scalbnfNx, scalblnfN, scalblnfNx.
	(Rounding Functions): Document ceilfN, ceilfNx, floorfN, floorfNx,
	truncfN, truncfNx, rintfN, rintfNx, nearbyintfN, nearbyintfNx,
	roundfN, roundfNx, roundevenfN, roundevenfNx, lrintfN, lrintfNx,
	llrintfN, llrintfNx, lroundfN, lroundfNx, llroundfN, llroundfNx,
	fromfpfN, fromfpfNx, ufromfpfN, ufromfpfNx, fromfpxfN, fromfpxfNx,
	ufromfpxfN, ufromfpxfNx, modffN, modffNx.
	(Remainder Functions): Document fmodfN, fmodfNx, remainderfN,
	remainderfNx.
	(Setting and modifying single bits of FP values): Document
	copysignfN, copysignfNx, nextafterfN, nextafterfNx, nextupfN,
	nextupfNx, nextdownfN, nextdownfNx, nanfN, nanfNx, canonicalizefN,
	canonicalizefNx, getpayloadfN, getpayloadfNx, setpayloadfN,
	setpayloadfNx, setpayloadsigfN, setpayloadsigfNx.
	(Floating-Point Comparison Functions): Document totalorderfN,
	totalorderfNx, totalordermagfN, totalordermagfNx.
	(Miscellaneous FP arithmetic functions): Document fminfN, fminfNx,
	fmaxfN, fmaxfNx, fminmagfN, fminmagfNx, fmaxmagfN, fmaxmagfNx,
	fdimfN, fdimfNx, fmafN, fmafNx.
	(Complex Numbers): Document the complex types: _FloatN complex and
	_FloatNx complex.
	(rojections, Conjugates, and Decomposing of Complex Numbers):
	Document crealfN, crealfNx, cimagfN, cimagfNx, conjfN, conjfNx,
	cargfN, cargfNx, cprojfN, cprojfNx.
	* manual/math.texi (Predefined Mathematical Constants): Document
	macros prefixed with M_.
	(Trigonometric Functions): Document sinfN, sinfNx, cosfN, cosfNx,
	tanfN, tanfNx, sincosfN, sincosfNx, csinfN, csinfNx, ccosfN,
	ccosfNx, ctanfN, ctanfNx.
	(Inverse Trigonometric Functions): Document asinfN, asinfNx,
	acosfN, acosfNx, atanfN, atanfNx, atan2fN, atan2fNx.
	(Exponentiation and Logarithms): Document expfN, expfNx, exp2fN,
	exp2fNx, exp10fN, exp10fNx, logfN, logfNx, log10fN, log10fNx,
	log2fN, log2fNx, logbfN, logbfNx, ilogbfN, ilogbfNx, llogbfN,
	llogbfNx, powfN, powfNx, sqrtfN, sqrtfNx, cbrtfN, cbrtfNx, hypotfN,
	hypotfNx, expm1fN, expm1fNx, log1pfN, log1pfNx, cexpfN, cexpfNx,
	clogfN, clogfNx, clog10fN, clog10fNx, csqrtfN, csqrtfNx, cpowfN,
	cpowfNx.
	(Hyperbolic Functions): sinhfN, sinhfNx, coshfN, coshfNx, tanhfN,
	tanhfNx, csinhfN, csinhfNx, ccoshfN, ccoshfNx, ctanhfN, ctanhfNx,
	asinhfN, asinhfNx, acoshfN, acoshfNx, atanhfN, atanhfNx, casinhfN,
	casinhfNx, cacoshfN, cacoshfNx, catanhfN, catanhfNx.
	(Special Functions): Document erffN, erffNx, erfcfN, erfcfNx,
	lgammafN, lgammafNx, lgammarfN_r, lgammafNx_r, tgammafN, tgammafNx,
	j0fN, j0fNx, j1fN, j1fNx, jnfN, jnfNx, y0fN, y0fNx, y1fN, y1fNx,
	ynfN, ynfNx.
---
 manual/arith.texi | 506 +++++++++++++++++++++++++++++++++++++++++++
 manual/math.texi  | 635 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1141 insertions(+)

Comments

Joseph Myers June 22, 2017, 1:23 a.m. UTC | #1 
On Wed, 21 Jun 2017, Gabriel F. T. Gomes wrote:

> +@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

I don't think it's appropriate to have all these duplicated stanzas in the 
manual saying the _FloatN / _FloatNx interfaces are like others except for 
the type - they should be added to the existing stanzas that already 
cover the float, double and long double functions.

I think that you should in this case use @deftypevrx for the new macros, 
along with @standardsx to indicate the standards for these interfaces 
(*not* @comment as you have there, which is the old syntax).  Likewise 
@deftypefunx, etc. - and in the cases where text explicitly says something 
was added in TS 18661-1, amend that text to say TS 18661-1 and TS 18661-3 
(with the expectation that all such sentences will be removed once we 
start putting @standards information in the formatted manual).

To avoid losing the information about where the *fN / *fNx functions come 
from, the statement about the types being provided ("On some machines, 
@theglibc{} also provides...") could be expanded to say how *fN / *fNx 
functions are provided, and in general those functions come from TS 
18661-3 (then only mention explicitly for a few functions that the *fN / 
*fNx functions are GNU extensions).

> +@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.

Apart from what I said above about merging with the existing fabs* 
description, note that a bit above there's a statement "@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}.".  That 
needs amending, maybe to say "the @code{fabs} functions" etc. so it 
doesn't need all the functions listed explicitly.
diff mbox

Patch

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