Home / cstd / math.ch

math.ch

Declarations

Public Only
Publicfunction fabsf
func fabsf(arg : float) : float
Computes the absolute value of a floating-point value arg.

Parameters

  • arg - floating-point value @return If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

Returns

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

See Also

  • https:en.cppreference.com/w/c/numeric/math/fabs
Publicfunction fabs
func fabs(arg : double) : double
Computes the absolute value of a floating-point value arg.

Parameters

  • arg - floating-point value @return If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

Returns

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

See Also

  • https:en.cppreference.com/w/c/numeric/math/fabs
Publicfunction fabsl
func fabsl(arg : unknown) : unknown
Computes the absolute value of a floating-point value arg.

Parameters

  • arg - floating-point value @return If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

Returns

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

See Also

  • https:en.cppreference.com/w/c/numeric/math/fabs
Publictypealias _Decimal32
type _Decimal32 = float
TODO
Publictypealias _Decimal64
type _Decimal64 = double
Publictypealias _Decimal128
type _Decimal128 = unknown
Publicfunction fabsd32
func fabsd32(arg : _Decimal32) : _Decimal32
Computes the absolute value of a floating-point value arg.

Parameters

  • arg - floating-point value @return If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

Returns

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

See Also

  • https:en.cppreference.com/w/c/numeric/math/fabs
Publicfunction fabsd64
func fabsd64(arg : _Decimal64) : _Decimal64
Computes the absolute value of a floating-point value arg.

Parameters

  • arg - floating-point value @return If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

Returns

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

See Also

  • https:en.cppreference.com/w/c/numeric/math/fabs
Publicfunction fabsd128
func fabsd128(arg : _Decimal128) : _Decimal128
Computes the absolute value of a floating-point value arg.

Parameters

  • arg - floating-point value @return If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

Returns

If successful, returns the absolute value of arg (|arg|). The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fabs

See Also

  • https:en.cppreference.com/w/c/numeric/math/fabs
Publicfunction fmodf
func fmodf(x : float, y : float) : float
Computes the floating-point remainder of the division operation x / y. The floating-point remainder of the division operation x / y calculated by this function is exactly the value x - n * y, where n is x / y with its fractional part truncated. The returned value has the same sign as x and is less or equal to y in magnitude. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • x, y - floating-point values @return If successful, returns the floating-point remainder of the division x / y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fmod

Returns

If successful, returns the floating-point remainder of the division x / y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fmod

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmod
Publicfunction fmod
func fmod(x : double, y : double) : double
Computes the floating-point remainder of the division operation x / y. The floating-point remainder of the division operation x / y calculated by this function is exactly the value x - n * y, where n is x / y with its fractional part truncated. The returned value has the same sign as x and is less or equal to y in magnitude. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • x, y - floating-point values @return If successful, returns the floating-point remainder of the division x / y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fmod

Returns

If successful, returns the floating-point remainder of the division x / y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fmod

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmod
Publicfunction fmodl
func fmodl(x : unknown, y : unknown) : unknown
Computes the floating-point remainder of the division operation x / y. The floating-point remainder of the division operation x / y calculated by this function is exactly the value x - n * y, where n is x / y with its fractional part truncated. The returned value has the same sign as x and is less or equal to y in magnitude. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • x, y - floating-point values @return If successful, returns the floating-point remainder of the division x / y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fmod

Returns

If successful, returns the floating-point remainder of the division x / y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fmod

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmod
Publicfunction remainderf
func remainderf(x : float, y : float) : float
Computes the IEEE remainder of the floating-point division operation x/y. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned.

Parameters

  • x, y - floating-point values @return If successful, returns the IEEE floating-point remainder of the division x/y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remainder

Returns

If successful, returns the IEEE floating-point remainder of the division x/y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remainder

See Also

  • https:en.cppreference.com/w/c/numeric/math/remainder
Publicfunction remainder
func remainder(x : double, y : double) : double
Computes the IEEE remainder of the floating-point division operation x/y. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned.

Parameters

  • x, y - floating-point values @return If successful, returns the IEEE floating-point remainder of the division x/y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remainder

Returns

If successful, returns the IEEE floating-point remainder of the division x/y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remainder

See Also

  • https:en.cppreference.com/w/c/numeric/math/remainder
Publicfunction remainderl
func remainderl(x : unknown, y : unknown) : unknown
Computes the IEEE remainder of the floating-point division operation x/y. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned.

Parameters

  • x, y - floating-point values @return If successful, returns the IEEE floating-point remainder of the division x/y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remainder

Returns

If successful, returns the IEEE floating-point remainder of the division x/y as defined above. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remainder

See Also

  • https:en.cppreference.com/w/c/numeric/math/remainder
Publicfunction remquof
func remquof(x : float, y : float, quo : *int) : float
Computes the floating-point remainder of the division operation x/y as the remainder() function does. Additionally, the sign and at least the three of the last bits of x/y will be stored in quo, sufficient to determine the octant of the result within a period. to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned.

Parameters

  • x, y - floating-point values @param quo - pointer to an integer value to store the sign and some bits of x/y @return If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo
  • quo - pointer to an integer value to store the sign and some bits of x/y @return If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo

Returns

If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo

See Also

  • https:en.cppreference.com/w/c/numeric/math/remquo
Publicfunction remquo
func remquo(x : double, y : double, quo : *int) : double
Computes the floating-point remainder of the division operation x/y as the remainder() function does. Additionally, the sign and at least the three of the last bits of x/y will be stored in quo, sufficient to determine the octant of the result within a period. to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned.

Parameters

  • x, y - floating-point values @param quo - pointer to an integer value to store the sign and some bits of x/y @return If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo
  • quo - pointer to an integer value to store the sign and some bits of x/y @return If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo

Returns

If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo

See Also

  • https:en.cppreference.com/w/c/numeric/math/remquo
Publicfunction remquol
func remquol(x : unknown, y : unknown, quo : *int) : unknown
Computes the floating-point remainder of the division operation x/y as the remainder() function does. Additionally, the sign and at least the three of the last bits of x/y will be stored in quo, sufficient to determine the octant of the result within a period. to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned.

Parameters

  • x, y - floating-point values @param quo - pointer to an integer value to store the sign and some bits of x/y @return If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo
  • quo - pointer to an integer value to store the sign and some bits of x/y @return If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo

Returns

If successful, returns the floating-point remainder of the division x/y as defined in remainder, and stores, in *quo, the sign and at least three of the least significant bits of x/y (formally, stores a value whose sign is the sign of x/y and whose magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where n is an implementation-defined integer greater than or equal to 3). If y is zero, the value stored in *quo is unspecified. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result is returned if subnormals are supported. If y is zero, but the domain error does not occur, zero is returned. @see https:en.cppreference.com/w/c/numeric/math/remquo

See Also

  • https:en.cppreference.com/w/c/numeric/math/remquo
Publicfunction fmaf
func fmaf(x : float, y : float, z : float) : float
Computes (x * y) + z as if to infinite precision and rounded only once to fit the result type. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • x, y, z - floating-point values @return If successful, returns the value of (x * y) + z as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation). If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fma

Returns

If successful, returns the value of (x * y) + z as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation). If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fma

See Also

  • https:en.cppreference.com/w/c/numeric/math/fma
Publicfunction fma
func fma(x : double, y : double, z : double) : double
Computes (x * y) + z as if to infinite precision and rounded only once to fit the result type. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • x, y, z - floating-point values @return If successful, returns the value of (x * y) + z as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation). If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fma

Returns

If successful, returns the value of (x * y) + z as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation). If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fma

See Also

  • https:en.cppreference.com/w/c/numeric/math/fma
Publicfunction fmal
func fmal(x : unknown, y : unknown, z : unknown) : unknown
Computes (x * y) + z as if to infinite precision and rounded only once to fit the result type. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • x, y, z - floating-point values @return If successful, returns the value of (x * y) + z as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation). If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fma

Returns

If successful, returns the value of (x * y) + z as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation). If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fma

See Also

  • https:en.cppreference.com/w/c/numeric/math/fma
Publicfunction fmaxf
func fmaxf(x : float, y : float) : float
Returns the larger of two floating-point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen).

Parameters

  • x, y - floating-point values @return If successful, returns the larger of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmax

Returns

If successful, returns the larger of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmax

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmax
Publicfunction fmax
func fmax(x : double, y : double) : double
Returns the larger of two floating-point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen).

Parameters

  • x, y - floating-point values @return If successful, returns the larger of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmax

Returns

If successful, returns the larger of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmax

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmax
Publicfunction fmaxl
func fmaxl(x : unknown, y : unknown) : unknown
Returns the larger of two floating-point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen).

Parameters

  • x, y - floating-point values @return If successful, returns the larger of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmax

Returns

If successful, returns the larger of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmax

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmax
Publicfunction fminf
func fminf(x : float, y : float) : float
Returns the smaller of two floating-point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen).

Parameters

  • x, y - floating-point values @return If successful, returns the smaller of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmin

Returns

If successful, returns the smaller of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmin

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmin
Publicfunction fmin
func fmin(x : double, y : double) : double
Returns the smaller of two floating-point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen).

Parameters

  • x, y - floating-point values @return If successful, returns the smaller of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmin

Returns

If successful, returns the smaller of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmin

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmin
Publicfunction fminl
func fminl(x : unknown, y : unknown) : unknown
Returns the smaller of two floating-point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen).

Parameters

  • x, y - floating-point values @return If successful, returns the smaller of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmin

Returns

If successful, returns the smaller of two floating-point values. The value returned is exact and does not depend on any rounding modes. @see https:en.cppreference.com/w/c/numeric/math/fmin

See Also

  • https:en.cppreference.com/w/c/numeric/math/fmin
Publicfunction fdimf
func fdimf(x : float, y : float) : float
Returns the positive difference between x and y, that is, if x>y, returns x-y, otherwise (if x≤y), returns +0. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • x, y - floating-point value @return If successful, returns the positive difference between x and y. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fdim

Returns

If successful, returns the positive difference between x and y. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fdim

See Also

  • https:en.cppreference.com/w/c/numeric/math/fdim
Publicfunction fdim
func fdim(x : double, y : double) : double
Returns the positive difference between x and y, that is, if x>y, returns x-y, otherwise (if x≤y), returns +0. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • x, y - floating-point value @return If successful, returns the positive difference between x and y. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fdim

Returns

If successful, returns the positive difference between x and y. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fdim

See Also

  • https:en.cppreference.com/w/c/numeric/math/fdim
Publicfunction fdiml
func fdiml(x : unknown, y : unknown) : unknown
Returns the positive difference between x and y, that is, if x>y, returns x-y, otherwise (if x≤y), returns +0. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • x, y - floating-point value @return If successful, returns the positive difference between x and y. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fdim

Returns

If successful, returns the positive difference between x and y. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/fdim

See Also

  • https:en.cppreference.com/w/c/numeric/math/fdim
Publicfunction nanf
func nanf(arg : *char) : float
Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling the appropriate parsing function strtoX, as follows: The call nan("n-char-sequence"), where n-char-sequence is a sequence of digits, Latin letters, and underscores, is equivalent to the call strtoX("NAN(n-char-sequence)", (char**)NULL);. The call nan("") is equivalent to the call strtoX("NAN()", (char**)NULL);. The call nan("string"), where string is neither an n-char-sequence nor an empty string, is equivalent to the call strtoX("NAN", (char**)NULL);. The parsing function is strtof. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs.

Parameters

  • arg - narrow character string identifying the contents of a NaN @return The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

Returns

The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

See Also

  • https:en.cppreference.com/w/c/numeric/math/nan
Publicfunction nan
func nan(arg : *char) : double
Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling the appropriate parsing function strtoX, as follows: The call nan("n-char-sequence"), where n-char-sequence is a sequence of digits, Latin letters, and underscores, is equivalent to the call strtoX("NAN(n-char-sequence)", (char**)NULL);. The call nan("") is equivalent to the call strtoX("NAN()", (char**)NULL);. The call nan("string"), where string is neither an n-char-sequence nor an empty string, is equivalent to the call strtoX("NAN", (char**)NULL);. The parsing function is strtod. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs.

Parameters

  • arg - narrow character string identifying the contents of a NaN @return The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

Returns

The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

See Also

  • https:en.cppreference.com/w/c/numeric/math/nan
Publicfunction nanl
func nanl(arg : *char) : unknown
Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling the appropriate parsing function strtoX, as follows: The call nan("n-char-sequence"), where n-char-sequence is a sequence of digits, Latin letters, and underscores, is equivalent to the call strtoX("NAN(n-char-sequence)", (char**)NULL);. The call nan("") is equivalent to the call strtoX("NAN()", (char**)NULL);. The call nan("string"), where string is neither an n-char-sequence nor an empty string, is equivalent to the call strtoX("NAN", (char**)NULL);. The parsing function is strtold. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs.

Parameters

  • arg - narrow character string identifying the contents of a NaN @return The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

Returns

The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

See Also

  • https:en.cppreference.com/w/c/numeric/math/nan
Publicfunction nand32
func nand32(arg : *char) : _Decimal32
Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling the appropriate parsing function strtoX, as follows: The call nan("n-char-sequence"), where n-char-sequence is a sequence of digits, Latin letters, and underscores, is equivalent to the call strtoX("NAN(n-char-sequence)", (char**)NULL);. The call nan("") is equivalent to the call strtoX("NAN()", (char**)NULL);. The call nan("string"), where string is neither an n-char-sequence nor an empty string, is equivalent to the call strtoX("NAN", (char**)NULL);. The parsing function is strtod32. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs.

Parameters

  • arg - narrow character string identifying the contents of a NaN @return The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

Returns

The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

See Also

  • https:en.cppreference.com/w/c/numeric/math/nan
Publicfunction nand64
func nand64(arg : *char) : _Decimal64
Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling the appropriate parsing function strtoX, as follows: The call nan("n-char-sequence"), where n-char-sequence is a sequence of digits, Latin letters, and underscores, is equivalent to the call strtoX("NAN(n-char-sequence)", (char**)NULL);. The call nan("") is equivalent to the call strtoX("NAN()", (char**)NULL);. The call nan("string"), where string is neither an n-char-sequence nor an empty string, is equivalent to the call strtoX("NAN", (char**)NULL);. The parsing function is strtod64. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs.

Parameters

  • arg - narrow character string identifying the contents of a NaN @return The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

Returns

The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

See Also

  • https:en.cppreference.com/w/c/numeric/math/nan
Publicfunction nand128
func nand128(arg : *char) : _Decimal128
Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling the appropriate parsing function strtoX, as follows: The call nan("n-char-sequence"), where n-char-sequence is a sequence of digits, Latin letters, and underscores, is equivalent to the call strtoX("NAN(n-char-sequence)", (char**)NULL);. The call nan("") is equivalent to the call strtoX("NAN()", (char**)NULL);. The call nan("string"), where string is neither an n-char-sequence nor an empty string, is equivalent to the call strtoX("NAN", (char**)NULL);. The parsing function is strtod128. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs.

Parameters

  • arg - narrow character string identifying the contents of a NaN @return The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

Returns

The quiet NaN value that corresponds to the identifying string arg or zero if the implementation does not support quiet NaNs. If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also supports quiet NaNs. @see https:en.cppreference.com/w/c/numeric/math/nan

See Also

  • https:en.cppreference.com/w/c/numeric/math/nan
Publicfunction expf
func expf(arg : float) : float
Computes e (Euler's number, 2.7182818...) raised to the given power arg. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the base-e exponential of arg (earg) is returned. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp

Returns

If no errors occur, the base-e exponential of arg (earg) is returned. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp

See Also

  • https:en.cppreference.com/w/c/numeric/math/exp
Publicfunction exp
func exp(arg : double) : double
Computes e (Euler's number, 2.7182818...) raised to the given power arg. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the base-e exponential of arg (earg) is returned. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp

Returns

If no errors occur, the base-e exponential of arg (earg) is returned. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp

See Also

  • https:en.cppreference.com/w/c/numeric/math/exp
Publicfunction expl
func expl(arg : unknown) : unknown
Computes e (Euler's number, 2.7182818...) raised to the given power arg. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the base-e exponential of arg (earg) is returned. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp

Returns

If no errors occur, the base-e exponential of arg (earg) is returned. If a range error occurs due to overflow, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp

See Also

  • https:en.cppreference.com/w/c/numeric/math/exp
Publicfunction exp2f
func exp2f(n : float) : float
Computes 2 raised to the given power n. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • n - floating-point value @return If no errors occur, the base-2 exponential of n (2n) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp2

Returns

If no errors occur, the base-2 exponential of n (2n) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp2

See Also

  • https:en.cppreference.com/w/c/numeric/math/exp2
Publicfunction exp2
func exp2(n : double) : double
Computes 2 raised to the given power n. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • n - floating-point value @return If no errors occur, the base-2 exponential of n (2n) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp2

Returns

If no errors occur, the base-2 exponential of n (2n) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp2

See Also

  • https:en.cppreference.com/w/c/numeric/math/exp2
Publicfunction exp2l
func exp2l(n : unknown) : unknown
Computes 2 raised to the given power n. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • n - floating-point value @return If no errors occur, the base-2 exponential of n (2n) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp2

Returns

If no errors occur, the base-2 exponential of n (2n) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/exp2

See Also

  • https:en.cppreference.com/w/c/numeric/math/exp2
Publicfunction expm1f
func expm1f(arg : float) : float
Computes the e (Euler's number, 2.7182818) raised to the given power arg, minus 1.0. This function is more accurate than the expression exp(arg)-1.0 if arg is close to zero. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur earg -1 is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/expm1

Returns

If no errors occur earg -1 is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/expm1

See Also

  • https:en.cppreference.com/w/c/numeric/math/expm1
Publicfunction expm1
func expm1(arg : double) : double
Computes the e (Euler's number, 2.7182818) raised to the given power arg, minus 1.0. This function is more accurate than the expression exp(arg)-1.0 if arg is close to zero. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur earg -1 is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/expm1

Returns

If no errors occur earg -1 is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/expm1

See Also

  • https:en.cppreference.com/w/c/numeric/math/expm1
Publicfunction expm1l
func expm1l(arg : unknown) : unknown
Computes the e (Euler's number, 2.7182818) raised to the given power arg, minus 1.0. This function is more accurate than the expression exp(arg)-1.0 if arg is close to zero. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur earg -1 is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/expm1

Returns

If no errors occur earg -1 is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/expm1

See Also

  • https:en.cppreference.com/w/c/numeric/math/expm1
Publicfunction logf
func logf(arg : float) : float
Computes the natural (base e) logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the natural (base-e) logarithm of arg (ln(arg) or loge(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log

Returns

If no errors occur, the natural (base-e) logarithm of arg (ln(arg) or loge(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log

See Also

  • https:en.cppreference.com/w/c/numeric/math/log
Publicfunction log
func log(arg : double) : double
Computes the natural (base e) logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the natural (base-e) logarithm of arg (ln(arg) or loge(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log

Returns

If no errors occur, the natural (base-e) logarithm of arg (ln(arg) or loge(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log

See Also

  • https:en.cppreference.com/w/c/numeric/math/log
Publicfunction logl
func logl(arg : unknown) : unknown
Computes the natural (base e) logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the natural (base-e) logarithm of arg (ln(arg) or loge(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log

Returns

If no errors occur, the natural (base-e) logarithm of arg (ln(arg) or loge(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log

See Also

  • https:en.cppreference.com/w/c/numeric/math/log
Publicfunction log10f
func log10f(arg : float) : float
Computes the common (base-10) logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • floating-point value @return If no errors occur, the common (base-10) logarithm of arg (log10(arg) or lg(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log10

Returns

If no errors occur, the common (base-10) logarithm of arg (log10(arg) or lg(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log10

See Also

  • https:en.cppreference.com/w/c/numeric/math/log10
Publicfunction log10
func log10(arg : double) : double
Computes the common (base-10) logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • floating-point value @return If no errors occur, the common (base-10) logarithm of arg (log10(arg) or lg(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log10

Returns

If no errors occur, the common (base-10) logarithm of arg (log10(arg) or lg(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log10

See Also

  • https:en.cppreference.com/w/c/numeric/math/log10
Publicfunction log10l
func log10l(arg : unknown) : unknown
Computes the common (base-10) logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • floating-point value @return If no errors occur, the common (base-10) logarithm of arg (log10(arg) or lg(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log10

Returns

If no errors occur, the common (base-10) logarithm of arg (log10(arg) or lg(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log10

See Also

  • https:en.cppreference.com/w/c/numeric/math/log10
Publicfunction log2f
func log2f(arg : float) : float
Computes the base 2 logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating point value @return If no errors occur, the base-2 logarithm of arg (log2(arg) or lb(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log2

Returns

If no errors occur, the base-2 logarithm of arg (log2(arg) or lb(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log2

See Also

  • https:en.cppreference.com/w/c/numeric/math/log2
Publicfunction log2
func log2(arg : double) : double
Computes the base 2 logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating point value @return If no errors occur, the base-2 logarithm of arg (log2(arg) or lb(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log2

Returns

If no errors occur, the base-2 logarithm of arg (log2(arg) or lb(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log2

See Also

  • https:en.cppreference.com/w/c/numeric/math/log2
Publicfunction log2l
func log2l(arg : unknown) : unknown
Computes the base 2 logarithm of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating point value @return If no errors occur, the base-2 logarithm of arg (log2(arg) or lb(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log2

Returns

If no errors occur, the base-2 logarithm of arg (log2(arg) or lb(arg)) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/log2

See Also

  • https:en.cppreference.com/w/c/numeric/math/log2
Publicfunction log1pf
func log1pf(arg : float) : float
Computes the natural (base e) logarithm of 1 + arg. This function is more precise than the expression log(1 + arg) if arg is close to zero. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur ln(1 + arg) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/log1p

Returns

If no errors occur ln(1 + arg) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/log1p

See Also

  • https:en.cppreference.com/w/c/numeric/math/log1p
Publicfunction log1p
func log1p(arg : double) : double
Computes the natural (base e) logarithm of 1 + arg. This function is more precise than the expression log(1 + arg) if arg is close to zero. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur ln(1 + arg) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/log1p

Returns

If no errors occur ln(1 + arg) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/log1p

See Also

  • https:en.cppreference.com/w/c/numeric/math/log1p
Publicfunction log1pl
func log1pl(arg : unknown) : unknown
Computes the natural (base e) logarithm of 1 + arg. This function is more precise than the expression log(1 + arg) if arg is close to zero. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur ln(1 + arg) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/log1p

Returns

If no errors occur ln(1 + arg) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/log1p

See Also

  • https:en.cppreference.com/w/c/numeric/math/log1p
Publicfunction powf
func powf(base : float, exponent : float) : float
Computes the value of base raised to the power exponent If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • base - base as floating-point value @param exponent - exponent as floating-point value @return If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow
  • exponent - exponent as floating-point value @return If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow

Returns

If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow

See Also

  • https:en.cppreference.com/w/c/numeric/math/pow
Publicfunction pow
func pow(base : double, exponent : double) : double
Computes the value of base raised to the power exponent If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • base - base as floating-point value @param exponent - exponent as floating-point value @return If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow
  • exponent - exponent as floating-point value @return If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow

Returns

If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow

See Also

  • https:en.cppreference.com/w/c/numeric/math/pow
Publicfunction powl
func powl(base : unknown, exponent : unknown) : unknown
Computes the value of base raised to the power exponent If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • base - base as floating-point value @param exponent - exponent as floating-point value @return If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow
  • exponent - exponent as floating-point value @return If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow

Returns

If no errors occur, base raised to the power of exponent (baseexponent) is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error or a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/pow

See Also

  • https:en.cppreference.com/w/c/numeric/math/pow
Publicfunction sqrtf
func sqrtf(arg : float) : float
Computes square root of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, square root of arg (√arg), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sqrt

Returns

If no errors occur, square root of arg (√arg), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sqrt

See Also

  • https:en.cppreference.com/w/c/numeric/math/sqrt
Publicfunction sqrt
func sqrt(arg : double) : double
Computes square root of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, square root of arg (√arg), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sqrt

Returns

If no errors occur, square root of arg (√arg), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sqrt

See Also

  • https:en.cppreference.com/w/c/numeric/math/sqrt
Publicfunction sqrtl
func sqrtl(arg : unknown) : unknown
Computes square root of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, square root of arg (√arg), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sqrt

Returns

If no errors occur, square root of arg (√arg), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sqrt

See Also

  • https:en.cppreference.com/w/c/numeric/math/sqrt
Publicfunction cbrtf
func cbrtf(arg : float) : float
Computes the cube root of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the cube root of arg (3√arg), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cbrt

Returns

If no errors occur, the cube root of arg (3√arg), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cbrt

See Also

  • https:en.cppreference.com/w/c/numeric/math/cbrt
Publicfunction cbrt
func cbrt(arg : double) : double
Computes the cube root of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the cube root of arg (3√arg), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cbrt

Returns

If no errors occur, the cube root of arg (3√arg), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cbrt

See Also

  • https:en.cppreference.com/w/c/numeric/math/cbrt
Publicfunction cbrtl
func cbrtl(arg : unknown) : unknown
Computes the cube root of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the cube root of arg (3√arg), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cbrt

Returns

If no errors occur, the cube root of arg (3√arg), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cbrt

See Also

  • https:en.cppreference.com/w/c/numeric/math/cbrt
Publicfunction hypotf
func hypotf(x : float, y : float) : float
Computes the square root of the sum of the squares of x and y, without undue overflow or underflow at intermediate stages of the computation. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • x, y - floating-point value @return If no errors occur, the hypotenuse of a right-angled triangle,√x2+y2, is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/hypot

Returns

If no errors occur, the hypotenuse of a right-angled triangle,√x2+y2, is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/hypot

See Also

  • https:en.cppreference.com/w/c/numeric/math/hypot
Publicfunction hypot
func hypot(x : double, y : double) : double
Computes the square root of the sum of the squares of x and y, without undue overflow or underflow at intermediate stages of the computation. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • x, y - floating-point value @return If no errors occur, the hypotenuse of a right-angled triangle,√x2+y2, is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/hypot

Returns

If no errors occur, the hypotenuse of a right-angled triangle,√x2+y2, is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/hypot

See Also

  • https:en.cppreference.com/w/c/numeric/math/hypot
Publicfunction hypotl
func hypotl(x : unknown, y : __float_128) : __float_128
Computes the square root of the sum of the squares of x and y, without undue overflow or underflow at intermediate stages of the computation. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • x, y - floating-point value @return If no errors occur, the hypotenuse of a right-angled triangle,√x2+y2, is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/hypot

Returns

If no errors occur, the hypotenuse of a right-angled triangle,√x2+y2, is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/hypot

See Also

  • https:en.cppreference.com/w/c/numeric/math/hypot
Publicfunction sinf
func sinf(arg : float) : float
Computes the sine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing an angle in radians @return If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

Returns

If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

See Also

  • https:en.cppreference.com/w/c/numeric/math/sin
Publicfunction sin
func sin(arg : double) : double
Computes the sine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing an angle in radians @return If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

Returns

If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

See Also

  • https:en.cppreference.com/w/c/numeric/math/sin
Publicfunction sinl
func sinl(arg : __float_128) : __float_128
Computes the sine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing an angle in radians @return If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

Returns

If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

See Also

  • https:en.cppreference.com/w/c/numeric/math/sin
Publicfunction sind32
func sind32(arg : _Decimal32) : _Decimal32
Computes the sine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing an angle in radians @return If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

Returns

If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

See Also

  • https:en.cppreference.com/w/c/numeric/math/sin
Publicfunction sind64
func sind64(arg : _Decimal64) : _Decimal64
Computes the sine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing an angle in radians @return If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

Returns

If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

See Also

  • https:en.cppreference.com/w/c/numeric/math/sin
Publicfunction sind128
func sind128(arg : _Decimal128) : _Decimal128
Computes the sine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing an angle in radians @return If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

Returns

If no errors occur, the sine of arg (sin(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sin

See Also

  • https:en.cppreference.com/w/c/numeric/math/sin
Publicfunction cosf
func cosf(arg : float) : float
Computes the cosine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

Returns

If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

See Also

  • https:en.cppreference.com/w/c/numeric/math/cos
Publicfunction cos
func cos(arg : double) : double
Computes the cosine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

Returns

If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

See Also

  • https:en.cppreference.com/w/c/numeric/math/cos
Publicfunction cosl
func cosl(arg : __float_128) : __float_128
Computes the cosine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

Returns

If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

See Also

  • https:en.cppreference.com/w/c/numeric/math/cos
Publicfunction cosd32
func cosd32(arg : _Decimal32) : _Decimal32
Computes the cosine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

Returns

If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

See Also

  • https:en.cppreference.com/w/c/numeric/math/cos
Publicfunction cosd64
func cosd64(arg : _Decimal64) : _Decimal64
Computes the cosine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

Returns

If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

See Also

  • https:en.cppreference.com/w/c/numeric/math/cos
Publicfunction cosd128
func cosd128(arg : _Decimal128) : _Decimal128
Computes the cosine of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

Returns

If no errors occur, the cosine of arg (cos(arg)) in the range [-1 ; +1], is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/cos

See Also

  • https:en.cppreference.com/w/c/numeric/math/cos
Publicfunction tanf
func tanf(arg : float) : float
Computes the tangent of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

Returns

If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

See Also

  • https:en.cppreference.com/w/c/numeric/math/tan
Publicfunction tan
func tan(arg : double) : double
Computes the tangent of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

Returns

If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

See Also

  • https:en.cppreference.com/w/c/numeric/math/tan
Publicfunction tanl
func tanl(arg : __float_128) : __float_128
Computes the tangent of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

Returns

If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

See Also

  • https:en.cppreference.com/w/c/numeric/math/tan
Publicfunction tand32
func tand32(arg : _Decimal32) : _Decimal32
Computes the tangent of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

Returns

If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

See Also

  • https:en.cppreference.com/w/c/numeric/math/tan
Publicfunction tand64
func tand64(arg : _Decimal64) : _Decimal64
Computes the tangent of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

Returns

If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

See Also

  • https:en.cppreference.com/w/c/numeric/math/tan
Publicfunction tand128
func tand128(arg : _Decimal128) : _Decimal128
Computes the tangent of arg (measured in radians). The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing angle in radians @return If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

Returns

If no errors occur, the tangent of arg (tan(arg)) is returned. The result may have little or no significance if the magnitude of arg is large. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tan

See Also

  • https:en.cppreference.com/w/c/numeric/math/tan
Publicfunction asinf
func asinf(arg : float) : float
Computes the principal values of the arc sine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

Returns

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

See Also

  • https:en.cppreference.com/w/c/numeric/math/asin
Publicfunction asin
func asin(arg : double) : double
Computes the principal values of the arc sine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

Returns

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

See Also

  • https:en.cppreference.com/w/c/numeric/math/asin
Publicfunction asinl
func asinl(arg : __float_128) : __float_128
Computes the principal values of the arc sine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

Returns

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

See Also

  • https:en.cppreference.com/w/c/numeric/math/asin
Publicfunction asind32
func asind32(arg : _Decimal32) : _Decimal32
Computes the principal values of the arc sine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

Returns

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

See Also

  • https:en.cppreference.com/w/c/numeric/math/asin
Publicfunction asind64
func asind64(arg : _Decimal64) : _Decimal64
Computes the principal values of the arc sine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

Returns

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

See Also

  • https:en.cppreference.com/w/c/numeric/math/asin
Publicfunction asind128
func asind128(arg : _Decimal128) : _Decimal128
Computes the principal values of the arc sine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

Returns

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [-π2; +π2], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asin

See Also

  • https:en.cppreference.com/w/c/numeric/math/asin
Publicfunction acosf
func acosf(arg : float) : float
Computes the principal value of the arc cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

Returns

If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

See Also

  • https:en.cppreference.com/w/c/numeric/math/acos
Publicfunction acos
func acos(arg : double) : double
Computes the principal value of the arc cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

Returns

If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

See Also

  • https:en.cppreference.com/w/c/numeric/math/acos
Publicfunction acosl
func acosl(arg : __float_128) : __float_128
Computes the principal value of the arc cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

Returns

If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

See Also

  • https:en.cppreference.com/w/c/numeric/math/acos
Publicfunction acosd32
func acosd32(arg : _Decimal32) : _Decimal32
Computes the principal value of the arc cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

Returns

If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

See Also

  • https:en.cppreference.com/w/c/numeric/math/acos
Publicfunction acosd64
func acosd64(arg : _Decimal64) : _Decimal64
Computes the principal value of the arc cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

Returns

If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

See Also

  • https:en.cppreference.com/w/c/numeric/math/acos
Publicfunction acosd128
func acosd128(arg : _Decimal128) : _Decimal128
Computes the principal value of the arc cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

Returns

If no errors occur, the arc cosine of arg (arccos(arg)) in the range [0 ; π], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/acos

See Also

  • https:en.cppreference.com/w/c/numeric/math/acos
Publicfunction atanf
func atanf(arg : float) : float
Computes the principal value of the arc tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

Returns

If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan
Publicfunction atan
func atan(arg : double) : double
Computes the principal value of the arc tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

Returns

If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan
Publicfunction atanl
func atanl(arg : __float_128) : __float_128
Computes the principal value of the arc tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

Returns

If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan
Publicfunction atand32
func atand32(arg : _Decimal32) : _Decimal32
Computes the principal value of the arc tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

Returns

If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan
Publicfunction atand64
func atand64(arg : _Decimal64) : _Decimal64
Computes the principal value of the arc tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

Returns

If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan
Publicfunction atand128
func atand128(arg : _Decimal128) : _Decimal128
Computes the principal value of the arc tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

Returns

If no errors occur, the arc tangent of arg (arctan(arg)) in the range [-π2; +π2] radians, is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atan

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan
Publicfunction atan2f
func atan2f(y : float, x : float) : float
Computes the arc tangent of y / x using the signs of arguments to determine the correct quadrant.

Parameters

  • x, y - floating-point value @return If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

Returns

If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan2
Publicfunction atan2
func atan2(y : double, x : double) : double
Computes the arc tangent of y / x using the signs of arguments to determine the correct quadrant.

Parameters

  • x, y - floating-point value @return If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

Returns

If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan2
Publicfunction atan2l
func atan2l(y : __float_128, x : __float_128) : __float_128
Computes the arc tangent of y / x using the signs of arguments to determine the correct quadrant.

Parameters

  • x, y - floating-point value @return If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

Returns

If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan2
Publicfunction atan2d32
func atan2d32(y : _Decimal32, x : _Decimal32) : _Decimal32
Computes the arc tangent of y / x using the signs of arguments to determine the correct quadrant.

Parameters

  • x, y - floating-point value @return If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

Returns

If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan2
Publicfunction atan2d64
func atan2d64(y : _Decimal64, x : _Decimal64) : _Decimal64
Computes the arc tangent of y / x using the signs of arguments to determine the correct quadrant.

Parameters

  • x, y - floating-point value @return If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

Returns

If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan2
Publicfunction atan2d128
func atan2d128(y : _Decimal128, x : _Decimal128) : _Decimal128
Computes the arc tangent of y / x using the signs of arguments to determine the correct quadrant.

Parameters

  • x, y - floating-point value @return If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

Returns

If no errors occur, the arc tangent of y / x (arctan(y/x)) in the range [-π ; +π] radians, is returned. @see https:en.cppreference.com/w/c/numeric/math/atan2

See Also

  • https:en.cppreference.com/w/c/numeric/math/atan2
Publicfunction sinhf
func sinhf(arg : float) : float
Computes hyperbolic sine of arg. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic sine of arg (sinh(arg), or earg-e-arg2) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sinh

Returns

If no errors occur, the hyperbolic sine of arg (sinh(arg), or earg-e-arg2) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sinh

See Also

  • https:en.cppreference.com/w/c/numeric/math/sinh
Publicfunction sinh
func sinh(arg : double) : double
Computes hyperbolic sine of arg. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic sine of arg (sinh(arg), or earg-e-arg2) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sinh

Returns

If no errors occur, the hyperbolic sine of arg (sinh(arg), or earg-e-arg2) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sinh

See Also

  • https:en.cppreference.com/w/c/numeric/math/sinh
Publicfunction sinhl
func sinhl(arg : __float_128) : __float_128
Computes hyperbolic sine of arg. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic sine of arg (sinh(arg), or earg-e-arg2) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sinh

Returns

If no errors occur, the hyperbolic sine of arg (sinh(arg), or earg-e-arg2) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/sinh

See Also

  • https:en.cppreference.com/w/c/numeric/math/sinh
Publicfunction coshf
func coshf(arg : float) : float
Computes the hyperbolic cosine of arg. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic cosine of arg (cosh(arg), or earg+e-arg2) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/cosh

Returns

If no errors occur, the hyperbolic cosine of arg (cosh(arg), or earg+e-arg2) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/cosh

See Also

  • https:en.cppreference.com/w/c/numeric/math/cosh
Publicfunction cosh
func cosh(arg : double) : double
Computes the hyperbolic cosine of arg. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic cosine of arg (cosh(arg), or earg+e-arg2) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/cosh

Returns

If no errors occur, the hyperbolic cosine of arg (cosh(arg), or earg+e-arg2) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/cosh

See Also

  • https:en.cppreference.com/w/c/numeric/math/cosh
Publicfunction coshl
func coshl(arg : __float_128) : __float_128
Computes the hyperbolic cosine of arg. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic cosine of arg (cosh(arg), or earg+e-arg2) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/cosh

Returns

If no errors occur, the hyperbolic cosine of arg (cosh(arg), or earg+e-arg2) is returned. If a range error due to overflow occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/cosh

See Also

  • https:en.cppreference.com/w/c/numeric/math/cosh
Publicfunction tanhf
func tanhf(arg : float) : float
Computes the hyperbolic tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic tangent of arg (tanh(arg), or earg-e-argearg+e-arg) is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tanh

Returns

If no errors occur, the hyperbolic tangent of arg (tanh(arg), or earg-e-argearg+e-arg) is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tanh

See Also

  • https:en.cppreference.com/w/c/numeric/math/tanh
Publicfunction tanh
func tanh(arg : double) : double
Computes the hyperbolic tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic tangent of arg (tanh(arg), or earg-e-argearg+e-arg) is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tanh

Returns

If no errors occur, the hyperbolic tangent of arg (tanh(arg), or earg-e-argearg+e-arg) is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tanh

See Also

  • https:en.cppreference.com/w/c/numeric/math/tanh
Publicfunction tanhl
func tanhl(arg : __float_128) : __float_128
Computes the hyperbolic tangent of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing a hyperbolic angle @return If no errors occur, the hyperbolic tangent of arg (tanh(arg), or earg-e-argearg+e-arg) is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tanh

Returns

If no errors occur, the hyperbolic tangent of arg (tanh(arg), or earg-e-argearg+e-arg) is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/tanh

See Also

  • https:en.cppreference.com/w/c/numeric/math/tanh
Publicfunction asinhf
func asinhf(arg : float) : float
Computes the inverse hyperbolic sine of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic sine of arg (sinh-1 (arg), or arsinh(arg)), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asinh

Returns

If no errors occur, the inverse hyperbolic sine of arg (sinh-1 (arg), or arsinh(arg)), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asinh

See Also

  • https:en.cppreference.com/w/c/numeric/math/asinh
Publicfunction asinh
func asinh(arg : double) : double
Computes the inverse hyperbolic sine of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic sine of arg (sinh-1 (arg), or arsinh(arg)), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asinh

Returns

If no errors occur, the inverse hyperbolic sine of arg (sinh-1 (arg), or arsinh(arg)), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asinh

See Also

  • https:en.cppreference.com/w/c/numeric/math/asinh
Publicfunction asinhl
func asinhl(arg : __float_128) : __float_128
Computes the inverse hyperbolic sine of arg. If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic sine of arg (sinh-1 (arg), or arsinh(arg)), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asinh

Returns

If no errors occur, the inverse hyperbolic sine of arg (sinh-1 (arg), or arsinh(arg)), is returned. If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/asinh

See Also

  • https:en.cppreference.com/w/c/numeric/math/asinh
Publicfunction acoshf
func acoshf(arg : float) : float
Computes the inverse hyperbolic cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported).

Parameters

  • arg - floating-point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic cosine of arg (cosh-1 (arg), or arcosh(arg)) on the interval [0, +∞], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). @see https:en.cppreference.com/w/c/numeric/math/acosh

Returns

If no errors occur, the inverse hyperbolic cosine of arg (cosh-1 (arg), or arcosh(arg)) on the interval [0, +∞], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). @see https:en.cppreference.com/w/c/numeric/math/acosh

See Also

  • https:en.cppreference.com/w/c/numeric/math/acosh
Publicfunction acosh
func acosh(arg : double) : double
Computes the inverse hyperbolic cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported).

Parameters

  • arg - floating-point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic cosine of arg (cosh-1 (arg), or arcosh(arg)) on the interval [0, +∞], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). @see https:en.cppreference.com/w/c/numeric/math/acosh

Returns

If no errors occur, the inverse hyperbolic cosine of arg (cosh-1 (arg), or arcosh(arg)) on the interval [0, +∞], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). @see https:en.cppreference.com/w/c/numeric/math/acosh

See Also

  • https:en.cppreference.com/w/c/numeric/math/acosh
Publicfunction acoshl
func acoshl(arg : __float_128) : __float_128
Computes the inverse hyperbolic cosine of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported).

Parameters

  • arg - floating-point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic cosine of arg (cosh-1 (arg), or arcosh(arg)) on the interval [0, +∞], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). @see https:en.cppreference.com/w/c/numeric/math/acosh

Returns

If no errors occur, the inverse hyperbolic cosine of arg (cosh-1 (arg), or arcosh(arg)) on the interval [0, +∞], is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). @see https:en.cppreference.com/w/c/numeric/math/acosh

See Also

  • https:en.cppreference.com/w/c/numeric/math/acosh
Publicfunction atanhf
func atanhf(arg : float) : float
Computes the inverse hyperbolic tangent of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating_point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic tangent of arg (tanh-1 (arg), or artanh(arg)), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atanh

Returns

If no errors occur, the inverse hyperbolic tangent of arg (tanh-1 (arg), or artanh(arg)), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atanh

See Also

  • https:en.cppreference.com/w/c/numeric/math/atanh
Publicfunction atanh
func atanh(arg : double) : double
Computes the inverse hyperbolic tangent of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating_point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic tangent of arg (tanh-1 (arg), or artanh(arg)), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atanh

Returns

If no errors occur, the inverse hyperbolic tangent of arg (tanh-1 (arg), or artanh(arg)), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atanh

See Also

  • https:en.cppreference.com/w/c/numeric/math/atanh
Publicfunction atanhl
func atanhl(arg : __float_128) : __float_128
Computes the inverse hyperbolic tangent of arg. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned.

Parameters

  • arg - floating_point value representing the area of a hyperbolic sector @return If no errors occur, the inverse hyperbolic tangent of arg (tanh-1 (arg), or artanh(arg)), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atanh

Returns

If no errors occur, the inverse hyperbolic tangent of arg (tanh-1 (arg), or artanh(arg)), is returned. If a domain error occurs, an implementation-defined value is returned (NaN where supported). If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the correct sign). If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/atanh

See Also

  • https:en.cppreference.com/w/c/numeric/math/atanh
Publicfunction erff
func erff(arg : float) : float
Computes the error function of arg.

Parameters

  • arg - floating-point value @return If no errors occur, value of the error function of arg, that is2√π∫arg0e−t2dt, is returned. If a range error occurs due to underflow, the correct result (after rounding), that is2⋅arg√π, is returned. @see https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf

Returns

If no errors occur, value of the error function of arg, that is2√π∫arg0e−t2dt, is returned. If a range error occurs due to underflow, the correct result (after rounding), that is2⋅arg√π, is returned. @see https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf

See Also

  • https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf
  • https:en.cppreference.com/w/c/numeric/math/erf
Publicfunction erf
func erf(arg : double) : double
Computes the error function of arg.

Parameters

  • arg - floating-point value @return If no errors occur, value of the error function of arg, that is2√π∫arg0e−t2dt, is returned. If a range error occurs due to underflow, the correct result (after rounding), that is2⋅arg√π, is returned. @see https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf

Returns

If no errors occur, value of the error function of arg, that is2√π∫arg0e−t2dt, is returned. If a range error occurs due to underflow, the correct result (after rounding), that is2⋅arg√π, is returned. @see https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf

See Also

  • https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf
  • https:en.cppreference.com/w/c/numeric/math/erf
Publicfunction erfl
func erfl(arg : __float_128) : __float_128
Computes the error function of arg.

Parameters

  • arg - floating-point value @return If no errors occur, value of the error function of arg, that is 2√π∫arg0e−t2dt, is returned. If a range error occurs due to underflow, the correct result (after rounding), that is2⋅arg√π, is returned. @see https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf

Returns

If no errors occur, value of the error function of arg, that is 2√π∫arg0e−t2dt, is returned. If a range error occurs due to underflow, the correct result (after rounding), that is2⋅arg√π, is returned. @see https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf

See Also

  • https:en.wikipedia.org/wiki/Error_function @see https:en.cppreference.com/w/c/numeric/math/erf
  • https:en.cppreference.com/w/c/numeric/math/erf
Publicfunction erfcf
func erfcf(arg : float) : float
Computes the complementary error function of arg, that is 1.0 - erf(arg), but without loss of precision for large arg.

Parameters

  • arg - floating-point value @return If no errors occur, value of the complementary error function of arg, that is 2√π∫∞arge−t2dt or1−erf(arg), is returned.If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function

Returns

If no errors occur, value of the complementary error function of arg, that is 2√π∫∞arge−t2dt or1−erf(arg), is returned.If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function

See Also

  • https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function
  • https:en.wikipedia.org/wiki/Complementary_error_function
Publicfunction erfc
func erfc(arg : double) : double
Computes the complementary error function of arg, that is 1.0 - erf(arg), but without loss of precision for large arg.

Parameters

  • arg - floating-point value @return If no errors occur, value of the complementary error function of arg, that is 2√π∫∞arge−t2dt or1−erf(arg), is returned.If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function

Returns

If no errors occur, value of the complementary error function of arg, that is 2√π∫∞arge−t2dt or1−erf(arg), is returned.If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function

See Also

  • https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function
  • https:en.wikipedia.org/wiki/Complementary_error_function
Publicfunction erfcl
func erfcl(arg : __float_128) : __float_128
Computes the complementary error function of arg, that is 1.0 - erf(arg), but without loss of precision for large arg.

Parameters

  • arg - floating-point value @return If no errors occur, value of the complementary error function of arg, that is 2√π∫∞arge−t2dt or1−erf(arg), is returned.If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function

Returns

If no errors occur, value of the complementary error function of arg, that is 2√π∫∞arge−t2dt or1−erf(arg), is returned.If a range error occurs due to underflow, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function

See Also

  • https:en.cppreference.com/w/c/numeric/math/erfc @see https:en.wikipedia.org/wiki/Complementary_error_function
  • https:en.wikipedia.org/wiki/Complementary_error_function
Publicfunction tgammaf
func tgammaf(arg : float) : float
Computes the gamma function of arg. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the value of the gamma function of arg, that is Γ(arg)=∫∞0targ−1e−tdt, is returned. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma

Returns

If no errors occur, the value of the gamma function of arg, that is Γ(arg)=∫∞0targ−1e−tdt, is returned. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma

See Also

  • https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma
  • https:en.cppreference.com/w/c/numeric/math/tgamma
Publicfunction tgamma
func tgamma(arg : double) : double
Computes the gamma function of arg. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the value of the gamma function of arg, that is Γ(arg)=∫∞0targ−1e−tdt, is returned. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma

Returns

If no errors occur, the value of the gamma function of arg, that is Γ(arg)=∫∞0targ−1e−tdt, is returned. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma

See Also

  • https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma
  • https:en.cppreference.com/w/c/numeric/math/tgamma
Publicfunction tgammal
func tgammal(arg : __float_128) : __float_128
Computes the gamma function of arg. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the value of the gamma function of arg, that is Γ(arg)=∫∞0targ−1e−tdt, is returned. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma

Returns

If no errors occur, the value of the gamma function of arg, that is Γ(arg)=∫∞0targ−1e−tdt, is returned. If a domain error occurs, an implementation-defined value (NaN where supported) is returned. If a pole error occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct value (after rounding) is returned. @see https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma

See Also

  • https:en.wikipedia.org/wiki/Gamma_function @see https:en.cppreference.com/w/c/numeric/math/tgamma
  • https:en.cppreference.com/w/c/numeric/math/tgamma
Publicfunction lgammaf
func lgammaf(arg : float) : float
Computes the natural logarithm of the absolute value of the gamma function of arg. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the value of the logarithm of the gamma function of arg, that is loge|∫∞0targ−1e−tdt|, is returned. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/lgamma

Returns

If no errors occur, the value of the logarithm of the gamma function of arg, that is loge|∫∞0targ−1e−tdt|, is returned. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/lgamma

See Also

  • https:en.cppreference.com/w/c/numeric/math/lgamma
Publicfunction lgamma
func lgamma(arg : double) : double
Computes the natural logarithm of the absolute value of the gamma function of arg. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the value of the logarithm of the gamma function of arg, that is loge|∫∞0targ−1e−tdt|, is returned. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/lgamma

Returns

If no errors occur, the value of the logarithm of the gamma function of arg, that is loge|∫∞0targ−1e−tdt|, is returned. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/lgamma

See Also

  • https:en.cppreference.com/w/c/numeric/math/lgamma
Publicfunction lgammal
func lgammal(arg : __float_128) : __float_128
Computes the natural logarithm of the absolute value of the gamma function of arg. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the value of the logarithm of the gamma function of arg, that is loge|∫∞0targ−1e−tdt|, is returned. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/lgamma

Returns

If no errors occur, the value of the logarithm of the gamma function of arg, that is loge|∫∞0targ−1e−tdt|, is returned. If a pole error occurs, +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/lgamma

See Also

  • https:en.cppreference.com/w/c/numeric/math/lgamma
Publicfunction ceilf
func ceilf(arg : float) : float
Computes the smallest integer value not less than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned. @see https:en.cppreference.com/w/c/numeric/math/ceil

Returns

If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned. @see https:en.cppreference.com/w/c/numeric/math/ceil

See Also

  • https:en.cppreference.com/w/c/numeric/math/ceil
Publicfunction ceil
func ceil(arg : double) : double
Computes the smallest integer value not less than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned. @see https:en.cppreference.com/w/c/numeric/math/ceil

Returns

If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned. @see https:en.cppreference.com/w/c/numeric/math/ceil

See Also

  • https:en.cppreference.com/w/c/numeric/math/ceil
Publicfunction ceill
func ceill(arg : __float_128) : __float_128
Computes the smallest integer value not less than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned. @see https:en.cppreference.com/w/c/numeric/math/ceil

Returns

If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned. @see https:en.cppreference.com/w/c/numeric/math/ceil

See Also

  • https:en.cppreference.com/w/c/numeric/math/ceil
Publicfunction floorf
func floorf(arg : float) : float
Computes the largest integer value not greater than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. @see https:en.cppreference.com/w/c/numeric/math/floor

Returns

If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. @see https:en.cppreference.com/w/c/numeric/math/floor

See Also

  • https:en.cppreference.com/w/c/numeric/math/floor
Publicfunction floor
func floor(arg : double) : double
Computes the largest integer value not greater than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. @see https:en.cppreference.com/w/c/numeric/math/floor

Returns

If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. @see https:en.cppreference.com/w/c/numeric/math/floor

See Also

  • https:en.cppreference.com/w/c/numeric/math/floor
Publicfunction floorl
func floorl(arg : __float_128) : __float_128
Computes the largest integer value not greater than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. @see https:en.cppreference.com/w/c/numeric/math/floor

Returns

If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. @see https:en.cppreference.com/w/c/numeric/math/floor

See Also

  • https:en.cppreference.com/w/c/numeric/math/floor
Publicfunction truncf
func truncf(arg : float) : float
Computes the nearest integer not greater in magnitude than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value not greater in magnitude than arg (in other words, arg rounded towards zero), is returned. @see https:en.cppreference.com/w/c/numeric/math/trunc

Returns

If no errors occur, the nearest integer value not greater in magnitude than arg (in other words, arg rounded towards zero), is returned. @see https:en.cppreference.com/w/c/numeric/math/trunc

See Also

  • https:en.cppreference.com/w/c/numeric/math/trunc
Publicfunction trunc
func trunc(arg : double) : double
Computes the nearest integer not greater in magnitude than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value not greater in magnitude than arg (in other words, arg rounded towards zero), is returned. @see https:en.cppreference.com/w/c/numeric/math/trunc

Returns

If no errors occur, the nearest integer value not greater in magnitude than arg (in other words, arg rounded towards zero), is returned. @see https:en.cppreference.com/w/c/numeric/math/trunc

See Also

  • https:en.cppreference.com/w/c/numeric/math/trunc
Publicfunction truncl
func truncl(arg : __float_128) : __float_128
Computes the nearest integer not greater in magnitude than arg.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value not greater in magnitude than arg (in other words, arg rounded towards zero), is returned. @see https:en.cppreference.com/w/c/numeric/math/trunc

Returns

If no errors occur, the nearest integer value not greater in magnitude than arg (in other words, arg rounded towards zero), is returned. @see https:en.cppreference.com/w/c/numeric/math/trunc

See Also

  • https:en.cppreference.com/w/c/numeric/math/trunc
Publicfunction roundf
func roundf(arg : float) : float
Computes the nearest integer value to arg (in floating-point format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction round
func round(arg : double) : double
Computes the nearest integer value to arg (in floating-point format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction roundl
func roundl(arg : __float_128) : __float_128
Computes the nearest integer value to arg (in floating-point format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction lroundf
func lroundf(arg : float) : long
Computes the nearest integer value to arg (in integer format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction lround
func lround(arg : double) : long
Computes the nearest integer value to arg (in integer format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction lroundl
func lroundl(arg : __float_128) : long
Computes the nearest integer value to arg (in integer format), rounding halfway cases away from zero, regardless of the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction llroundf
func llroundf(arg : float) : i64
Type-generic macros: If arg has type long double, roundl, lroundl, llroundl is called. Otherwise, if arg has integer type or the type double, round, lround, llround is called. Otherwise, roundf, lroundf, llroundf is called, respectively.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction llround
func llround(arg : double) : i64
Type-generic macros: If arg has type long double, roundl, lroundl, llroundl is called. Otherwise, if arg has integer type or the type double, round, lround, llround is called. Otherwise, roundf, lroundf, llroundf is called, respectively.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction llroundl
func llroundl(arg : __float_128) : i64
Type-generic macros: If arg has type long double, roundl, lroundl, llroundl is called. Otherwise, if arg has integer type or the type double, round, lround, llround is called. Otherwise, roundf, lroundf, llroundf is called, respectively.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

Returns

If no errors occur, the nearest integer value to arg, rounding halfway cases away from zero, is returned. @see https:en.cppreference.com/w/c/numeric/math/round

See Also

  • https:en.cppreference.com/w/c/numeric/math/round
Publicfunction nearbyintf
func nearbyintf(arg : float) : float
Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode.

Parameters

  • arg - floating-point value @return The nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/nearbyint

Returns

The nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/nearbyint

See Also

  • https:en.cppreference.com/w/c/numeric/math/nearbyint
Publicfunction nearbyint
func nearbyint(arg : double) : double
Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode.

Parameters

  • arg - floating-point value @return The nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/nearbyint

Returns

The nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/nearbyint

See Also

  • https:en.cppreference.com/w/c/numeric/math/nearbyint
Publicfunction nearbyintl
func nearbyintl(arg : __float_128) : __float_128
Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode.

Parameters

  • arg - floating-point value @return The nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/nearbyint

Returns

The nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/nearbyint

See Also

  • https:en.cppreference.com/w/c/numeric/math/nearbyint
Publicfunction rintf
func rintf(arg : float) : float
Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction rint
func rint(arg : double) : double
Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction rintl
func rintl(arg : __float_128) : __float_128
Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction lrintf
func lrintf(arg : float) : long
Rounds the floating-point argument arg to an integer value in integer format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction lrint
func lrint(arg : double) : long
Rounds the floating-point argument arg to an integer value in integer format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction lrintl
func lrintl(arg : __float_128) : long
Rounds the floating-point argument arg to an integer value in integer format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction llrintf
func llrintf(arg : float) : i64
Rounds the floating-point argument arg to an integer value in integer format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction llrint
func llrint(arg : double) : i64
Rounds the floating-point argument arg to an integer value in integer format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction llrintl
func llrintl(arg : __float_128) : i64
Rounds the floating-point argument arg to an integer value in integer format, using the current rounding mode.

Parameters

  • arg - floating-point value @return If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

Returns

If no errors occur, the nearest integer value to arg, according to the current rounding mode, is returned. @see https:en.cppreference.com/w/c/numeric/math/rint

See Also

  • https:en.cppreference.com/w/c/numeric/math/rint
Publicfunction frexpf
func frexpf(arg : float, exp : *int) : float
Decomposes given floating-point value x into a normalized fraction and an integral power of two. @parm arg - floating-point value @parm exp - pointer to integer value to store the exponent to Otherwise (if arg is not zero), if no errors occur, returns the value x in the range (-1;-0.5], [0.5; 1) and stores an integer value in *exp such that x×2(*exp)=arg. If the value to be stored in *exp is outside the range of int, the behavior is unspecified. If arg is not a floating-point number, the behavior is unspecified.

Returns

If arg is zero, returns zero and stores zero in *exp. Otherwise (if arg is not zero), if no errors occur, returns the value x in the range (-1;-0.5], [0.5; 1) and stores an integer value in *exp such that x×2(*exp)=arg. If the value to be stored in *exp is outside the range of int, the behavior is unspecified. If arg is not a floating-point number, the behavior is unspecified. @see https:en.cppreference.com/w/c/numeric/math/frexp

See Also

  • https:en.cppreference.com/w/c/numeric/math/frexp
Publicfunction frexp
func frexp(arg : double, exp : *int) : double
Decomposes given floating-point value x into a normalized fraction and an integral power of two. @parm arg - floating-point value @parm exp - pointer to integer value to store the exponent to Otherwise (if arg is not zero), if no errors occur, returns the value x in the range (-1;-0.5], [0.5; 1) and stores an integer value in *exp such that x×2(*exp)=arg. If the value to be stored in *exp is outside the range of int, the behavior is unspecified. If arg is not a floating-point number, the behavior is unspecified.

Returns

If arg is zero, returns zero and stores zero in *exp. Otherwise (if arg is not zero), if no errors occur, returns the value x in the range (-1;-0.5], [0.5; 1) and stores an integer value in *exp such that x×2(*exp)=arg. If the value to be stored in *exp is outside the range of int, the behavior is unspecified. If arg is not a floating-point number, the behavior is unspecified. @see https:en.cppreference.com/w/c/numeric/math/frexp

See Also

  • https:en.cppreference.com/w/c/numeric/math/frexp
Publicfunction frexpl
func frexpl(arg : __float_128, exp : *int) : __float_128
Decomposes given floating-point value x into a normalized fraction and an integral power of two. @parm arg - floating-point value @parm exp - pointer to integer value to store the exponent to Otherwise (if arg is not zero), if no errors occur, returns the value x in the range (-1;-0.5], [0.5; 1) and stores an integer value in *exp such that x×2(*exp)=arg. If the value to be stored in *exp is outside the range of int, the behavior is unspecified. If arg is not a floating-point number, the behavior is unspecified.

Returns

If arg is zero, returns zero and stores zero in *exp. Otherwise (if arg is not zero), if no errors occur, returns the value x in the range (-1;-0.5], [0.5; 1) and stores an integer value in *exp such that x×2(*exp)=arg. If the value to be stored in *exp is outside the range of int, the behavior is unspecified. If arg is not a floating-point number, the behavior is unspecified. @see https:en.cppreference.com/w/c/numeric/math/frexp

See Also

  • https:en.cppreference.com/w/c/numeric/math/frexp
Publicfunction ldexpf
func ldexpf(arg : float, exp : int) : float
Multiplies a floating-point value arg by the number 2 raised to the exp power. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp
  • exp - integer value @return If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp

Returns

If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp

See Also

  • https:en.cppreference.com/w/c/numeric/math/ldexp
Publicfunction ldexp
func ldexp(arg : double, exp : int) : double
Multiplies a floating-point value arg by the number 2 raised to the exp power. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp
  • exp - integer value @return If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp

Returns

If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp

See Also

  • https:en.cppreference.com/w/c/numeric/math/ldexp
Publicfunction ldexpl
func ldexpl(arg : __float_128, exp : int) : __float_128
Multiplies a floating-point value arg by the number 2 raised to the exp power. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp
  • exp - integer value @return If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp

Returns

If no errors occur, arg multiplied by 2 to the power of exp (arg×2exp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/ldexp

See Also

  • https:en.cppreference.com/w/c/numeric/math/ldexp
Publicfunction modff
func modff(arg : float, iptr : *float) : float
Decomposes given floating-point value arg into integral and fractional parts, each having the same type and sign as arg. The integral part (in floating-point format) is stored in the object pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding).

Parameters

  • arg - floating-point value @param iptr - pointer to floating-point value to store the integral part to @return If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf
  • iptr - pointer to floating-point value to store the integral part to @return If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf

Returns

If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf

See Also

  • https:en.cppreference.com/w/c/numeric/math/modf
Publicfunction modf
func modf(arg : double, iptr : *double) : double
Decomposes given floating-point value arg into integral and fractional parts, each having the same type and sign as arg. The integral part (in floating-point format) is stored in the object pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding).

Parameters

  • arg - floating-point value @param iptr - pointer to floating-point value to store the integral part to @return If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf
  • iptr - pointer to floating-point value to store the integral part to @return If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf

Returns

If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf

See Also

  • https:en.cppreference.com/w/c/numeric/math/modf
Publicfunction modfl
func modfl(arg : __float_128, iptr : *__float_128) : __float_128
Decomposes given floating-point value arg into integral and fractional parts, each having the same type and sign as arg. The integral part (in floating-point format) is stored in the object pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding).

Parameters

  • arg - floating-point value @param iptr - pointer to floating-point value to store the integral part to @return If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf
  • iptr - pointer to floating-point value to store the integral part to @return If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf

Returns

If no errors occur, returns the fractional part of arg with the same sign as arg. The integral part is put into the value pointed to by iptr. The sum of the returned value and the value stored in *iptr gives arg (allowing for rounding). @see https:en.cppreference.com/w/c/numeric/math/modf

See Also

  • https:en.cppreference.com/w/c/numeric/math/modf
Publicfunction scalbnf
func scalbnf(arg : float, exp : int) : float
Multiplies a floating-point value arg by FLT_RADIX raised to power exp. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn
  • exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

Returns

If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

See Also

  • https:en.cppreference.com/w/c/numeric/math/scalbn
Publicfunction scalbn
func scalbn(arg : double, exp : int) : double
Multiplies a floating-point value arg by FLT_RADIX raised to power exp. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn
  • exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

Returns

If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

See Also

  • https:en.cppreference.com/w/c/numeric/math/scalbn
Publicfunction scalbnl
func scalbnl(arg : __float_128, exp : int) : __float_128
Multiplies a floating-point value arg by FLT_RADIX raised to power exp. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn
  • exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

Returns

If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

See Also

  • https:en.cppreference.com/w/c/numeric/math/scalbn
Publicfunction scalblnf
func scalblnf(arg : float, exp : long) : float
Multiplies a floating-point value arg by FLT_RADIX raised to power exp. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn
  • exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

Returns

If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

See Also

  • https:en.cppreference.com/w/c/numeric/math/scalbn
Publicfunction scalbln
func scalbln(arg : double, exp : long) : double
Multiplies a floating-point value arg by FLT_RADIX raised to power exp. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn
  • exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

Returns

If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

See Also

  • https:en.cppreference.com/w/c/numeric/math/scalbn
Publicfunction scalblnl
func scalblnl(arg : __float_128, exp : long) : __float_128
Multiplies a floating-point value arg by FLT_RADIX raised to power exp. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned.

Parameters

  • arg - floating-point value @param exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn
  • exp - integer value @return If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

Returns

If no errors occur, arg multiplied by FLT_RADIX to the power of exp (arg×FLT_RADIXexp) is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned. If a range error due to underflow occurs, the correct result (after rounding) is returned. @see https:en.cppreference.com/w/c/numeric/math/scalbn

See Also

  • https:en.cppreference.com/w/c/numeric/math/scalbn
Publicfunction ilogbf
func ilogbf(arg : float) : int
Extracts the value of the unbiased exponent from the floating-point argument arg, and returns it as a signed integer value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur.

Parameters

  • arg - floating-point value @return If no errors occur, the unbiased exponent of arg is returned as a signed int value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur. @see https:en.cppreference.com/w/c/numeric/math/ilogb

Returns

If no errors occur, the unbiased exponent of arg is returned as a signed int value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur. @see https:en.cppreference.com/w/c/numeric/math/ilogb

See Also

  • https:en.cppreference.com/w/c/numeric/math/ilogb
Publicfunction ilogb
func ilogb(arg : double) : int
Extracts the value of the unbiased exponent from the floating-point argument arg, and returns it as a signed integer value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur.

Parameters

  • arg - floating-point value @return If no errors occur, the unbiased exponent of arg is returned as a signed int value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur. @see https:en.cppreference.com/w/c/numeric/math/ilogb

Returns

If no errors occur, the unbiased exponent of arg is returned as a signed int value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur. @see https:en.cppreference.com/w/c/numeric/math/ilogb

See Also

  • https:en.cppreference.com/w/c/numeric/math/ilogb
Publicfunction ilogbl
func ilogbl(arg : __float_128) : int
Extracts the value of the unbiased exponent from the floating-point argument arg, and returns it as a signed integer value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur.

Parameters

  • arg - floating-point value @return If no errors occur, the unbiased exponent of arg is returned as a signed int value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur. @see https:en.cppreference.com/w/c/numeric/math/ilogb

Returns

If no errors occur, the unbiased exponent of arg is returned as a signed int value. If arg is zero, FP_ILOGB0 is returned. If arg is infinite, INT_MAX is returned. If arg is a NaN, FP_ILOGBNAN is returned. If the correct result is greater than INT_MAX or smaller than INT_MIN, the return value is unspecified and a domain error or range error may occur. @see https:en.cppreference.com/w/c/numeric/math/ilogb

See Also

  • https:en.cppreference.com/w/c/numeric/math/ilogb
Publicfunction nextafterf
func nextafterf(from : float, to : float) : float
First, converts both arguments to the type of the function, then returns the next representable value of from in the direction of to. If from equals to to, to is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned.

Parameters

  • from, to - floating-point values @return If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

Returns

If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

See Also

  • https:en.cppreference.com/w/c/numeric/math/nextafter
Publicfunction nextafter
func nextafter(from : double, to : double) : double
First, converts both arguments to the type of the function, then returns the next representable value of from in the direction of to. If from equals to to, to is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned.

Parameters

  • from, to - floating-point values @return If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

Returns

If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

See Also

  • https:en.cppreference.com/w/c/numeric/math/nextafter
Publicfunction nextafterl
func nextafterl(from : __float_128, to : __float_128) : __float_128
First, converts both arguments to the type of the function, then returns the next representable value of from in the direction of to. If from equals to to, to is returned. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned.

Parameters

  • from, to - floating-point values @return If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

Returns

If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

See Also

  • https:en.cppreference.com/w/c/numeric/math/nextafter
Publicfunction nexttowardf
func nexttowardf(from : float, to : __float_128) : float
First, converts the first argument to the type of the function, then returns the next representable value of from in the direction of to. If from equals to to, to is returned, converted from long double to the return type of the function without loss of range or precision. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned.

Parameters

  • from, to - floating-point values @return If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

Returns

If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

See Also

  • https:en.cppreference.com/w/c/numeric/math/nextafter
Publicfunction nexttoward
func nexttoward(from : double, to : __float_128) : double
First, converts the first argument to the type of the function, then returns the next representable value of from in the direction of to. If from equals to to, to is returned, converted from long double to the return type of the function without loss of range or precision. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned.

Parameters

  • from, to - floating-point values @return If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

Returns

If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

See Also

  • https:en.cppreference.com/w/c/numeric/math/nextafter
Publicfunction nexttowardl
func nexttowardl(from : __float_128, to : __float_128) : __float_128
First, converts the first argument to the type of the function, then returns the next representable value of from in the direction of to. If from equals to to, to is returned, converted from long double to the return type of the function without loss of range or precision. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned.

Parameters

  • from, to - floating-point values @return If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

Returns

If no errors occur, the next representable value of from in the direction of to. is returned. If from equals to, then to is returned, converted to the type of the function. If a range error due to overflow occurs, ±HUGE_VAL, ±HUGE_VALF, or ±HUGE_VALL is returned (with the same sign as from). If a range error occurs due to underflow, the correct result is returned. @see https:en.cppreference.com/w/c/numeric/math/nextafter

See Also

  • https:en.cppreference.com/w/c/numeric/math/nextafter
Publicfunction logbf
func logbf(arg : float) : float
Extracts the value of the unbiased radix-independent exponent from the floating-point argument arg, and returns it as a floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the unbiased exponent of arg is returned as a signed floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/logb

Returns

If no errors occur, the unbiased exponent of arg is returned as a signed floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/logb

See Also

  • https:en.cppreference.com/w/c/numeric/math/logb
Publicfunction logb
func logb(arg : double) : double
Extracts the value of the unbiased radix-independent exponent from the floating-point argument arg, and returns it as a floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the unbiased exponent of arg is returned as a signed floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/logb

Returns

If no errors occur, the unbiased exponent of arg is returned as a signed floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/logb

See Also

  • https:en.cppreference.com/w/c/numeric/math/logb
Publicfunction logbl
func logbl(arg : __float_128) : __float_128
Extracts the value of the unbiased radix-independent exponent from the floating-point argument arg, and returns it as a floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

Parameters

  • arg - floating-point value @return If no errors occur, the unbiased exponent of arg is returned as a signed floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/logb

Returns

If no errors occur, the unbiased exponent of arg is returned as a signed floating-point value. If a domain error occurs, an implementation-defined value is returned. If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned. @see https:en.cppreference.com/w/c/numeric/math/logb

See Also

  • https:en.cppreference.com/w/c/numeric/math/logb
Publicfunction copysignf
func copysignf(x : float, y : float) : float
Composes a floating-point value with the magnitude of x and the sign of y. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations.

Parameters

  • x, y - floating-point values @return If no errors occur, the floating-point value with the magnitude of x and the sign of y is returned. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations. @see https:en.cppreference.com/w/c/numeric/math/copysign

Returns

If no errors occur, the floating-point value with the magnitude of x and the sign of y is returned. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations. @see https:en.cppreference.com/w/c/numeric/math/copysign

See Also

  • https:en.cppreference.com/w/c/numeric/math/copysign
Publicfunction copysign
func copysign(x : double, y : double) : double
Composes a floating-point value with the magnitude of x and the sign of y. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations.

Parameters

  • x, y - floating-point values @return If no errors occur, the floating-point value with the magnitude of x and the sign of y is returned. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations. @see https:en.cppreference.com/w/c/numeric/math/copysign

Returns

If no errors occur, the floating-point value with the magnitude of x and the sign of y is returned. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations. @see https:en.cppreference.com/w/c/numeric/math/copysign

See Also

  • https:en.cppreference.com/w/c/numeric/math/copysign
Publicfunction copysignl
func copysignl(x : __float_128, y : __float_128) : __float_128
Composes a floating-point value with the magnitude of x and the sign of y. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations.

Parameters

  • x, y - floating-point values @return If no errors occur, the floating-point value with the magnitude of x and the sign of y is returned. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations. @see https:en.cppreference.com/w/c/numeric/math/copysign

Returns

If no errors occur, the floating-point value with the magnitude of x and the sign of y is returned. If x is NaN, then NaN with the sign of y is returned. If y is -0, the result is only negative if the implementation supports the signed zero consistently in arithmetic operations. @see https:en.cppreference.com/w/c/numeric/math/copysign

See Also

  • https:en.cppreference.com/w/c/numeric/math/copysign
Publictypealias float_t
type float_t = float
TODO macro isunordered #define isunordered(x, y)

See Also

  • https:en.cppreference.com/w/c/numeric/math/isunordered
Publictypealias double_t
type double_t = double

See Also

  • https:en.cppreference.com/w/c/numeric/math/float_t