Builtin type std::prelude::f32

Single precision floating point type

Methods

• fn parse(s: &[u8]) -> Option<f32>

  source

  Parses a floating point number from a string.

  Returns Option::none() if the string does not represent a valid floating point number.

  Example

  assert_eq!(f32::parse("3.1415"), Option::some(3.1415f32));
  assert_eq!(f32::parse("inf"), Option::some(f32::infinity()));
  Run this example

• fn is_sign_negative(self: f32) -> bool

  source

  Returns true if the number has a negative sign, false otherwise.

• fn max_value() -> f32

  source

  Returns the maximum value of f32.

• fn min_value() -> f32

  source

  Returns the minimum value of f32.

• fn min_positive() -> f32

  source

  Returns the smallest positive value of f32.

• fn epsilon() -> f32

  source

  Returns the machine epsilon for f32.

• fn from_bits(bits: u32) -> f32

  source

  Create f64 from raw bits

  Example

  let f = f32::from_bits(0x40490fdb);
  assert_eq!(f, std::math::PI as f32);
  Run this example

• fn to_bits(self: f32) -> u32

  source

  Returns the raw bits of self

  Example

  let x = 1.0f32;
  assert_eq!(x.to_bits(), 0x3f800000u32);
  Run this example

• fn next_up(self: f32) -> f32

  source

  Returns the smallest floating point number strictly greater than self.

  If self is NaN or positive infinity, it returns self unchanged.

  Example

  assert_eq!(0.0f32.next_up(), 1.0e-45f32);
  assert_eq!(1.0f32.next_up(), 1.0000001f32);
  assert_eq!((-1.0f32).next_up(), -0.99999994f32);
  assert_eq!(f32::neg_infinity().next_up(), -3.4028235e38f32);
  assert_eq!(f32::infinity().next_up(), f32::infinity());
  assert!(f32::nan().next_up().is_nan());
  Run this example

• fn next_down(self: f32) -> f32

  source

  Returns the largest floating point number strictly less than self.

  If self is NaN or negative infinity, it returns self unchanged.

  Example

  assert_eq!(0.0f32.next_down(), -1.0e-45f32);
  assert_eq!(1.0f32.next_down(), 0.99999994f32);
  assert_eq!((-1.0f32).next_down(), -1.0000001f32);
  assert_eq!(f32::infinity().next_down(), 3.4028235e38f32);
  assert_eq!(f32::neg_infinity().next_down(), f32::neg_infinity());
  assert!(f32::nan().next_down().is_nan());
  Run this example

• fn acos(self: f32) -> f32

  source

  Inverse cosine

• fn asin(self: f32) -> f32

  source

  Inverse sine

• fn atan(self: f32) -> f32

  source

  Inverse tangent

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

  source

  Four-quadrant inverse tangent

• fn atanh(self: f32) -> f32

  source

  Inverse hyperbolic cosine

• fn cbrt(self: f32) -> f32

  source

  Cube root

• fn ceil(self: f32) -> f32

  source

  Ceiling of number

• fn cos(self: f32) -> f32

  source

  Cosine

• fn cosh(self: f32) -> f32

  source

  Hyperbolic cosine

• fn erf(self: f32) -> f32

  source

  Gauss error function

• fn erfc(self: f32) -> f32

  source

  Complementary error function (1 - erf(self))

• fn exp(self: f32) -> f32

  source

  Exponential function (e^self)

• fn floor(self: f32) -> f32

  source

  Floor of number

• fn frexp(self: f32) -> (f32, i32)

  source

  Decomposes self into a normalized fractional part and an integral power of two.

  Inverse of ldexp.

• fn ldexp(self: f32, exp: i32) -> f32

  source

  Multiplies self by 2 raised to the power of exp.

  Inverse of frexp.

• fn log(self: f32) -> f32

  source

  Natural logarithm

• fn log2(self: f32) -> f32

  source

  Base 2 logarithm

• fn log10(self: f32) -> f32

  source

  Base 10 logarithm

• fn modf(self: f32) -> (f32, f32)

  source

  Decompose self into a whole and fractional part

• fn pow(self: f32, other: f32) -> f32

  source

  Power function

• fn round(self: f32) -> f32

  source

  Rounds self to the closest integer.

  If the number is halfway between two integers, it is rounded away from zero.

• fn sin(self: f32) -> f32

  source

  Sine function

• fn sinh(self: f32) -> f32

  source

  Hyperbolic sine function

• fn sqrt(self: f32) -> f32

  source

  Square root

• fn tan(self: f32) -> f32

  source

  Tangent function

• fn tanh(self: f32) -> f32

  source

  Hyperbolic tangent function

• fn trunc(self: f32) -> f32

  source

  Returns the integer part of self (round towards zero).

Mixins

• mixin BuiltinComparable<f32>

• fn equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if arguments are equal, false otherwise

  See Equatable for details.

• fn not_equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns false if arguments are equal, true otherwise

• fn compare(lhs: &Self, rhs: &Self) -> Ordering

  source

  Compare the value

  See Comparable for details.

• fn less_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is strictly less than rhs, false otherwise

• fn less_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is less or equal to rhs, false otherwise

• fn greater_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs strictly greater than rhs, false otherwise

• fn greater_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs greater than or equal rhs, false otherwise

• mixin<F> FloatFormattable<f32, F>

  F: Formatter<F>

• fn fmt(self: &Self, formatter: &mut F) -> Result<(), Error>

  source

  Write the object into a given formatter.

  See Formattable for details.

• mixin FloatOps<f32>

• fn nan() -> Self

  source

  Returns NaN.

• fn infinity() -> Self

  source

  Returns a positive infinity.

• fn neg_infinity() -> Self

  source

  Returns a negative infinity.

• fn is_nan(self: Self) -> bool

  source

  Returns true if the number is NaN, false otherwise.

• fn is_infinite(self: Self) -> bool

  source

  Returns true if the number is infinite, false otherwise.

• fn is_finite(self: Self) -> bool

  source

  Returns true if the number is neither infinite nor NaN, false otherwise.