Home / cstd / math.ch

math.ch

Declarations

Public Only
fabsf
Publicfunction
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
fabs
Publicfunction
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
fabsl
Publicfunction
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
_Decimal32
Publictypealias
type _Decimal32 = float
TODO
_Decimal64
Publictypealias
type _Decimal64 = double
_Decimal128
Publictypealias
type _Decimal128 = unknown
fabsd32
Publicfunction
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
fabsd64
Publicfunction
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
fabsd128
Publicfunction
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
fmodf
Publicfunction
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
fmod
Publicfunction
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
fmodl
Publicfunction
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
remainderf
Publicfunction
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
remainder
Publicfunction
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
remainderl
Publicfunction
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
remquof
Publicfunction
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
remquo
Publicfunction
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
remquol
Publicfunction
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
fmaf
Publicfunction
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
fma
Publicfunction
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
fmal
Publicfunction
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
fmaxf
Publicfunction
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
fmax
Publicfunction
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
fmaxl
Publicfunction
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
fminf
Publicfunction
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
fmin
Publicfunction
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
fminl
Publicfunction
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
fdimf
Publicfunction
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
fdim
Publicfunction
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
fdiml
Publicfunction
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
nanf
Publicfunction
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
nan
Publicfunction
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
nanl
Publicfunction
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
nand32
Publicfunction
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
nand64
Publicfunction
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
nand128
Publicfunction
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
expf
Publicfunction
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
exp
Publicfunction
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
expl
Publicfunction
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
exp2f
Publicfunction
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
exp2
Publicfunction
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
exp2l
Publicfunction
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
expm1f
Publicfunction
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
expm1
Publicfunction
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
expm1l
Publicfunction
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
logf
Publicfunction
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
log
Publicfunction
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
logl
Publicfunction
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
log10f
Publicfunction
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
log10
Publicfunction
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
log10l
Publicfunction
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
log2f
Publicfunction
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
log2
Publicfunction
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
log2l
Publicfunction
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
log1pf
Publicfunction
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
log1p
Publicfunction
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
log1pl
Publicfunction
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
powf
Publicfunction
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
pow
Publicfunction
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
powl
Publicfunction
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
sqrtf
Publicfunction
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
sqrt
Publicfunction
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
sqrtl
Publicfunction
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
cbrtf
Publicfunction
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
cbrt
Publicfunction
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
cbrtl
Publicfunction
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
hypotf
Publicfunction
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
hypot
Publicfunction
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
hypotl
Publicfunction
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
sinf
Publicfunction
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
sin
Publicfunction
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
sinl
Publicfunction
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
sind32
Publicfunction
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
sind64
Publicfunction
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
sind128
Publicfunction
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
cosf
Publicfunction
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
cos
Publicfunction
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
cosl
Publicfunction
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
cosd32
Publicfunction
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
cosd64
Publicfunction
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
cosd128
Publicfunction
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
tanf
Publicfunction
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
tan
Publicfunction
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
tanl
Publicfunction
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
tand32
Publicfunction
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
tand64
Publicfunction
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
tand128
Publicfunction
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
asinf
Publicfunction
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
asin
Publicfunction
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
asinl
Publicfunction
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
asind32
Publicfunction
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
asind64
Publicfunction
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
asind128
Publicfunction
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
acosf
Publicfunction
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
acos
Publicfunction
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
acosl
Publicfunction
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
acosd32
Publicfunction
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
acosd64
Publicfunction
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
acosd128
Publicfunction
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
atanf
Publicfunction
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
atan
Publicfunction
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
atanl
Publicfunction
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
atand32
Publicfunction
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
atand64
Publicfunction
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
atand128
Publicfunction
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
atan2f
Publicfunction
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
atan2
Publicfunction
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
atan2l
Publicfunction
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
atan2d32
Publicfunction
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
atan2d64
Publicfunction
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
atan2d128
Publicfunction
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
sinhf
Publicfunction
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
sinh
Publicfunction
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
sinhl
Publicfunction
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
coshf
Publicfunction
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
cosh
Publicfunction
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
coshl
Publicfunction
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
tanhf
Publicfunction
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
tanh
Publicfunction
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
tanhl
Publicfunction
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
asinhf
Publicfunction
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
asinh
Publicfunction
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
asinhl
Publicfunction
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
acoshf
Publicfunction
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
acosh
Publicfunction
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
acoshl
Publicfunction
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
atanhf
Publicfunction
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
atanh
Publicfunction
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
atanhl
Publicfunction
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
erff
Publicfunction
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
erf
Publicfunction
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
erfl
Publicfunction
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
erfcf
Publicfunction
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
erfc
Publicfunction
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
erfcl
Publicfunction
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
tgammaf
Publicfunction
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
tgamma
Publicfunction
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
tgammal
Publicfunction
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
lgammaf
Publicfunction
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
lgamma
Publicfunction
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
lgammal
Publicfunction
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
ceilf
Publicfunction
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
ceil
Publicfunction
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
ceill
Publicfunction
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
floorf
Publicfunction
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
floor
Publicfunction
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
floorl
Publicfunction
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
truncf
Publicfunction
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
trunc
Publicfunction
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
truncl
Publicfunction
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
roundf
Publicfunction
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
round
Publicfunction
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
roundl
Publicfunction
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
lroundf
Publicfunction
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
lround
Publicfunction
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
lroundl
Publicfunction
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
llroundf
Publicfunction
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
llround
Publicfunction
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
llroundl
Publicfunction
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
nearbyintf
Publicfunction
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
nearbyint
Publicfunction
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
nearbyintl
Publicfunction
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
rintf
Publicfunction
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
rint
Publicfunction
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
rintl
Publicfunction
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
lrintf
Publicfunction
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
lrint
Publicfunction
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
lrintl
Publicfunction
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
llrintf
Publicfunction
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
llrint
Publicfunction
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
llrintl
Publicfunction
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
frexpf
Publicfunction
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
frexp
Publicfunction
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
frexpl
Publicfunction
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
ldexpf
Publicfunction
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
ldexp
Publicfunction
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
ldexpl
Publicfunction
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
modff
Publicfunction
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
modf
Publicfunction
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
modfl
Publicfunction
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
scalbnf
Publicfunction
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
scalbn
Publicfunction
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
scalbnl
Publicfunction
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
scalblnf
Publicfunction
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
scalbln
Publicfunction
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
scalblnl
Publicfunction
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
ilogbf
Publicfunction
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
ilogb
Publicfunction
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
ilogbl
Publicfunction
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
nextafterf
Publicfunction
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
nextafter
Publicfunction
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
nextafterl
Publicfunction
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
nexttowardf
Publicfunction
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
nexttoward
Publicfunction
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
nexttowardl
Publicfunction
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
logbf
Publicfunction
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
logb
Publicfunction
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
logbl
Publicfunction
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
copysignf
Publicfunction
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
copysign
Publicfunction
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
copysignl
Publicfunction
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
float_t
Publictypealias
type float_t = float
TODO macro isunordered #define isunordered(x, y)

See Also

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

See Also

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