diff options
Diffstat (limited to 'man-pages-posix-2017/man0p/math.h.0p')
| -rw-r--r-- | man-pages-posix-2017/man0p/math.h.0p | 588 |
1 files changed, 588 insertions, 0 deletions
diff --git a/man-pages-posix-2017/man0p/math.h.0p b/man-pages-posix-2017/man0p/math.h.0p new file mode 100644 index 0000000..e9fc2dd --- /dev/null +++ b/man-pages-posix-2017/man0p/math.h.0p @@ -0,0 +1,588 @@ +'\" et +.TH math.h "0P" 2017 "IEEE/The Open Group" "POSIX Programmer's Manual" +.\" +.SH PROLOG +This manual page is part of the POSIX Programmer's Manual. +The Linux implementation of this interface may differ (consult +the corresponding Linux manual page for details of Linux behavior), +or the interface may not be implemented on Linux. +.\" +.EQ +delim $$ +.EN +.SH NAME +math.h +\(em mathematical declarations +.SH SYNOPSIS +.LP +.nf +#include <math.h> +.fi +.SH DESCRIPTION +Some of the functionality described on this reference page extends the +ISO\ C standard. Applications shall define the appropriate feature test macro +(see the System Interfaces volume of POSIX.1\(hy2017, +.IR "Section 2.2" ", " "The Compilation Environment") +to enable the visibility of these symbols in this header. +.P +The +.IR <math.h> +header shall define at least the following types: +.IP "\fBfloat_t\fR" 12 +A real-floating type at least as wide as +.BR float . +.IP "\fBdouble_t\fR" 12 +A real-floating type at least as wide as +.BR double , +and at least as wide as +.BR float_t . +.P +If FLT_EVAL_METHOD equals 0, +.BR float_t +and +.BR double_t +shall be +.BR float +and +.BR double , +respectively; if FLT_EVAL_METHOD equals 1, they shall both be +.BR double ; +if FLT_EVAL_METHOD equals 2, they shall both be +.BR "long double" ; +for other values of FLT_EVAL_METHOD, they are otherwise +implementation-defined. +.P +The +.IR <math.h> +header shall define the following macros, where real-floating indicates +that the argument shall be an expression of real-floating type: +.sp +.RS 4 +.nf + +int fpclassify(real-floating x); +int isfinite(real-floating x); +int isgreater(real-floating x, real-floating y); +int isgreaterequal(real-floating x, real-floating y); +int isinf(real-floating x); +int isless(real-floating x, real-floating y); +int islessequal(real-floating x, real-floating y); +int islessgreater(real-floating x, real-floating y); +int isnan(real-floating x); +int isnormal(real-floating x); +int isunordered(real-floating x, real-floating y); +int signbit(real-floating x); +.fi +.P +.RE +.P +The +.IR <math.h> +header shall define the following symbolic constants. The values +shall have type +.BR double +and shall be accurate to at least the precision of the +.BR double +type. +.IP M_E 12 +Value of $e$ +.IP M_LOG2E 12 +Value of $log_ 2" " e$ +.IP M_LOG10E 12 +Value of $log_ 10" " e$ +.IP M_LN2 12 +Value of $log_ e" " 2$ +.IP M_LN10 12 +Value of $log_ e" " 10$ +.IP M_PI 12 +Value of $pi$ +.IP M_PI_2 12 +Value of $pi /2$ +.IP M_PI_4 12 +Value of $pi /4$ +.IP M_1_PI 12 +Value of $1/ pi$ +.IP M_2_PI 12 +Value of $2/ pi$ +.IP M_2_SQRTPI 12 +Value of $2/ sqrt pi$ +.IP M_SQRT2 12 +Value of $sqrt 2$ +.IP M_SQRT1_2 12 +Value of $1/ sqrt 2$ +.P +The +.IR <math.h> +header shall define the following symbolic constant: +.IP MAXFLOAT 12 +Same value as FLT_MAX in +.IR <float.h> . +.P +The +.IR <math.h> +header shall define the following macros: +.IP HUGE_VAL 12 +A positive +.BR double +constant expression, not necessarily representable as a +.BR float . +Used as an error value returned by the mathematics library. HUGE_VAL +evaluates to +infinity on systems supporting IEEE\ Std\ 754\(hy1985. +.IP HUGE_VALF 12 +A positive +.BR float +constant expression. Used as an error value returned by the mathematics +library. HUGE_VALF evaluates to +infinity on systems supporting IEEE\ Std\ 754\(hy1985. +.IP HUGE_VALL 12 +A positive +.BR "long double" +constant expression. Used as an error value returned by the mathematics +library. HUGE_VALL evaluates to +infinity on systems supporting IEEE\ Std\ 754\(hy1985. +.IP INFINITY 12 +A constant expression of type +.BR float +representing positive or unsigned infinity, if available; else a +positive constant of type +.BR float +that overflows at translation time. +.IP NAN 12 +A constant expression of type +.BR float +representing a quiet NaN. This macro is only defined if the +implementation supports quiet NaNs for the +.BR float +type. +.P +The following macros shall be defined for number classification. They +represent the mutually-exclusive kinds of floating-point values. They +expand to integer constant expressions with distinct values. Additional +implementation-defined floating-point classifications, with macro +definitions beginning with FP_ and an uppercase letter, may also be +specified by the implementation. +.sp +.RS +FP_INFINITE +FP_NAN +FP_NORMAL +FP_SUBNORMAL +FP_ZERO +.RE +.P +The following optional macros indicate whether the +\fIfma\fR() +family of functions are fast compared with direct code: +.sp +.RS +FP_FAST_FMA +FP_FAST_FMAF +FP_FAST_FMAL +.RE +.P +If defined, the FP_FAST_FMA macro shall expand to the integer constant +1 and shall indicate that the +\fIfma\fR() +function generally executes about as fast as, or faster than, a +multiply and an add of +.BR double +operands. If undefined, the speed of execution is unspecified. The +other macros have the equivalent meaning for the +.BR float +and +.BR "long double" +versions. +.P +The following macros shall expand to integer constant expressions whose +values are returned by +.IR ilogb (\c +.IR x ) +if +.IR x +is zero or NaN, respectively. The value of FP_ILOGB0 shall be either +{INT_MIN} +or \-\c +{INT_MAX}. +The value of FP_ILOGBNAN shall be either +{INT_MAX} +or +{INT_MIN}. +.sp +.RS +FP_ILOGB0 +FP_ILOGBNAN +.RE +.P +The following macros shall expand to the integer constants 1 and 2, +respectively; +.sp +.RS +MATH_ERRNO +MATH_ERREXCEPT +.RE +.P +The following macro shall expand to an expression that has type +.BR int +and the value MATH_ERRNO, MATH_ERREXCEPT, or the bitwise-inclusive OR +of both: +.sp +.RS +math_errhandling +.RE +.P +The value of math_errhandling is constant for the duration of the +program. It is unspecified whether math_errhandling is a macro or an +identifier with external linkage. If a macro definition is suppressed +or a program defines an identifier with the name math_errhandling , the +behavior is undefined. If the expression (math_errhandling & +MATH_ERREXCEPT) can be non-zero, the implementation shall define the +macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in +.IR <fenv.h> . +.P +The following shall be declared as functions and may also be defined as +macros. Function prototypes shall be provided. +.sp +.RS 4 +.nf + +double acos(double); +float acosf(float); +double acosh(double); +float acoshf(float); +long double acoshl(long double); +long double acosl(long double); +double asin(double); +float asinf(float); +double asinh(double); +float asinhf(float); +long double asinhl(long double); +long double asinl(long double); +double atan(double); +double atan2(double, double); +float atan2f(float, float); +long double atan2l(long double, long double); +float atanf(float); +double atanh(double); +float atanhf(float); +long double atanhl(long double); +long double atanl(long double); +double cbrt(double); +float cbrtf(float); +long double cbrtl(long double); +double ceil(double); +float ceilf(float); +long double ceill(long double); +double copysign(double, double); +float copysignf(float, float); +long double copysignl(long double, long double); +double cos(double); +float cosf(float); +double cosh(double); +float coshf(float); +long double coshl(long double); +long double cosl(long double); +double erf(double); +double erfc(double); +float erfcf(float); +long double erfcl(long double); +float erff(float); +long double erfl(long double); +double exp(double); +double exp2(double); +float exp2f(float); +long double exp2l(long double); +float expf(float); +long double expl(long double); +double expm1(double); +float expm1f(float); +long double expm1l(long double); +double fabs(double); +float fabsf(float); +long double fabsl(long double); +double fdim(double, double); +float fdimf(float, float); +long double fdiml(long double, long double); +double floor(double); +float floorf(float); +long double floorl(long double); +double fma(double, double, double); +float fmaf(float, float, float); +long double fmal(long double, long double, long double); +double fmax(double, double); +float fmaxf(float, float); +long double fmaxl(long double, long double); +double fmin(double, double); +float fminf(float, float); +long double fminl(long double, long double); +double fmod(double, double); +float fmodf(float, float); +long double fmodl(long double, long double); +double frexp(double, int *); +float frexpf(float, int *); +long double frexpl(long double, int *); +double hypot(double, double); +float hypotf(float, float); +long double hypotl(long double, long double); +int ilogb(double); +int ilogbf(float); +int ilogbl(long double); +double j0(double); +double j1(double); +double jn(int, double); +double ldexp(double, int); +float ldexpf(float, int); +long double ldexpl(long double, int); +double lgamma(double); +float lgammaf(float); +long double lgammal(long double); +long long llrint(double); +long long llrintf(float); +long long llrintl(long double); +long long llround(double); +long long llroundf(float); +long long llroundl(long double); +double log(double); +double log10(double); +float log10f(float); +long double log10l(long double); +double log1p(double); +float log1pf(float); +long double log1pl(long double); +double log2(double); +float log2f(float); +long double log2l(long double); +double logb(double); +float logbf(float); +long double logbl(long double); +float logf(float); +long double logl(long double); +long lrint(double); +long lrintf(float); +long lrintl(long double); +long lround(double); +long lroundf(float); +long lroundl(long double); +double modf(double, double *); +float modff(float, float *); +long double modfl(long double, long double *); +double nan(const char *); +float nanf(const char *); +long double nanl(const char *); +double nearbyint(double); +float nearbyintf(float); +long double nearbyintl(long double); +double nextafter(double, double); +float nextafterf(float, float); +long double nextafterl(long double, long double); +double nexttoward(double, long double); +float nexttowardf(float, long double); +long double nexttowardl(long double, long double); +double pow(double, double); +float powf(float, float); +long double powl(long double, long double); +double remainder(double, double); +float remainderf(float, float); +long double remainderl(long double, long double); +double remquo(double, double, int *); +float remquof(float, float, int *); +long double remquol(long double, long double, int *); +double rint(double); +float rintf(float); +long double rintl(long double); +double round(double); +float roundf(float); +long double roundl(long double); +double scalbln(double, long); +float scalblnf(float, long); +long double scalblnl(long double, long); +double scalbn(double, int); +float scalbnf(float, int); +long double scalbnl(long double, int); +double sin(double); +float sinf(float); +double sinh(double); +float sinhf(float); +long double sinhl(long double); +long double sinl(long double); +double sqrt(double); +float sqrtf(float); +long double sqrtl(long double); +double tan(double); +float tanf(float); +double tanh(double); +float tanhf(float); +long double tanhl(long double); +long double tanl(long double); +double tgamma(double); +float tgammaf(float); +long double tgammal(long double); +double trunc(double); +float truncf(float); +long double truncl(long double); +double y0(double); +double y1(double); +double yn(int, double); +.fi +.P +.RE +.P +The following external variable shall be defined: +.sp +.RS 4 +.nf + +extern int signgam; +.fi +.P +.RE +.P +The behavior of each of the functions defined in +.IR <math.h> +is specified in the System Interfaces volume of POSIX.1\(hy2017 for all representable values of its input +arguments, except where stated otherwise. Each function shall execute +as if it were a single operation without generating any externally +visible exceptional conditions. +.LP +.IR "The following sections are informative." +.SH "APPLICATION USAGE" +The FP_CONTRACT pragma can be used to allow (if the state is on) or +disallow (if the state is off) the implementation to contract +expressions. Each pragma can occur either outside external declarations +or preceding all explicit declarations and statements inside a compound +statement. When outside external declarations, the pragma takes effect +from its occurrence until another FP_CONTRACT pragma is encountered, or +until the end of the translation unit. When inside a compound +statement, the pragma takes effect from its occurrence until another +FP_CONTRACT pragma is encountered (including within a nested compound +statement), or until the end of the compound statement; at the end of a +compound statement the state for the pragma is restored to its +condition just before the compound statement. If this pragma is used in +any other context, the behavior is undefined. The default state (on or +off) for the pragma is implementation-defined. +.P +Applications should use FLT_MAX as described in the +.IR <float.h> +header instead of the obsolescent MAXFLOAT. +.P +Note that if FLT_EVAL_METHOD is neither 0 nor 1, then some constants might +not compare equal as expected; for example, \fR(double)M_PI == M_PI\fR +can fail. +.SH RATIONALE +Before the ISO/IEC\ 9899:\|1999 standard, the math library was defined only for the floating +type +.BR double . +All the names formed by appending +.BR 'f' +or +.BR 'l' +to a name in +.IR <math.h> +were reserved to allow for the definition of +.BR float +and +.BR "long double" +libraries; and the ISO/IEC\ 9899:\|1999 standard provides for all three versions of math +functions. +.P +The functions +.IR ecvt (\|), +.IR fcvt (\|), +and +.IR gcvt (\|) +have been dropped from the ISO\ C standard since their capability is available +through +\fIsprintf\fR(). +.SH "FUTURE DIRECTIONS" +None. +.SH "SEE ALSO" +.IR "\fB<float.h>\fP", +.IR "\fB<stddef.h>\fP", +.IR "\fB<sys_types.h>\fP" +.P +The System Interfaces volume of POSIX.1\(hy2017, +.IR "Section 2.2" ", " "The Compilation Environment", +.IR "\fIacos\fR\^(\|)", +.IR "\fIacosh\fR\^(\|)", +.IR "\fIasin\fR\^(\|)", +.IR "\fIasinh\fR\^(\|)", +.IR "\fIatan\fR\^(\|)", +.IR "\fIatan2\fR\^(\|)", +.IR "\fIatanh\fR\^(\|)", +.IR "\fIcbrt\fR\^(\|)", +.IR "\fIceil\fR\^(\|)", +.IR "\fIcopysign\fR\^(\|)", +.IR "\fIcos\fR\^(\|)", +.IR "\fIcosh\fR\^(\|)", +.IR "\fIerf\fR\^(\|)", +.IR "\fIerfc\fR\^(\|)", +.IR "\fIexp\fR\^(\|)", +.IR "\fIexp2\fR\^(\|)", +.IR "\fIexpm1\fR\^(\|)", +.IR "\fIfabs\fR\^(\|)", +.IR "\fIfdim\fR\^(\|)", +.IR "\fIfloor\fR\^(\|)", +.IR "\fIfma\fR\^(\|)", +.IR "\fIfmax\fR\^(\|)", +.IR "\fIfmin\fR\^(\|)", +.IR "\fIfmod\fR\^(\|)", +.IR "\fIfpclassify\fR\^(\|)", +.IR "\fIfrexp\fR\^(\|)", +.IR "\fIhypot\fR\^(\|)", +.IR "\fIilogb\fR\^(\|)", +.IR "\fIisfinite\fR\^(\|)", +.IR "\fIisgreater\fR\^(\|)", +.IR "\fIisgreaterequal\fR\^(\|)", +.IR "\fIisinf\fR\^(\|)", +.IR "\fIisless\fR\^(\|)", +.IR "\fIislessequal\fR\^(\|)", +.IR "\fIislessgreater\fR\^(\|)", +.IR "\fIisnan\fR\^(\|)", +.IR "\fIisnormal\fR\^(\|)", +.IR "\fIisunordered\fR\^(\|)", +.IR "\fIj0\fR\^(\|)", +.IR "\fIldexp\fR\^(\|)", +.IR "\fIlgamma\fR\^(\|)", +.IR "\fIllrint\fR\^(\|)", +.IR "\fIllround\fR\^(\|)", +.IR "\fIlog\fR\^(\|)", +.IR "\fIlog10\fR\^(\|)", +.IR "\fIlog1p\fR\^(\|)", +.IR "\fIlog2\fR\^(\|)", +.IR "\fIlogb\fR\^(\|)", +.IR "\fIlrint\fR\^(\|)", +.IR "\fIlround\fR\^(\|)", +.IR "\fImodf\fR\^(\|)", +.IR "\fInan\fR\^(\|)", +.IR "\fInearbyint\fR\^(\|)", +.IR "\fInextafter\fR\^(\|)", +.IR "\fIpow\fR\^(\|)", +.IR "\fIremainder\fR\^(\|)", +.IR "\fIremquo\fR\^(\|)", +.IR "\fIrint\fR\^(\|)", +.IR "\fIround\fR\^(\|)", +.IR "\fIscalbln\fR\^(\|)", +.IR "\fIsignbit\fR\^(\|)", +.IR "\fIsin\fR\^(\|)", +.IR "\fIsinh\fR\^(\|)", +.IR "\fIsqrt\fR\^(\|)", +.IR "\fItan\fR\^(\|)", +.IR "\fItanh\fR\^(\|)", +.IR "\fItgamma\fR\^(\|)", +.IR "\fItrunc\fR\^(\|)", +.IR "\fIy0\fR\^(\|)" +.\" +.SH COPYRIGHT +Portions of this text are reprinted and reproduced in electronic form +from IEEE Std 1003.1-2017, Standard for Information Technology +-- Portable Operating System Interface (POSIX), The Open Group Base +Specifications Issue 7, 2018 Edition, +Copyright (C) 2018 by the Institute of +Electrical and Electronics Engineers, Inc and The Open Group. +In the event of any discrepancy between this version and the original IEEE and +The Open Group Standard, the original IEEE and The Open Group Standard +is the referee document. The original Standard can be obtained online at +http://www.opengroup.org/unix/online.html . +.PP +Any typographical or formatting errors that appear +in this page are most likely +to have been introduced during the conversion of the source files to +man page format. To report such errors, see +https://www.kernel.org/doc/man-pages/reporting_bugs.html . |