Primitive Type f32 

A 32-bit floating-point type (specifically, the “binary32” type defined in IEEE 754-2008).

This type can represent a wide range of decimal numbers, like 3.5, 27, -113.75, 0.0078125, 34359738368, 0, -1. So unlike integer types (such as i32), floating-point types can represent non-integer numbers, too.

However, being able to represent this wide range of numbers comes at the cost of precision: floats can only represent some of the real numbers and calculation with floats round to a nearby representable number. For example, 5.0 and 1.0 can be exactly represented as f32, but 1.0 / 5.0 results in 0.20000000298023223876953125 since 0.2 cannot be exactly represented as f32. Note, however, that printing floats with println and friends will often discard insignificant digits: println!("{}", 1.0f32 / 5.0f32) will print 0.2.

Additionally, f32 can represent some special values:

• −0.0: IEEE 754 floating-point numbers have a bit that indicates their sign, so −0.0 is a possible value. For comparison −0.0 = +0.0, but floating-point operations can carry the sign bit through arithmetic operations. This means −0.0 × +0.0 produces −0.0 and a negative number rounded to a value smaller than a float can represent also produces −0.0.
• ∞ and −∞: these result from calculations like 1.0 / 0.0.
• NaN (not a number): this value results from calculations like (-1.0).sqrt(). NaN has some potentially unexpected behavior:
  • It is not equal to any float, including itself! This is the reason f32 doesn’t implement the Eq trait.
  • It is also neither smaller nor greater than any float, making it impossible to sort by the default comparison operation, which is the reason f32 doesn’t implement the Ord trait.
  • It is also considered infectious as almost all calculations where one of the operands is NaN will also result in NaN. The explanations on this page only explicitly document behavior on NaN operands if this default is deviated from.
  • Lastly, there are multiple bit patterns that are considered NaN. Rust does not currently guarantee that the bit patterns of NaN are preserved over arithmetic operations, and they are not guaranteed to be portable or even fully deterministic! This means that there may be some surprising results upon inspecting the bit patterns, as the same calculations might produce NaNs with different bit patterns. This also affects the sign of the NaN: checking is_sign_positive or is_sign_negative on a NaN is the most common way to run into these surprising results. (Checking x >= 0.0 or x <= 0.0 avoids those surprises, but also how negative/positive zero are treated.) See the section below for what exactly is guaranteed about the bit pattern of a NaN.

When a primitive operation (addition, subtraction, multiplication, or division) is performed on this type, the result is rounded according to the roundTiesToEven direction defined in IEEE 754-2008. That means:

• The result is the representable value closest to the true value, if there is a unique closest representable value.
• If the true value is exactly half-way between two representable values, the result is the one with an even least-significant binary digit.
• If the true value’s magnitude is ≥ f32::MAX + 2^{(f32::MAX_EXP − f32::MANTISSA_DIGITS − 1)}, the result is ∞ or −∞ (preserving the true value’s sign).
• If the result of a sum exactly equals zero, the outcome is +0.0 unless both arguments were negative, then it is -0.0. Subtraction a - b is regarded as a sum a + (-b).

For more information on floating-point numbers, see Wikipedia.

See also the std::f32::consts module.

NaN bit patterns

This section defines the possible NaN bit patterns returned by floating-point operations.

The bit pattern of a floating-point NaN value is defined by:

• a sign bit.
• a quiet/signaling bit. Rust assumes that the quiet/signaling bit being set to 1 indicates a quiet NaN (QNaN), and a value of 0 indicates a signaling NaN (SNaN). In the following we will hence just call it the “quiet bit”.
• a payload, which makes up the rest of the significand (i.e., the mantissa) except for the quiet bit.

The rules for NaN values differ between arithmetic and non-arithmetic (or “bitwise”) operations. The non-arithmetic operations are unary -, abs, copysign, signum, {to,from}_bits, {to,from}_{be,le,ne}_bytes and is_sign_{positive,negative}. These operations are guaranteed to exactly preserve the bit pattern of their input except for possibly changing the sign bit.

The following rules apply when a NaN value is returned from an arithmetic operation:

• The result has a non-deterministic sign.

• The quiet bit and payload are non-deterministically chosen from the following set of options:

  • Preferred NaN: The quiet bit is set and the payload is all-zero.
  • Quieting NaN propagation: The quiet bit is set and the payload is copied from any input operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for as casts), then
    • If the output is smaller than the input, low-order bits of the payload get dropped.
    • If the output is larger than the input, the payload gets filled up with 0s in the low-order bits.
  • Unchanged NaN propagation: The quiet bit and payload are copied from any input operand that is a NaN. If the inputs and outputs do not have the same size (i.e., for as casts), the same rules as for “quieting NaN propagation” apply, with one caveat: if the output is smaller than the input, dropping the low-order bits may result in a payload of 0; a payload of 0 is not possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN propagation cannot occur with some inputs.
  • Target-specific NaN: The quiet bit is set and the payload is picked from a target-specific set of “extra” possible NaN payloads. The set can depend on the input operand values. See the table below for the concrete NaNs this set contains on various targets.

In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input value. Similarly, if all input NaNs are preferred (or if there are no input NaNs) and the target does not have any “extra” NaN payloads, then the output NaN is guaranteed to be preferred.

The non-deterministic choice happens when the operation is executed; i.e., the result of a NaN-producing floating-point operation is a stable bit pattern (looking at these bits multiple times will yield consistent results), but running the same operation twice with the same inputs can produce different results.

These guarantees are neither stronger nor weaker than those of IEEE 754: IEEE 754 guarantees that an operation never returns a signaling NaN, whereas it is possible for operations like SNAN * 1.0 to return a signaling NaN in Rust. Conversely, IEEE 754 makes no statement at all about which quiet NaN is returned, whereas Rust restricts the set of possible results to the ones listed above.

Unless noted otherwise, the same rules also apply to NaNs returned by other library functions (e.g. min, minimum, max, maximum); other aspects of their semantics and which IEEE 754 operation they correspond to are documented with the respective functions.

When an arithmetic floating-point operation is executed in const context, the same rules apply: no guarantee is made about which of the NaN bit patterns described above will be returned. The result does not have to match what happens when executing the same code at runtime, and the result can vary depending on factors such as compiler version and flags.

Target-specific “extra” NaN values

target_arch	Extra payloads possible on this platform
aarch64, arm, arm64ec, loongarch64, powerpc (except when target_abi = "spe"), powerpc64, riscv32, riscv64, s390x, x86, x86_64	None
nvptx64	All payloads
sparc, sparc64	The all-one payload
wasm32, wasm64	If all input NaNs are quiet with all-zero payload: None. Otherwise: all payloads.

For targets not in this table, all payloads are possible.

Algebraic operators

Algebraic operators of the form a.algebraic_*(b) allow the compiler to optimize floating point operations using all the usual algebraic properties of real numbers – despite the fact that those properties do not hold on floating point numbers. This can give a great performance boost since it may unlock vectorization.

The exact set of optimizations is unspecified but typically allows combining operations, rearranging series of operations based on mathematical properties, converting between division and reciprocal multiplication, and disregarding the sign of zero. This means that the results of elementary operations may have undefined precision, and “non-mathematical” values such as NaN, +/-Inf, or -0.0 may behave in unexpected ways, but these operations will never cause undefined behavior.

Algebraic operations are non-deterministic. This means that two invocations of such an operation with the same inputs may produce different results even within a single program run. No guarantees are made about the results of individual operations, except that they produce some valid floating-point value. Unsafe code must not rely on any property of the return value for soundness. However, implementations will generally do their best to pick a reasonable tradeoff between performance and accuracy of the result.

For example:

x = a.algebraic_add(b).algebraic_add(c).algebraic_add(d);

May be rewritten as:

x = ((a + b) + c) + d; // As written
x = (a + c) + (b + d); // Reordered to shorten critical path and enable vectorization

The following example demonstrates the non-determinism:

let x1 = a.algebraic_add(b);
let x2 = a.algebraic_add(b);
assert_eq!(x1.to_bits(), x1.to_bits()); // this is guaranteed
assert_eq!(x1.to_bits(), x2.to_bits()); // but this may fail
assert!(!x2.is_nan()); // this may also fail, even if there was no NaN input

Implementations

impl f32

pub const fn floor(self) -> f32

Returns the largest integer that is less than or equal to self.

This function always returns the precise result.

Examples

let f = 3.7_f32;
let g = 3.0_f32;
let h = -3.7_f32;

assert_eq!(f.floor(), 3.0);
assert_eq!(g.floor(), 3.0);
assert_eq!(h.floor(), -4.0);

pub const fn ceil(self) -> f32

Returns the smallest integer that is greater than or equal to self.

This function always returns the precise result.

Examples

let f = 3.01_f32;
let g = 4.0_f32;
let h = -3.01_f32;

assert_eq!(f.ceil(), 4.0);
assert_eq!(g.ceil(), 4.0);
assert_eq!(h.ceil(), -3.0);

pub const fn round(self) -> f32

Returns the nearest integer to self. If a value is half-way between two integers, round away from 0.0.

This function always returns the precise result.

On most hardware platforms, round_ties_even may execute faster than round. If both rounding methods fit the use case, consider using round_ties_even. Note that the two methods apply different rounding rules to values exactly halfway between two integers.

Examples

let f = 3.3_f32;
let g = -3.3_f32;
let h = -3.7_f32;
let i = 3.5_f32;
let j = 4.5_f32;

assert_eq!(f.round(), 3.0);
assert_eq!(g.round(), -3.0);
assert_eq!(h.round(), -4.0);
assert_eq!(i.round(), 4.0);
assert_eq!(j.round(), 5.0);

pub const fn round_ties_even(self) -> f32

Returns the nearest integer to a number. Rounds half-way cases to the number with an even least significant digit.

This function always returns the precise result.

Examples

let f = 3.3_f32;
let g = -3.3_f32;
let h = 3.5_f32;
let i = 4.5_f32;

assert_eq!(f.round_ties_even(), 3.0);
assert_eq!(g.round_ties_even(), -3.0);
assert_eq!(h.round_ties_even(), 4.0);
assert_eq!(i.round_ties_even(), 4.0);

pub const fn trunc(self) -> f32

Returns the integer part of self. This means that non-integer numbers are always truncated towards zero.

This function always returns the precise result.

Examples

let f = 3.7_f32;
let g = 3.0_f32;
let h = -3.7_f32;

assert_eq!(f.trunc(), 3.0);
assert_eq!(g.trunc(), 3.0);
assert_eq!(h.trunc(), -3.0);

pub const fn fract(self) -> f32

Returns the fractional part of self.

This function always returns the precise result.

Examples

let x = 3.6_f32;
let y = -3.6_f32;
let abs_difference_x = (x.fract() - 0.6).abs();
let abs_difference_y = (y.fract() - (-0.6)).abs();

assert!(abs_difference_x <= f32::EPSILON);
assert!(abs_difference_y <= f32::EPSILON);

pub const fn mul_add(self, a: f32, b: f32) -> f32

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

Using mul_add may be more performant than an unfused multiply-add if the target architecture has a dedicated fma CPU instruction. However, this is not always true, and will be heavily dependant on designing algorithms with specific target hardware in mind.

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result. It is specified by IEEE 754 as fusedMultiplyAdd and guaranteed not to change.

Examples

let m = 10.0_f32;
let x = 4.0_f32;
let b = 60.0_f32;

assert_eq!(m.mul_add(x, b), 100.0);
assert_eq!(m * x + b, 100.0);

let one_plus_eps = 1.0_f32 + f32::EPSILON;
let one_minus_eps = 1.0_f32 - f32::EPSILON;
let minus_one = -1.0_f32;

// The exact result (1 + eps) * (1 - eps) = 1 - eps * eps.
assert_eq!(one_plus_eps.mul_add(one_minus_eps, minus_one), -f32::EPSILON * f32::EPSILON);
// Different rounding with the non-fused multiply and add.
assert_eq!(one_plus_eps * one_minus_eps + minus_one, 0.0);

pub fn div_euclid(self, rhs: f32) -> f32

Calculates Euclidean division, the matching method for rem_euclid.

This computes the integer n such that self = n * rhs + self.rem_euclid(rhs). In other words, the result is self / rhs rounded to the integer n such that self >= n * rhs.

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result.

Examples

let a: f32 = 7.0;
let b = 4.0;
assert_eq!(a.div_euclid(b), 1.0); // 7.0 > 4.0 * 1.0
assert_eq!((-a).div_euclid(b), -2.0); // -7.0 >= 4.0 * -2.0
assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0
assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0

pub fn rem_euclid(self, rhs: f32) -> f32

Calculates the least nonnegative remainder of self when divided by rhs.

In particular, the return value r satisfies 0.0 <= r < rhs.abs() in most cases. However, due to a floating point round-off error it can result in r == rhs.abs(), violating the mathematical definition, if self is much smaller than rhs.abs() in magnitude and self < 0.0. This result is not an element of the function’s codomain, but it is the closest floating point number in the real numbers and thus fulfills the property self == self.div_euclid(rhs) * rhs + self.rem_euclid(rhs) approximately.

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result.

Examples

let a: f32 = 7.0;
let b = 4.0;
assert_eq!(a.rem_euclid(b), 3.0);
assert_eq!((-a).rem_euclid(b), 1.0);
assert_eq!(a.rem_euclid(-b), 3.0);
assert_eq!((-a).rem_euclid(-b), 1.0);
// limitation due to round-off error
assert!((-f32::EPSILON).rem_euclid(3.0) != 0.0);

pub fn powi(self, n: i32) -> f32

Raises a number to an integer power.

Using this function is generally faster than using powf. It might have a different sequence of rounding operations than powf, so the results are not guaranteed to agree.

Note that this function is special in that it can return non-NaN results for NaN inputs. For example, f32::powi(f32::NAN, 0) returns 1.0. However, if an input is a signaling NaN, then the result is non-deterministically either a NaN or the result that the corresponding quiet NaN would produce.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let x = 2.0_f32;
let abs_difference = (x.powi(2) - (x * x)).abs();
assert!(abs_difference <= 1e-5);

assert_eq!(f32::powi(f32::NAN, 0), 1.0);
assert_eq!(f32::powi(0.0, 0), 1.0);

pub fn powf(self, n: f32) -> f32

Raises a number to a floating point power.

Note that this function is special in that it can return non-NaN results for NaN inputs. For example, f32::powf(f32::NAN, 0.0) returns 1.0. However, if an input is a signaling NaN, then the result is non-deterministically either a NaN or the result that the corresponding quiet NaN would produce.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let x = 2.0_f32;
let abs_difference = (x.powf(2.0) - (x * x)).abs();
assert!(abs_difference <= 1e-5);

assert_eq!(f32::powf(1.0, f32::NAN), 1.0);
assert_eq!(f32::powf(f32::NAN, 0.0), 1.0);
assert_eq!(f32::powf(0.0, 0.0), 1.0);

pub fn sqrt(self) -> f32

Returns the square root of a number.

Returns NaN if self is a negative number other than -0.0.

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result. It is specified by IEEE 754 as squareRoot and guaranteed not to change.

Examples

let positive = 4.0_f32;
let negative = -4.0_f32;
let negative_zero = -0.0_f32;

assert_eq!(positive.sqrt(), 2.0);
assert!(negative.sqrt().is_nan());
assert!(negative_zero.sqrt() == negative_zero);

pub fn exp(self) -> f32

Returns e^(self), (the exponential function).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let one = 1.0f32;
// e^1
let e = one.exp();

// ln(e) - 1 == 0
let abs_difference = (e.ln() - 1.0).abs();

assert!(abs_difference <= 1e-6);

pub fn exp2(self) -> f32

Returns 2^(self).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let f = 2.0f32;

// 2^2 - 4 == 0
let abs_difference = (f.exp2() - 4.0).abs();

assert!(abs_difference <= 1e-5);

pub fn ln(self) -> f32

Returns the natural logarithm of the number.

This returns NaN when the number is negative, and negative infinity when number is zero.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let one = 1.0f32;
// e^1
let e = one.exp();

// ln(e) - 1 == 0
let abs_difference = (e.ln() - 1.0).abs();

assert!(abs_difference <= 1e-6);

Non-positive values:

assert_eq!(0_f32.ln(), f32::NEG_INFINITY);
assert!((-42_f32).ln().is_nan());

pub fn log(self, base: f32) -> f32

Returns the logarithm of the number with respect to an arbitrary base.

This returns NaN when the number is negative, and negative infinity when number is zero.

The result might not be correctly rounded owing to implementation details; self.log2() can produce more accurate results for base 2, and self.log10() can produce more accurate results for base 10.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let five = 5.0f32;

// log5(5) - 1 == 0
let abs_difference = (five.log(5.0) - 1.0).abs();

assert!(abs_difference <= 1e-6);

Non-positive values:

assert_eq!(0_f32.log(10.0), f32::NEG_INFINITY);
assert!((-42_f32).log(10.0).is_nan());

pub fn log2(self) -> f32

Returns the base 2 logarithm of the number.

This returns NaN when the number is negative, and negative infinity when number is zero.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let two = 2.0f32;

// log2(2) - 1 == 0
let abs_difference = (two.log2() - 1.0).abs();

assert!(abs_difference <= 1e-6);

Non-positive values:

assert_eq!(0_f32.log2(), f32::NEG_INFINITY);
assert!((-42_f32).log2().is_nan());

pub fn log10(self) -> f32

Returns the base 10 logarithm of the number.

This returns NaN when the number is negative, and negative infinity when number is zero.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let ten = 10.0f32;

// log10(10) - 1 == 0
let abs_difference = (ten.log10() - 1.0).abs();

assert!(abs_difference <= 1e-6);

Non-positive values:

assert_eq!(0_f32.log10(), f32::NEG_INFINITY);
assert!((-42_f32).log10().is_nan());

pub fn abs_sub(self, other: f32) -> f32

👎Deprecated since 1.10.0:

you probably meant (self - other).abs(): this operation is (self - other).max(0.0) except that abs_sub also propagates NaNs (also known as fdimf in C). If you truly need the positive difference, consider using that expression or the C function fdimf, depending on how you wish to handle NaN (please consider filing an issue describing your use-case too).

The positive difference of two numbers.

• If self <= other: 0.0
• Else: self - other

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the fdimf from libc on Unix and Windows. Note that this might change in the future.

Examples

let x = 3.0f32;
let y = -3.0f32;

let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();

assert!(abs_difference_x <= 1e-6);
assert!(abs_difference_y <= 1e-6);

pub fn cbrt(self) -> f32

Returns the cube root of a number.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the cbrtf from libc on Unix and Windows. Note that this might change in the future.

Examples

let x = 8.0f32;

// x^(1/3) - 2 == 0
let abs_difference = (x.cbrt() - 2.0).abs();

assert!(abs_difference <= 1e-6);

pub fn hypot(self, other: f32) -> f32

Compute the distance between the origin and a point (x, y) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length x.abs() and y.abs().

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the hypotf from libc on Unix and Windows. Note that this might change in the future.

Examples

let x = 2.0f32;
let y = 3.0f32;

// sqrt(x^2 + y^2)
let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();

assert!(abs_difference <= 1e-5);

pub fn sin(self) -> f32

Computes the sine of a number (in radians).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let x = std::f32::consts::FRAC_PI_2;

let abs_difference = (x.sin() - 1.0).abs();

assert!(abs_difference <= 1e-6);

pub fn cos(self) -> f32

Computes the cosine of a number (in radians).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next.

Examples

let x = 2.0 * std::f32::consts::PI;

let abs_difference = (x.cos() - 1.0).abs();

assert!(abs_difference <= 1e-6);

pub fn tan(self) -> f32

Computes the tangent of a number (in radians).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the tanf from libc on Unix and Windows. Note that this might change in the future.

Examples

let x = std::f32::consts::FRAC_PI_4;
let abs_difference = (x.tan() - 1.0).abs();

assert!(abs_difference <= 1e-6);

pub fn asin(self) -> f32

Computes the arcsine of a number. Return value is in radians in the range [-pi/2, pi/2] or NaN if the number is outside the range [-1, 1].

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the asinf from libc on Unix and Windows. Note that this might change in the future.

Examples

let f = std::f32::consts::FRAC_PI_4;

// asin(sin(pi/2))
let abs_difference = (f.sin().asin() - f).abs();

assert!(abs_difference <= 1e-6);

pub fn acos(self) -> f32

Computes the arccosine of a number. Return value is in radians in the range [0, pi] or NaN if the number is outside the range [-1, 1].

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the acosf from libc on Unix and Windows. Note that this might change in the future.

Examples

let f = std::f32::consts::FRAC_PI_4;

// acos(cos(pi/4))
let abs_difference = (f.cos().acos() - std::f32::consts::FRAC_PI_4).abs();

assert!(abs_difference <= 1e-6);

pub fn atan(self) -> f32

Computes the arctangent of a number. Return value is in radians in the range [-pi/2, pi/2];

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the atanf from libc on Unix and Windows. Note that this might change in the future.

Examples

let f = 1.0f32;

// atan(tan(1))
let abs_difference = (f.tan().atan() - 1.0).abs();

assert!(abs_difference <= 1e-6);

pub fn atan2(self, other: f32) -> f32

Computes the four quadrant arctangent of self (y) and other (x) in radians.

x	y	Piecewise Definition	Range
>= +0	>= +0	arctan(y/x)	[+0, +pi/2]
>= +0	<= -0	arctan(y/x)	[-pi/2, -0]
<= -0	>= +0	arctan(y/x) + pi	[+pi/2, +pi]
<= -0	<= -0	arctan(y/x) - pi	[-pi, -pi/2]

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the atan2f from libc on Unix and Windows. Note that this might change in the future.

Examples

// Positive angles measured counter-clockwise
// from positive x axis
// -pi/4 radians (45 deg clockwise)
let x1 = 3.0f32;
let y1 = -3.0f32;

// 3pi/4 radians (135 deg counter-clockwise)
let x2 = -3.0f32;
let y2 = 3.0f32;

let abs_difference_1 = (y1.atan2(x1) - (-std::f32::consts::FRAC_PI_4)).abs();
let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f32::consts::FRAC_PI_4)).abs();

assert!(abs_difference_1 <= 1e-5);
assert!(abs_difference_2 <= 1e-5);

pub fn sin_cos(self) -> (f32, f32)

Simultaneously computes the sine and cosine of the number, x. Returns (sin(x), cos(x)).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, Rust version, and can even differ within the same execution from one invocation to the next. This function currently corresponds to the (f32::sin(x), f32::cos(x)). Note that this might change in the future.

Examples