From patchwork Wed Jun 21 17:45:22 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gabriel F T Gomes X-Patchwork-Id: 21180 X-Patchwork-Delegate: joseph@codesourcery.com Received: (qmail 49718 invoked by alias); 21 Jun 2017 17:46:36 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 47374 invoked by uid 89); 21 Jun 2017 17:46:05 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-24.2 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, KHOP_DYNAMIC, RCVD_IN_DNSWL_LOW autolearn=ham version=3.3.2 spammy=Reporting, Gabriel X-HELO: mx0a-001b2d01.pphosted.com From: "Gabriel F. T. Gomes" To: libc-alpha@sourceware.org Subject: [PATCH v2 3/6] Document _FloatN and _FloatNx versions of math functions Date: Wed, 21 Jun 2017 14:45:22 -0300 In-Reply-To: <1498067125-30472-1-git-send-email-gftg@linux.vnet.ibm.com> References: <1498067125-30472-1-git-send-email-gftg@linux.vnet.ibm.com> X-TM-AS-MML: disable x-cbid: 17062117-0024-0000-0000-000001825B81 X-IBM-AV-DETECTION: SAVI=unused REMOTE=unused XFE=unused x-cbparentid: 17062117-0025-0000-0000-0000164A9F9C Message-Id: <1498067125-30472-4-git-send-email-gftg@linux.vnet.ibm.com> X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10432:, , definitions=2017-06-21_04:, , signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 suspectscore=1 malwarescore=0 phishscore=0 adultscore=0 bulkscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1703280000 definitions=main-1706210298 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 * 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(+) 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