math

Returns NaN (rather than throwing) for a negative radicand; sqrt(-0.0) is -0.0 and sqrt(+inf) is +inf.

Defined for the whole real line, including negatives (unlike sqrt): the result keeps the sign of x, so cbrt(-8) is -2.

Returns the largest integral value not greater than x as a double; already-integral, NaN, and ±∞ inputs are returned unchanged, and the sign of zero is preserved.

Returns the smallest integral value not less than x as a double; already-integral, NaN, and ±∞ inputs are returned unchanged. For x in (−1, 0) the result is -0.0.

Discards the fractional part, rounding toward zero rather than ±∞ (so it differs from floor on negatives, e.g. trunc(-2.7) is -2.0); the sign of x, NaN, and ±∞ are preserved.

Halfway cases are rounded away from zero, not to even, so round(2.5) is 3 and round(-2.5) is -3 — this differs from Python's banker's rounding; NaN and ±∞ pass through unchanged.

Overflows to +inf for large x and underflows to 0 for large negative x; exp(-inf) is 0 and exp(+inf) is +inf.

Returns -inf for x == 0 and NaN (rather than throwing) for negative x; out-of-domain input never raises an exception.

Returns -inf for x == 0 and NaN for negative x, matching log's out-of-domain behavior.

Returns -inf for x == 0 and NaN for negative x, matching log's out-of-domain behavior.

The argument is interpreted in radians; precision degrades for very large magnitudes due to argument reduction, and sin(±inf) is NaN.

The argument is interpreted in radians; precision degrades for very large magnitudes due to argument reduction, and cos(±inf) is NaN.

The argument is in radians; near the poles (odd multiples of π/2, which are not exactly representable) the result is a large finite value rather than ±∞, and tan(±inf) is NaN.

Returns a value in [−π/2, π/2]; arguments outside [−1, 1] yield NaN rather than throwing.

Returns a value in [0, π]; arguments outside [−1, 1] yield NaN rather than throwing.

Accepts the whole real line and returns a value in (−π/2, π/2), approaching ±π/2 as x → ±∞.

Uses the signs of both arguments to select the correct quadrant, returning a value in (−π, π]; it is well-defined when x is zero (including the atan2(0, 0) case, which returns 0).

Computes the 2-norm while avoiding intermediate overflow/underflow that a naive sqrt(x*x + y*y) would suffer; returns +inf if either argument is infinite (even when the other is NaN).

Returns x - n*y for the integer n truncated toward zero, so the result takes the sign of the dividend x (unlike a Python-style modulo); a zero divisor yields NaN rather than throwing.

Takes the magnitude from x and the sign bit from y; because it copies the IEEE sign bit, it distinguishes +0.0 from -0.0 and works even when x is NaN.

The reliable NaN test, since NaN compares unequal to everything including itself (so x != x is the only other portable check).

True for both +inf and -inf; false for NaN (use isnan for that) and for every finite value.

Operates on the absolute values via the Euclidean algorithm, so the result is non-negative; gcd(0, 0) is 0 and gcd(n, 0) is |n|. Passing LLONG_MIN overflows when negated.

Computed by an iterative product from 2; n of 0 or 1 returns 1, and any negative n also returns 1 since the loop never executes (no error is raised). Results past 20! silently overflow long long.

Returns a reference bound to whichever argument compares smaller; on a tie (neither b < a) it returns a. Because the result is a reference into the caller's arguments, it dangles when the operands are temporaries.

Returns a reference bound to whichever argument compares larger; on a tie (neither a < b) it returns a. As with min, the returned reference dangles if the operands are temporaries.

Both operands are cast to double and forwarded to std::pow, so this follows IEEE-754 semantics (e.g. pow(0, 0) is 1, and a negative base with a non-integer exponent yields NaN); integer arguments lose exactness beyond 2^53.