api

math.ch

Declarations in math.ch

203 declarationscstd

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
Chemical API Referencechemicallang.com  ·  GitHub