diff options
Diffstat (limited to 'man0p/math.h.0p')
| -rw-r--r-- | man0p/math.h.0p | 487 |
1 files changed, 487 insertions, 0 deletions
diff --git a/man0p/math.h.0p b/man0p/math.h.0p new file mode 100644 index 000000000..3c598f670 --- /dev/null +++ b/man0p/math.h.0p @@ -0,0 +1,487 @@ +.\" Copyright (c) 2001-2003 The Open Group, All Rights Reserved +.TH "<math.h>" P 2003 "IEEE/The Open Group" "POSIX Programmer's Manual" +.\" <math.h> +.SH NAME +math.h \- mathematical declarations +.SH SYNOPSIS +.LP +\fB#include <math.h>\fP +.SH DESCRIPTION +.LP +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 IEEE\ Std\ 1003.1-2001, Section 2.2, The Compilation Environment) +to enable the visibility of these symbols in this +header. +.LP +The \fI<math.h>\fP header shall include definitions for at least the +following types: +.TP 7 +\fBfloat_t\fP +A real-floating type at least as wide as \fBfloat\fP. +.TP 7 +\fBdouble_t\fP +A real-floating type at least as wide as \fBdouble\fP, and at least +as wide as \fBfloat_t\fP. +.sp +.LP +If FLT_EVAL_METHOD equals 0, \fBfloat_t\fP and \fBdouble_t\fP shall +be \fBfloat\fP and \fBdouble\fP, respectively; if +FLT_EVAL_METHOD equals 1, they shall both be \fBdouble\fP; if FLT_EVAL_METHOD +equals 2, they shall both be \fBlong double\fP; for +other values of FLT_EVAL_METHOD, they are otherwise implementation-defined. +.LP +The \fI<math.h>\fP header shall define the following macros, where +real-floating indicates that the argument shall be an +expression of real-floating type: +.sp +.RS +.nf + +\fBint fpclassify(real-floating x); +int isfinite(real-floating x); +int isinf(real-floating x); +int isnan(real-floating x); +int isnormal(real-floating x); +int signbit(real-floating x); +int isgreater(real-floating x, real-floating y); +int isgreaterequal(real-floating x, real-floating y); +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 isunordered(real-floating x, real-floating y); +\fP +.fi +.RE +.LP +The \fI<math.h>\fP header shall provide for the following constants. +The values are of type \fBdouble\fP and are +accurate within the precision of the \fBdouble\fP type. +.TP 7 +M_E +Value of \fIe\fP +.TP 7 +M_LOG2E +Value of log_2\fIe\fP +.TP 7 +M_LOG10E +Value of log_10\fIe\fP +.TP 7 +M_LN2 +Value of log_e2 +.TP 7 +M_LN10 +Value of log_e10 +.TP 7 +M_PI +Value of pi +.TP 7 +M_PI_2 +Value of pi/2 +.TP 7 +M_PI_4 +Value of pi/4 +.TP 7 +M_1_PI +Value of 1/pi +.TP 7 +M_2_PI +Value of 2/pi +.TP 7 +M_2_SQRTPI +Value of 2/ sqrt pi +.TP 7 +M_SQRT2 +Value of sqrt 2 +.TP 7 +M_SQRT1_2 +Value of 1/sqrt 2 +.sp +.LP +The header shall define the following symbolic constants: +.TP 7 +MAXFLOAT +Value of maximum non-infinite single-precision floating-point number. +.TP 7 +HUGE_VAL +A positive \fBdouble\fP expression, not necessarily representable +as a \fBfloat\fP. Used as an error value returned by the +mathematics library. HUGE_VAL evaluates to +infinity on systems supporting +IEEE\ Std\ 754-1985. +.TP 7 +HUGE_VALF +A positive \fBfloat\fP constant expression. Used as an error value +returned by the mathematics library. HUGE_VALF evaluates to ++infinity on systems supporting IEEE\ Std\ 754-1985. +.TP 7 +HUGE_VALL +A positive \fBlong double\fP constant expression. Used as an error +value returned by the mathematics library. HUGE_VALL +evaluates to +infinity on systems supporting IEEE\ Std\ 754-1985. +.TP 7 +INFINITY +A constant expression of type \fBfloat\fP representing positive or +unsigned infinity, if available; else a positive constant +of type \fBfloat\fP that overflows at translation time. +.TP 7 +NAN +A constant expression of type \fBfloat\fP representing a quiet NaN. +This symbolic constant is only defined if the +implementation supports quiet NaNs for the \fBfloat\fP type. +.sp +.LP +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 +.nf + +FP_INFINITE +FP_NAN +FP_NORMAL +FP_SUBNORMAL +FP_ZERO +.fi +.RE +.LP +The following optional macros indicate whether the \fIfma\fP() family +of functions are fast +compared with direct code: +.sp +.RS +.nf + +FP_FAST_FMA +FP_FAST_FMAF +FP_FAST_FMAL +.fi +.RE +.LP +The FP_FAST_FMA macro shall be defined to indicate that the \fIfma\fP() +function generally +executes about as fast as, or faster than, a multiply and an add of +\fBdouble\fP operands. The other macros have the equivalent +meaning for the \fBfloat\fP and \fBlong double\fP versions. +.LP +The following macros shall expand to integer constant expressions +whose values are returned by \fIilogb\fP( \fIx\fP) if +\fIx\fP is zero or NaN, respectively. The value of FP_ILOGB0 shall +be either {INT_MIN} or - {INT_MAX}. The value of FP_ILOGBNAN +shall be either {INT_MAX} or {INT_MIN}. +.sp +.RS +.nf + +FP_ILOGB0 +FP_ILOGBNAN +.fi +.RE +.LP +The following macros shall expand to the integer constants 1 and 2, +respectively; +.sp +.RS +.nf + +MATH_ERRNO +MATH_ERREXCEPT +.fi +.RE +.LP +The following macro shall expand to an expression that has type \fBint\fP +and the value MATH_ERRNO, MATH_ERREXCEPT, or the +bitwise-inclusive OR of both: +.sp +.RS +.nf + +math_errhandling +.fi +.RE +.LP +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 \fI<fenv.h>\fP. +.LP +The following shall be declared as functions and may also be defined +as macros. Function prototypes shall be provided. +.sp +.RS +.nf + +\fBdouble 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 value, int *); +long double frexpl(long double value, 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 scalb(double, 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); + +\fP +.fi +.RE +.LP +The following external variable shall be defined: +.sp +.RS +.nf + +\fB +extern int signgam; + +\fP +.fi +.RE +.LP +The behavior of each of the functions defined in \fI<math.h>\fP is +specified in the System Interfaces volume of +IEEE\ Std\ 1003.1-2001 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 +\fIThe following sections are informative.\fP +.SH APPLICATION USAGE +.LP +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. +.SH RATIONALE +.LP +Before the ISO/IEC\ 9899:1999 standard, the math library was defined +only for the floating type \fBdouble\fP. All the names +formed by appending \fB'f'\fP or \fB'l'\fP to a name in \fI<math.h>\fP +were reserved to allow for the definition of +\fBfloat\fP and \fBlong double\fP libraries; and the ISO/IEC\ 9899:1999 +standard provides for all three versions of math +functions. +.LP +The functions \fIecvt\fP(), \fIfcvt\fP(), and \fIgcvt\fP() have been +dropped from the ISO\ C standard since their capability is available +through \fIsprintf\fP(). These are provided on XSI-conformant systems +supporting the +Legacy Option Group. +.SH FUTURE DIRECTIONS +.LP +None. +.SH SEE ALSO +.LP +\fI<stddef.h>\fP , \fI<sys/types.h>\fP , the System +Interfaces volume of IEEE\ Std\ 1003.1-2001, \fIacos\fP(), \fIacosh\fP(), +\fIasin\fP(), \fIatan\fP(), \fIatan2\fP(), \fIcbrt\fP(), \fIceil\fP(), +\fIcos\fP(), \fIcosh\fP(), \fIerf\fP(), \fIexp\fP(), \fIexpm1\fP(), +\fIfabs\fP(), \fIfloor\fP(), \fIfmod\fP(), \fIfrexp\fP(), \fIhypot\fP(), +\fIilogb\fP(), \fIisnan\fP(), \fIj0\fP(), \fIldexp\fP(), \fIlgamma\fP(), +\fIlog\fP(), \fIlog10\fP(), \fIlog1p\fP(), \fIlogb\fP(), \fImodf\fP(), +\fInextafter\fP(), \fIpow\fP(), \fIremainder\fP(), \fIrint\fP(), \fIscalb\fP(), +\fIsin\fP(), \fIsinh\fP(), \fIsqrt\fP(), \fItan\fP(), \fItanh\fP(), +\fIy0\fP() +.SH COPYRIGHT +Portions of this text are reprinted and reproduced in electronic form +from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology +-- Portable Operating System Interface (POSIX), The Open Group Base +Specifications Issue 6, Copyright (C) 2001-2003 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 . |