|
|
|
Classes | |
| class | half |
Functions | |
Comparison operators | |
| HALF_CONSTEXPR_NOERR bool | operator== (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | operator!= (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | operator< (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | operator> (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | operator<= (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | operator>= (half x, half y) |
Arithmetic operators | |
| HALF_CONSTEXPR half | operator+ (half arg) |
| HALF_CONSTEXPR half | operator- (half arg) |
| half | operator+ (half x, half y) |
| half | operator- (half x, half y) |
| half | operator* (half x, half y) |
| half | operator/ (half x, half y) |
Input and output | |
| template<typename charT , typename traits > | |
| std::basic_ostream< charT, traits > & | operator<< (std::basic_ostream< charT, traits > &out, half arg) |
| template<typename charT , typename traits > | |
| std::basic_istream< charT, traits > & | operator>> (std::basic_istream< charT, traits > &in, half &arg) |
Basic mathematical operations | |
| HALF_CONSTEXPR half | fabs (half arg) |
| HALF_CONSTEXPR half | abs (half arg) |
| half | fmod (half x, half y) |
| half | remainder (half x, half y) |
| half | remquo (half x, half y, int *quo) |
| half | fma (half x, half y, half z) |
| HALF_CONSTEXPR_NOERR half | fmax (half x, half y) |
| HALF_CONSTEXPR_NOERR half | fmin (half x, half y) |
| half | fdim (half x, half y) |
| half | nanh (const char *arg) |
Exponential functions | |
| half | exp (half arg) |
| half | exp2 (half arg) |
| half | expm1 (half arg) |
| half | log (half arg) |
| half | log10 (half arg) |
| half | log2 (half arg) |
| half | log1p (half arg) |
Power functions | |
| half | sqrt (half arg) |
| half | rsqrt (half arg) |
| half | cbrt (half arg) |
| half | hypot (half x, half y) |
| half | hypot (half x, half y, half z) |
| half | pow (half x, half y) |
Trigonometric functions | |
| void | sincos (half arg, half *sin, half *cos) |
| half | sin (half arg) |
| half | cos (half arg) |
| half | tan (half arg) |
| half | asin (half arg) |
| half | acos (half arg) |
| half | atan (half arg) |
| half | atan2 (half y, half x) |
Hyperbolic functions | |
| half | sinh (half arg) |
| half | cosh (half arg) |
| half | tanh (half arg) |
| half | asinh (half arg) |
| half | acosh (half arg) |
| half | atanh (half arg) |
Error and gamma functions | |
| half | erf (half arg) |
| half | erfc (half arg) |
| half | lgamma (half arg) |
| half | tgamma (half arg) |
Rounding | |
| half | ceil (half arg) |
| half | floor (half arg) |
| half | trunc (half arg) |
| half | round (half arg) |
| long | lround (half arg) |
| half | rint (half arg) |
| long | lrint (half arg) |
| half | nearbyint (half arg) |
Floating point manipulation | |
| half | frexp (half arg, int *exp) |
| half | scalbln (half arg, long exp) |
| half | scalbn (half arg, int exp) |
| half | ldexp (half arg, int exp) |
| half | modf (half arg, half *iptr) |
| int | ilogb (half arg) |
| half | logb (half arg) |
| half | nextafter (half from, half to) |
| half | nexttoward (half from, long double to) |
| HALF_CONSTEXPR half | copysign (half x, half y) |
Floating point classification | |
| HALF_CONSTEXPR int | fpclassify (half arg) |
| HALF_CONSTEXPR bool | isfinite (half arg) |
| HALF_CONSTEXPR bool | isinf (half arg) |
| HALF_CONSTEXPR bool | isnan (half arg) |
| HALF_CONSTEXPR bool | isnormal (half arg) |
| HALF_CONSTEXPR bool | signbit (half arg) |
Comparison | |
| HALF_CONSTEXPR bool | isgreater (half x, half y) |
| HALF_CONSTEXPR bool | isgreaterequal (half x, half y) |
| HALF_CONSTEXPR bool | isless (half x, half y) |
| HALF_CONSTEXPR bool | islessequal (half x, half y) |
| HALF_CONSTEXPR bool | islessgreater (half x, half y) |
| HALF_CONSTEXPR bool | isunordered (half x, half y) |
Casting | |
| template<typename T , typename U > | |
| T | half_cast (U arg) |
| template<typename T , std::float_round_style R, typename U > | |
| T | half_cast (U arg) |
Error handling | |
| int | feclearexcept (int excepts) |
| int | fetestexcept (int excepts) |
| int | feraiseexcept (int excepts) |
| int | fegetexceptflag (int *flagp, int excepts) |
| int | fesetexceptflag (const int *flagp, int excepts) |
| void | fethrowexcept (int excepts, const char *msg="") |
Main namespace for half-precision functionality. This namespace contains all the functionality provided by the library.
Arc cosine function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::acos.
| arg | function argument |
| FE_INVALID | for signaling NaN or if abs(arg) > 1 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hyperbolic area cosine. This function is exact to rounding for all rounding modes.
See also: Documentation for std::acosh.
| arg | function argument |
| FE_INVALID | for signaling NaN or arguments <1 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Arc sine. This function is exact to rounding for all rounding modes.
See also: Documentation for std::asin.
| arg | function argument |
| FE_INVALID | for signaling NaN or if abs(arg) > 1 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hyperbolic area sine. This function is exact to rounding for all rounding modes.
See also: Documentation for std::asinh.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Arc tangent function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::atan.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Arc tangent function. This function may be 1 ULP off the correctly rounded exact result in ~0.005% of inputs for std::round_to_nearest, in ~0.1% of inputs for std::round_toward_zero and in ~0.02% of inputs for any other rounding mode.
See also: Documentation for std::atan2.
| y | numerator |
| x | denominator |
| FE_INVALID | if x or y is signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hyperbolic area tangent. This function is exact to rounding for all rounding modes.
See also: Documentation for std::atanh.
| arg | function argument |
| FE_INVALID | for signaling NaN or if abs(arg) > 1 |
| FE_DIVBYZERO | for +/-1 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Take sign. See also: Documentation for std::copysign.
| x | value to change sign for |
| y | value to take sign from |
Cosine function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::cos.
| arg | function argument |
| FE_INVALID | for signaling NaN or infinity |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hyperbolic cosine. This function is exact to rounding for all rounding modes.
See also: Documentation for std::cosh.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Error function. This function may be 1 ULP off the correctly rounded exact result for any rounding mode in <0.5% of inputs.
See also: Documentation for std::erf.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Complementary error function. This function may be 1 ULP off the correctly rounded exact result for any rounding mode in <0.5% of inputs.
See also: Documentation for std::erfc.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Exponential function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::exp.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Binary exponential. This function is exact to rounding for all rounding modes.
See also: Documentation for std::exp2.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Exponential minus one. This function may be 1 ULP off the correctly rounded exact result in <0.05% of inputs for std::round_to_nearest and in <1% of inputs for any other rounding mode.
See also: Documentation for std::expm1.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Positive difference. This function is exact to rounding for all rounding modes.
See also: Documentation for std::fdim.
| x | first operand |
| y | second operand |
| FE_... | according to operator-(half,half) |
|
inline |
Clear exception flags. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.
See also: Documentation for std::feclearexcept.
| excepts | OR of exceptions to clear |
| 0 | all selected flags cleared successfully |
|
inline |
Save exception flags. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.
See also: Documentation for std::fegetexceptflag.
| flagp | adress to store flag state at |
| excepts | OR of flags to save |
| 0 | for success |
|
inline |
Raise exception flags. This raises the specified floating point exceptions and also invokes any additional automatic exception handling as configured with the HALF_ERRHANDLIG_... preprocessor symbols. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.
See also: Documentation for std::feraiseexcept.
| excepts | OR of exceptions to raise |
| 0 | all selected exceptions raised successfully |
|
inline |
Restore exception flags. This only copies the specified exception state (including unset flags) without incurring any additional exception handling. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.
See also: Documentation for std::fesetexceptflag.
| flagp | adress to take flag state from |
| excepts | OR of flags to restore |
| 0 | for success |
|
inline |
Test exception flags. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.
See also: Documentation for std::fetestexcept.
| excepts | OR of exceptions to test |
|
inline |
Throw C++ exceptions based on set exception flags. This function manually throws a corresponding C++ exception if one of the specified flags is set, no matter if automatic throwing (via HALF_ERRHANDLING_THROW_...) is enabled or not. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.
| excepts | OR of exceptions to test |
| msg | error message to use for exception description |
| std::domain_error | if FE_INVALID or FE_DIVBYZERO is selected and set |
| std::overflow_error | if FE_OVERFLOW is selected and set |
| std::underflow_error | if FE_UNDERFLOW is selected and set |
| std::range_error | if FE_INEXACT is selected and set |
Nearest integer not greater than half value. See also: Documentation for std::floor.
| arg | half to round |
| FE_INVALID | for signaling NaN |
| FE_INEXACT | if value had to be rounded |
Fused multiply add. This function is exact to rounding for all rounding modes.
See also: Documentation for std::fma.
| x | first operand |
| y | second operand |
| z | third operand |
| FE_INVALID | according to operator*() and operator+() unless any argument is a quiet NaN and no argument is a signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding the final addition |
|
inline |
Classify floating-point value. See also: Documentation for std::fpclassify.
| arg | number to classify |
| FP_ZERO | for positive and negative zero |
| FP_SUBNORMAL | for subnormal numbers |
| FP_INFINITY | for positive and negative infinity |
| FP_NAN | for NaNs |
| FP_NORMAL | for all other (normal) values |
Decompress floating-point number. See also: Documentation for std::frexp.
| arg | number to decompress |
| exp | address to store exponent at |
| FE_INVALID | for signaling NaN |
| T half_float::half_cast | ( | U | arg | ) |
Cast to or from half-precision floating-point number. This casts between half and any built-in arithmetic type. The values are converted directly using the default rounding mode, without any roundtrip over float that a static_cast would otherwise do.
Using this cast with neither of the two types being a half or with any of the two types not being a built-in arithmetic type (apart from half, of course) results in a compiler error and casting between halfs returns the argument unmodified.
| T | destination type (half or built-in arithmetic type) |
| U | source type (half or built-in arithmetic type) |
| arg | value to cast |
| FE_INVALID | if T is integer type and result is not representable as T |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
| T half_float::half_cast | ( | U | arg | ) |
Cast to or from half-precision floating-point number. This casts between half and any built-in arithmetic type. The values are converted directly using the specified rounding mode, without any roundtrip over float that a static_cast would otherwise do.
Using this cast with neither of the two types being a half or with any of the two types not being a built-in arithmetic type (apart from half, of course) results in a compiler error and casting between halfs returns the argument unmodified.
| T | destination type (half or built-in arithmetic type) |
| R | rounding mode to use. |
| U | source type (half or built-in arithmetic type) |
| arg | value to cast |
| FE_INVALID | if T is integer type and result is not representable as T |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hypotenuse function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::hypot.
| x | first argument |
| y | second argument |
| FE_INVALID | if x or y is signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding of the final square root |
Hypotenuse function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::hypot.
| x | first argument |
| y | second argument |
| z | third argument |
| FE_INVALID | if x, y or z is signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding of the final square root |
|
inline |
Extract exponent. See also: Documentation for std::ilogb.
| arg | number to query |
| FP_ILOGB0 | for zero |
| FP_ILOGBNAN | for NaN |
| INT_MAX | for infinity |
| FE_INVALID | for 0 or infinite values |
|
inline |
Check if finite number. See also: Documentation for std::isfinite.
| arg | number to check |
| true | if neither infinity nor NaN |
| false | else |
Quiet comparison for greater than. See also: Documentation for std::isgreater.
| x | first operand |
| y | second operand |
| true | if x greater than y |
| false | else |
Quiet comparison for greater equal. See also: Documentation for std::isgreaterequal.
| x | first operand |
| y | second operand |
| true | if x greater equal y |
| false | else |
|
inline |
Check for infinity. See also: Documentation for std::isinf.
| arg | number to check |
| true | for positive or negative infinity |
| false | else |
Quiet comparison for less than. See also: Documentation for std::isless.
| x | first operand |
| y | second operand |
| true | if x less than y |
| false | else |
Quiet comparison for less equal. See also: Documentation for std::islessequal.
| x | first operand |
| y | second operand |
| true | if x less equal y |
| false | else |
Quiet comarison for less or greater. See also: Documentation for std::islessgreater.
| x | first operand |
| y | second operand |
| true | if either less or greater |
| false | else |
|
inline |
Check for NaN. See also: Documentation for std::isnan.
| arg | number to check |
| true | for NaNs |
| false | else |
|
inline |
Check if normal number. See also: Documentation for std::isnormal.
| arg | number to check |
| true | if normal number |
| false | if either subnormal, zero, infinity or NaN |
Quiet check if unordered. See also: Documentation for std::isunordered.
| x | first operand |
| y | second operand |
| true | if unordered (one or two NaN operands) |
| false | else |
Multiply by power of two. This function is exact to rounding for all rounding modes.
See also: Documentation for std::ldexp.
| arg | number to modify |
| exp | power of two to multiply with |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Natural logarithm of gamma function. This function may be 1 ULP off the correctly rounded exact result for any rounding mode in ~0.025% of inputs.
See also: Documentation for std::lgamma.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_DIVBYZERO | for 0 or negative integer arguments |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Natural logarithm. This function is exact to rounding for all rounding modes.
See also: Documentation for std::log.
| arg | function argument |
| FE_INVALID | for signaling NaN or negative argument |
| FE_DIVBYZERO | for 0 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Common logarithm. This function is exact to rounding for all rounding modes.
See also: Documentation for std::log10.
| arg | function argument |
| FE_INVALID | for signaling NaN or negative argument |
| FE_DIVBYZERO | for 0 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Natural logarithm plus one. This function may be 1 ULP off the correctly rounded exact result in <0.05% of inputs for std::round_to_nearest and in ~1% of inputs for any other rounding mode.
See also: Documentation for std::log1p.
| arg | function argument |
| FE_INVALID | for signaling NaN or argument <-1 |
| FE_DIVBYZERO | for -1 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Binary logarithm. This function is exact to rounding for all rounding modes.
See also: Documentation for std::log2.
| arg | function argument |
| FE_INVALID | for signaling NaN or negative argument |
| FE_DIVBYZERO | for 0 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
|
inline |
Nearest integer using half's internal rounding mode. See also: Documentation for std::lrint.
| arg | half expression to round |
| FE_INVALID | if value is not representable as long |
| FE_INEXACT | if value had to be rounded |
|
inline |
Nearest integer. See also: Documentation for std::lround.
| arg | half to round |
| FE_INVALID | if value is not representable as long |
|
inline |
Nearest integer using half's internal rounding mode. See also: Documentation for std::nearbyint.
| arg | half expression to round |
| FE_INVALID | for signaling NaN |
Next representable value. See also: Documentation for std::nextafter.
| from | value to compute next representable value for |
| to | direction towards which to compute next value |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW | for infinite result from finite argument |
| FE_UNDERFLOW | for subnormal result |
Next representable value. See also: Documentation for std::nexttoward.
| from | value to compute next representable value for |
| to | direction towards which to compute next value |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW | for infinite result from finite argument |
| FE_UNDERFLOW | for subnormal result |
Multiplication. This operation is exact to rounding for all rounding modes.
| x | left operand |
| y | right operand |
| FE_INVALID | if multiplying 0 with infinity or if x or y is signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Addition. This operation is exact to rounding for all rounding modes.
| x | left operand |
| y | right operand |
| FE_INVALID | if x and y are infinities with different signs or signaling NaNs |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Subtraction. This operation is exact to rounding for all rounding modes.
| x | left operand |
| y | right operand |
| FE_INVALID | if x and y are infinities with equal signs or signaling NaNs |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Division. This operation is exact to rounding for all rounding modes.
| x | left operand |
| y | right operand |
| FE_INVALID | if dividing 0s or infinities with each other or if x or y is signaling NaN |
| FE_DIVBYZERO | if dividing finite value by 0 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
| std::basic_ostream< charT, traits > & half_float::operator<< | ( | std::basic_ostream< charT, traits > & | out, |
| half | arg | ||
| ) |
| std::basic_istream< charT, traits > & half_float::operator>> | ( | std::basic_istream< charT, traits > & | in, |
| half & | arg | ||
| ) |
Input operator. This uses the built-in functionality for streaming in floating-point numbers, specifically double precision floating point numbers (unless overridden with HALF_ARITHMETIC_TYPE). So the input string is first rounded to double precision using the underlying platform's current floating-point rounding mode before being rounded to half-precision using the library's half-precision rounding mode.
| in | input stream to read from |
| arg | half to read into |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Power function. This function may be 1 ULP off the correctly rounded exact result for any rounding mode in ~0.00025% of inputs.
See also: Documentation for std::pow.
| x | base |
| y | exponent |
| FE_INVALID | if x or y is signaling NaN or if x is finite an negative and y is finite and not integral |
| FE_DIVBYZERO | if x is 0 and y is negative |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Remainder of division. See also: Documentation for std::remainder.
| x | first operand |
| y | second operand |
| FE_INVALID | if x is infinite or y is 0 or if x or y is signaling NaN |
Remainder of division. See also: Documentation for std::remquo.
| x | first operand |
| y | second operand |
| quo | address to store some bits of quotient at |
| FE_INVALID | if x is infinite or y is 0 or if x or y is signaling NaN |
Nearest integer. See also: Documentation for std::round.
| arg | half to round |
| FE_INVALID | for signaling NaN |
| FE_INEXACT | if value had to be rounded |
Inverse square root. This function is exact to rounding for all rounding modes and thus generally more accurate than directly computing 1 / sqrt(arg) in half-precision, in addition to also being faster.
| arg | function argument |
| FE_INVALID | for signaling NaN and negative arguments |
| FE_INEXACT | according to rounding |
Multiply by power of two. This function is exact to rounding for all rounding modes.
See also: Documentation for std::scalbln.
| arg | number to modify |
| exp | power of two to multiply with |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Multiply by power of two. This function is exact to rounding for all rounding modes.
See also: Documentation for std::scalbn.
| arg | number to modify |
| exp | power of two to multiply with |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
|
inline |
Check sign. See also: Documentation for std::signbit.
| arg | number to check |
| true | for negative number |
| false | for positive number |
Sine function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::sin.
| arg | function argument |
| FE_INVALID | for signaling NaN or infinity |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Compute sine and cosine simultaneously. This returns the same results as sin() and cos() but is faster than calling each function individually.
This function is exact to rounding for all rounding modes.
| arg | function argument |
| sin | variable to take sine of arg |
| cos | variable to take cosine of arg |
| FE_INVALID | for signaling NaN or infinity |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hyperbolic sine. This function is exact to rounding for all rounding modes.
See also: Documentation for std::sinh.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Square root. This function is exact to rounding for all rounding modes.
See also: Documentation for std::sqrt.
| arg | function argument |
| FE_INVALID | for signaling NaN and negative arguments |
| FE_INEXACT | according to rounding |
Tangent function. This function is exact to rounding for all rounding modes.
See also: Documentation for std::tan.
| arg | function argument |
| FE_INVALID | for signaling NaN or infinity |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Hyperbolic tangent. This function is exact to rounding for all rounding modes.
See also: Documentation for std::tanh.
| arg | function argument |
| FE_INVALID | for signaling NaN |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Gamma function. This function may be 1 ULP off the correctly rounded exact result for any rounding mode in <0.25% of inputs.
See also: Documentation for std::tgamma.
| arg | function argument |
| FE_INVALID | for signaling NaN, negative infinity or negative integer arguments |
| FE_DIVBYZERO | for 0 |
| FE_OVERFLOW,...UNDERFLOW,...INEXACT | according to rounding |
Nearest integer not greater in magnitude than half value. See also: Documentation for std::trunc.
| arg | half to round |
| FE_INVALID | for signaling NaN |
| FE_INEXACT | if value had to be rounded |
1.9.2