1.0.0[−]Primitive Type f32
The 32-bit floating point type.
Methods
impl f32[src]
impl f32pub fn floor(self) -> f32[src]
pub fn floor(self) -> f32Returns the largest integer less than or equal to a number.
Examples
let f = 3.99_f32; let g = 3.0_f32; assert_eq!(f.floor(), 3.0); assert_eq!(g.floor(), 3.0);Run
pub fn ceil(self) -> f32[src]
pub fn ceil(self) -> f32Returns the smallest integer greater than or equal to a number.
Examples
let f = 3.01_f32; let g = 4.0_f32; assert_eq!(f.ceil(), 4.0); assert_eq!(g.ceil(), 4.0);Run
pub fn round(self) -> f32[src]
pub fn round(self) -> f32Returns the nearest integer to a number. Round half-way cases away from
0.0.
Examples
let f = 3.3_f32; let g = -3.3_f32; assert_eq!(f.round(), 3.0); assert_eq!(g.round(), -3.0);Run
pub fn trunc(self) -> f32[src]
pub fn trunc(self) -> f32Returns the integer part of a number.
Examples
let f = 3.3_f32; let g = -3.7_f32; assert_eq!(f.trunc(), 3.0); assert_eq!(g.trunc(), -3.0);Run
pub fn fract(self) -> f32[src]
pub fn fract(self) -> f32Returns the fractional part of a number.
Examples
use std::f32; let x = 3.5_f32; let y = -3.5_f32; let abs_difference_x = (x.fract() - 0.5).abs(); let abs_difference_y = (y.fract() - (-0.5)).abs(); assert!(abs_difference_x <= f32::EPSILON); assert!(abs_difference_y <= f32::EPSILON);Run
pub fn abs(self) -> f32[src]
pub fn abs(self) -> f32Computes the absolute value of self. Returns NAN if the
number is NAN.
Examples
use std::f32; let x = 3.5_f32; let y = -3.5_f32; let abs_difference_x = (x.abs() - x).abs(); let abs_difference_y = (y.abs() - (-y)).abs(); assert!(abs_difference_x <= f32::EPSILON); assert!(abs_difference_y <= f32::EPSILON); assert!(f32::NAN.abs().is_nan());Run
pub fn signum(self) -> f32[src]
pub fn signum(self) -> f32Returns a number that represents the sign of self.
1.0if the number is positive,+0.0orINFINITY-1.0if the number is negative,-0.0orNEG_INFINITYNANif the number isNAN
Examples
use std::f32; let f = 3.5_f32; assert_eq!(f.signum(), 1.0); assert_eq!(f32::NEG_INFINITY.signum(), -1.0); assert!(f32::NAN.signum().is_nan());Run
#[must_use]
pub fn copysign(self, y: f32) -> f32[src]
#[must_use]
pub fn copysign(self, y: f32) -> f32Returns a number composed of the magnitude of self and the sign of
y.
Equal to self if the sign of self and y are the same, otherwise
equal to -self. If self is a NAN, then a NAN with the sign of
y is returned.
Examples
#![feature(copysign)] use std::f32; let f = 3.5_f32; assert_eq!(f.copysign(0.42), 3.5_f32); assert_eq!(f.copysign(-0.42), -3.5_f32); assert_eq!((-f).copysign(0.42), 3.5_f32); assert_eq!((-f).copysign(-0.42), -3.5_f32); assert!(f32::NAN.copysign(1.0).is_nan());Run
pub fn mul_add(self, a: f32, b: f32) -> f32[src]
pub fn mul_add(self, a: f32, b: f32) -> f32Fused multiply-add. Computes (self * a) + b with only one rounding
error, yielding a more accurate result than an unfused multiply-add.
Using mul_add can be more performant than an unfused multiply-add if
the target architecture has a dedicated fma CPU instruction.
Examples
use std::f32; let m = 10.0_f32; let x = 4.0_f32; let b = 60.0_f32; // 100.0 let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn div_euc(self, rhs: f32) -> f32[src]
pub fn div_euc(self, rhs: f32) -> f32Calculates Euclidean division, the matching method for mod_euc.
This computes the integer n such that
self = n * rhs + self.mod_euc(rhs).
In other words, the result is self / rhs rounded to the integer n
such that self >= n * rhs.
Examples
#![feature(euclidean_division)] let a: f32 = 7.0; let b = 4.0; assert_eq!(a.div_euc(b), 1.0); // 7.0 > 4.0 * 1.0 assert_eq!((-a).div_euc(b), -2.0); // -7.0 >= 4.0 * -2.0 assert_eq!(a.div_euc(-b), -1.0); // 7.0 >= -4.0 * -1.0 assert_eq!((-a).div_euc(-b), 2.0); // -7.0 >= -4.0 * 2.0Run
pub fn mod_euc(self, rhs: f32) -> f32[src]
pub fn mod_euc(self, rhs: f32) -> f32Calculates the Euclidean modulo (self mod rhs), which is never negative.
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_euc(rhs) * rhs + self.mod_euc(rhs)
approximatively.
Examples
#![feature(euclidean_division)] let a: f32 = 7.0; let b = 4.0; assert_eq!(a.mod_euc(b), 3.0); assert_eq!((-a).mod_euc(b), 1.0); assert_eq!(a.mod_euc(-b), 3.0); assert_eq!((-a).mod_euc(-b), 1.0); // limitation due to round-off error assert!((-std::f32::EPSILON).mod_euc(3.0) != 0.0);Run
pub fn powi(self, n: i32) -> f32[src]
pub fn powi(self, n: i32) -> f32Raises a number to an integer power.
Using this function is generally faster than using powf
Examples
use std::f32; let x = 2.0_f32; let abs_difference = (x.powi(2) - x*x).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn powf(self, n: f32) -> f32[src]
pub fn powf(self, n: f32) -> f32Raises a number to a floating point power.
Examples
use std::f32; let x = 2.0_f32; let abs_difference = (x.powf(2.0) - x*x).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn sqrt(self) -> f32[src]
pub fn sqrt(self) -> f32Takes the square root of a number.
Returns NaN if self is a negative number.
Examples
use std::f32; let positive = 4.0_f32; let negative = -4.0_f32; let abs_difference = (positive.sqrt() - 2.0).abs(); assert!(abs_difference <= f32::EPSILON); assert!(negative.sqrt().is_nan());Run
pub fn exp(self) -> f32[src]
pub fn exp(self) -> f32Returns e^(self), (the exponential function).
Examples
use std::f32; 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 <= f32::EPSILON);Run
pub fn exp2(self) -> f32[src]
pub fn exp2(self) -> f32Returns 2^(self).
Examples
use std::f32; let f = 2.0f32; // 2^2 - 4 == 0 let abs_difference = (f.exp2() - 4.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn ln(self) -> f32[src]
pub fn ln(self) -> f32Returns the natural logarithm of the number.
Examples
use std::f32; 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 <= f32::EPSILON);Run
pub fn log(self, base: f32) -> f32[src]
pub fn log(self, base: f32) -> f32Returns the logarithm of the number with respect to an arbitrary base.
The result may 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.
Examples
use std::f32; let five = 5.0f32; // log5(5) - 1 == 0 let abs_difference = (five.log(5.0) - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn log2(self) -> f32[src]
pub fn log2(self) -> f32Returns the base 2 logarithm of the number.
Examples
use std::f32; let two = 2.0f32; // log2(2) - 1 == 0 let abs_difference = (two.log2() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn log10(self) -> f32[src]
pub fn log10(self) -> f32Returns the base 10 logarithm of the number.
Examples
use std::f32; let ten = 10.0f32; // log10(10) - 1 == 0 let abs_difference = (ten.log10() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn abs_sub(self, other: f32) -> f32[src]
pub fn abs_sub(self, other: f32) -> f32: you probably meant (self - other).abs(): this operation is (self - other).max(0.0) (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
Examples
use std::f32; 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 <= f32::EPSILON); assert!(abs_difference_y <= f32::EPSILON);Run
pub fn cbrt(self) -> f32[src]
pub fn cbrt(self) -> f32Takes the cubic root of a number.
Examples
use std::f32; let x = 8.0f32; // x^(1/3) - 2 == 0 let abs_difference = (x.cbrt() - 2.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn hypot(self, other: f32) -> f32[src]
pub fn hypot(self, other: f32) -> f32Calculates the length of the hypotenuse of a right-angle triangle given
legs of length x and y.
Examples
use std::f32; 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 <= f32::EPSILON);Run
pub fn sin(self) -> f32[src]
pub fn sin(self) -> f32Computes the sine of a number (in radians).
Examples
use std::f32; let x = f32::consts::PI/2.0; let abs_difference = (x.sin() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn cos(self) -> f32[src]
pub fn cos(self) -> f32Computes the cosine of a number (in radians).
Examples
use std::f32; let x = 2.0*f32::consts::PI; let abs_difference = (x.cos() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn tan(self) -> f32[src]
pub fn tan(self) -> f32Computes the tangent of a number (in radians).
Examples
use std::f32; let x = f32::consts::PI / 4.0; let abs_difference = (x.tan() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn asin(self) -> f32[src]
pub fn asin(self) -> f32Computes 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].
Examples
use std::f32; let f = f32::consts::PI / 2.0; // asin(sin(pi/2)) let abs_difference = (f.sin().asin() - f32::consts::PI / 2.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn acos(self) -> f32[src]
pub fn acos(self) -> f32Computes 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].
Examples
use std::f32; let f = f32::consts::PI / 4.0; // acos(cos(pi/4)) let abs_difference = (f.cos().acos() - f32::consts::PI / 4.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn atan(self) -> f32[src]
pub fn atan(self) -> f32Computes the arctangent of a number. Return value is in radians in the range [-pi/2, pi/2];
Examples
use std::f32; let f = 1.0f32; // atan(tan(1)) let abs_difference = (f.tan().atan() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn atan2(self, other: f32) -> f32[src]
pub fn atan2(self, other: f32) -> f32Computes the four quadrant arctangent of self (y) and other (x) in radians.
x = 0,y = 0:0x >= 0:arctan(y/x)->[-pi/2, pi/2]y >= 0:arctan(y/x) + pi->(pi/2, pi]y < 0:arctan(y/x) - pi->(-pi, -pi/2)
Examples
use std::f32; let pi = f32::consts::PI; // 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) - (-pi/4.0)).abs(); let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs(); assert!(abs_difference_1 <= f32::EPSILON); assert!(abs_difference_2 <= f32::EPSILON);Run
pub fn sin_cos(self) -> (f32, f32)[src]
pub fn sin_cos(self) -> (f32, f32)Simultaneously computes the sine and cosine of the number, x. Returns
(sin(x), cos(x)).
Examples
use std::f32; let x = f32::consts::PI/4.0; let f = x.sin_cos(); let abs_difference_0 = (f.0 - x.sin()).abs(); let abs_difference_1 = (f.1 - x.cos()).abs(); assert!(abs_difference_0 <= f32::EPSILON); assert!(abs_difference_1 <= f32::EPSILON);Run
pub fn exp_m1(self) -> f32[src]
pub fn exp_m1(self) -> f32Returns e^(self) - 1 in a way that is accurate even if the
number is close to zero.
Examples
use std::f32; let x = 6.0f32; // e^(ln(6)) - 1 let abs_difference = (x.ln().exp_m1() - 5.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn ln_1p(self) -> f32[src]
pub fn ln_1p(self) -> f32Returns ln(1+n) (natural logarithm) more accurately than if
the operations were performed separately.
Examples
use std::f32; let x = f32::consts::E - 1.0; // ln(1 + (e - 1)) == ln(e) == 1 let abs_difference = (x.ln_1p() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn sinh(self) -> f32[src]
pub fn sinh(self) -> f32Hyperbolic sine function.
Examples
use std::f32; let e = f32::consts::E; let x = 1.0f32; let f = x.sinh(); // Solving sinh() at 1 gives `(e^2-1)/(2e)` let g = (e*e - 1.0)/(2.0*e); let abs_difference = (f - g).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn cosh(self) -> f32[src]
pub fn cosh(self) -> f32Hyperbolic cosine function.
Examples
use std::f32; let e = f32::consts::E; let x = 1.0f32; let f = x.cosh(); // Solving cosh() at 1 gives this result let g = (e*e + 1.0)/(2.0*e); let abs_difference = (f - g).abs(); // Same result assert!(abs_difference <= f32::EPSILON);Run
pub fn tanh(self) -> f32[src]
pub fn tanh(self) -> f32Hyperbolic tangent function.
Examples
use std::f32; let e = f32::consts::E; let x = 1.0f32; let f = x.tanh(); // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))` let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2)); let abs_difference = (f - g).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn asinh(self) -> f32[src]
pub fn asinh(self) -> f32Inverse hyperbolic sine function.
Examples
use std::f32; let x = 1.0f32; let f = x.sinh().asinh(); let abs_difference = (f - x).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn acosh(self) -> f32[src]
pub fn acosh(self) -> f32Inverse hyperbolic cosine function.
Examples
use std::f32; let x = 1.0f32; let f = x.cosh().acosh(); let abs_difference = (f - x).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn atanh(self) -> f32[src]
pub fn atanh(self) -> f32impl f32[src]
impl f32pub fn is_nan(self) -> bool[src]
pub fn is_nan(self) -> boolReturns true if this value is NaN and false otherwise.
use std::f32; let nan = f32::NAN; let f = 7.0_f32; assert!(nan.is_nan()); assert!(!f.is_nan());Run
pub fn is_infinite(self) -> bool[src]
pub fn is_infinite(self) -> boolReturns true if this value is positive infinity or negative infinity and
false otherwise.
use std::f32; let f = 7.0f32; let inf = f32::INFINITY; let neg_inf = f32::NEG_INFINITY; let nan = f32::NAN; assert!(!f.is_infinite()); assert!(!nan.is_infinite()); assert!(inf.is_infinite()); assert!(neg_inf.is_infinite());Run
pub fn is_finite(self) -> bool[src]
pub fn is_finite(self) -> boolReturns true if this number is neither infinite nor NaN.
use std::f32; let f = 7.0f32; let inf = f32::INFINITY; let neg_inf = f32::NEG_INFINITY; let nan = f32::NAN; assert!(f.is_finite()); assert!(!nan.is_finite()); assert!(!inf.is_finite()); assert!(!neg_inf.is_finite());Run
pub fn is_normal(self) -> bool[src]
pub fn is_normal(self) -> boolReturns true if the number is neither zero, infinite,
subnormal, or NaN.
use std::f32; let min = f32::MIN_POSITIVE; // 1.17549435e-38f32 let max = f32::MAX; let lower_than_min = 1.0e-40_f32; let zero = 0.0_f32; assert!(min.is_normal()); assert!(max.is_normal()); assert!(!zero.is_normal()); assert!(!f32::NAN.is_normal()); assert!(!f32::INFINITY.is_normal()); // Values between `0` and `min` are Subnormal. assert!(!lower_than_min.is_normal());Run
pub fn classify(self) -> FpCategory[src]
pub fn classify(self) -> FpCategoryReturns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.
use std::num::FpCategory; use std::f32; let num = 12.4_f32; let inf = f32::INFINITY; assert_eq!(num.classify(), FpCategory::Normal); assert_eq!(inf.classify(), FpCategory::Infinite);Run
pub fn is_sign_positive(self) -> bool[src]
pub fn is_sign_positive(self) -> boolReturns true if and only if self has a positive sign, including +0.0, NaNs with
positive sign bit and positive infinity.
let f = 7.0_f32; let g = -7.0_f32; assert!(f.is_sign_positive()); assert!(!g.is_sign_positive());Run
pub fn is_sign_negative(self) -> bool[src]
pub fn is_sign_negative(self) -> boolReturns true if and only if self has a negative sign, including -0.0, NaNs with
negative sign bit and negative infinity.
let f = 7.0f32; let g = -7.0f32; assert!(!f.is_sign_negative()); assert!(g.is_sign_negative());Run
pub fn recip(self) -> f32[src]
pub fn recip(self) -> f32Takes the reciprocal (inverse) of a number, 1/x.
use std::f32; let x = 2.0_f32; let abs_difference = (x.recip() - (1.0/x)).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn to_degrees(self) -> f321.7.0[src]
pub fn to_degrees(self) -> f32Converts radians to degrees.
use std::f32::{self, consts}; let angle = consts::PI; let abs_difference = (angle.to_degrees() - 180.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn to_radians(self) -> f321.7.0[src]
pub fn to_radians(self) -> f32Converts degrees to radians.
use std::f32::{self, consts}; let angle = 180.0f32; let abs_difference = (angle.to_radians() - consts::PI).abs(); assert!(abs_difference <= f32::EPSILON);Run
pub fn max(self, other: f32) -> f32[src]
pub fn max(self, other: f32) -> f32Returns the maximum of the two numbers.
let x = 1.0f32; let y = 2.0f32; assert_eq!(x.max(y), y);Run
If one of the arguments is NaN, then the other argument is returned.
pub fn min(self, other: f32) -> f32[src]
pub fn min(self, other: f32) -> f32Returns the minimum of the two numbers.
let x = 1.0f32; let y = 2.0f32; assert_eq!(x.min(y), x);Run
If one of the arguments is NaN, then the other argument is returned.
pub fn to_bits(self) -> u321.20.0[src]
pub fn to_bits(self) -> u32Raw transmutation to u32.
This is currently identical to transmute::<f32, u32>(self) on all platforms.
See from_bits for some discussion of the portability of this operation
(there are almost no issues).
Note that this function is distinct from as casting, which attempts to
preserve the numeric value, and not the bitwise value.
Examples
assert_ne!((1f32).to_bits(), 1f32 as u32); // to_bits() is not casting! assert_eq!((12.5f32).to_bits(), 0x41480000); Run
pub fn from_bits(v: u32) -> f321.20.0[src]
pub fn from_bits(v: u32) -> f32Raw transmutation from u32.
This is currently identical to transmute::<u32, f32>(v) on all platforms.
It turns out this is incredibly portable, for two reasons:
- Floats and Ints have the same endianness on all supported platforms.
- IEEE-754 very precisely specifies the bit layout of floats.
However there is one caveat: prior to the 2008 version of IEEE-754, how to interpret the NaN signaling bit wasn't actually specified. Most platforms (notably x86 and ARM) picked the interpretation that was ultimately standardized in 2008, but some didn't (notably MIPS). As a result, all signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa.
Rather than trying to preserve signaling-ness cross-platform, this implementation favors preserving the exact bits. This means that any payloads encoded in NaNs will be preserved even if the result of this method is sent over the network from an x86 machine to a MIPS one.
If the results of this method are only manipulated by the same architecture that produced them, then there is no portability concern.
If the input isn't NaN, then there is no portability concern.
If you don't care about signalingness (very likely), then there is no portability concern.
Note that this function is distinct from as casting, which attempts to
preserve the numeric value, and not the bitwise value.
Examples
use std::f32; let v = f32::from_bits(0x41480000); let difference = (v - 12.5).abs(); assert!(difference <= 1e-5);Run
Trait Implementations
impl Copy for f32[src]
impl Copy for f32impl<'a> MulAssign<&'a f32> for f321.22.0[src]
impl<'a> MulAssign<&'a f32> for f32fn mul_assign(&mut self, other: &'a f32)[src]
fn mul_assign(&mut self, other: &'a f32)impl MulAssign<f32> for f321.8.0[src]
impl MulAssign<f32> for f32fn mul_assign(&mut self, other: f32)[src]
fn mul_assign(&mut self, other: f32)impl LowerExp for f32[src]
impl LowerExp for f32impl Product<f32> for f321.12.0[src]
impl Product<f32> for f32impl<'a> Product<&'a f32> for f321.12.0[src]
impl<'a> Product<&'a f32> for f32impl<'a, 'b> Sub<&'a f32> for &'b f32[src]
impl<'a, 'b> Sub<&'a f32> for &'b f32type Output = <f32 as Sub<f32>>::Output
The resulting type after applying the - operator.
fn sub(self, other: &'a f32) -> <f32 as Sub<f32>>::Output[src]
fn sub(self, other: &'a f32) -> <f32 as Sub<f32>>::Outputimpl Sub<f32> for f32[src]
impl Sub<f32> for f32type Output = f32
The resulting type after applying the - operator.
fn sub(self, other: f32) -> f32[src]
fn sub(self, other: f32) -> f32impl<'a> Sub<f32> for &'a f32[src]
impl<'a> Sub<f32> for &'a f32type Output = <f32 as Sub<f32>>::Output
The resulting type after applying the - operator.
fn sub(self, other: f32) -> <f32 as Sub<f32>>::Output[src]
fn sub(self, other: f32) -> <f32 as Sub<f32>>::Outputimpl<'a> Sub<&'a f32> for f32[src]
impl<'a> Sub<&'a f32> for f32type Output = <f32 as Sub<f32>>::Output
The resulting type after applying the - operator.
fn sub(self, other: &'a f32) -> <f32 as Sub<f32>>::Output[src]
fn sub(self, other: &'a f32) -> <f32 as Sub<f32>>::Outputimpl Sum<f32> for f321.12.0[src]
impl Sum<f32> for f32impl<'a> Sum<&'a f32> for f321.12.0[src]
impl<'a> Sum<&'a f32> for f32impl FromStr for f32[src]
impl FromStr for f32type Err = ParseFloatError
The associated error which can be returned from parsing.
fn from_str(src: &str) -> Result<f32, ParseFloatError>[src]
fn from_str(src: &str) -> Result<f32, ParseFloatError>Converts a string in base 10 to a float. Accepts an optional decimal exponent.
This function accepts strings such as
- '3.14'
- '-3.14'
- '2.5E10', or equivalently, '2.5e10'
- '2.5E-10'
- '5.'
- '.5', or, equivalently, '0.5'
- 'inf', '-inf', 'NaN'
Leading and trailing whitespace represent an error.
Arguments
- src - A string
Return value
Err(ParseFloatError) if the string did not represent a valid
number. Otherwise, Ok(n) where n is the floating-point
number represented by src.
impl Neg for f32[src]
impl Neg for f32impl<'a> Neg for &'a f32[src]
impl<'a> Neg for &'a f32type Output = <f32 as Neg>::Output
The resulting type after applying the - operator.
fn neg(self) -> <f32 as Neg>::Output[src]
fn neg(self) -> <f32 as Neg>::Outputimpl SubAssign<f32> for f321.8.0[src]
impl SubAssign<f32> for f32fn sub_assign(&mut self, other: f32)[src]
fn sub_assign(&mut self, other: f32)impl<'a> SubAssign<&'a f32> for f321.22.0[src]
impl<'a> SubAssign<&'a f32> for f32fn sub_assign(&mut self, other: &'a f32)[src]
fn sub_assign(&mut self, other: &'a f32)impl Display for f32[src]
impl Display for f32impl RemAssign<f32> for f321.8.0[src]
impl RemAssign<f32> for f32fn rem_assign(&mut self, other: f32)[src]
fn rem_assign(&mut self, other: f32)impl<'a> RemAssign<&'a f32> for f321.22.0[src]
impl<'a> RemAssign<&'a f32> for f32fn rem_assign(&mut self, other: &'a f32)[src]
fn rem_assign(&mut self, other: &'a f32)impl From<i8> for f321.6.0[src]
impl From<i8> for f32Converts i8 to f32 losslessly.
impl From<i16> for f321.6.0[src]
impl From<i16> for f32Converts i16 to f32 losslessly.
impl From<u8> for f321.6.0[src]
impl From<u8> for f32Converts u8 to f32 losslessly.
impl From<u16> for f321.6.0[src]
impl From<u16> for f32Converts u16 to f32 losslessly.
impl<'a> Div<&'a f32> for f32[src]
impl<'a> Div<&'a f32> for f32type Output = <f32 as Div<f32>>::Output
The resulting type after applying the / operator.
fn div(self, other: &'a f32) -> <f32 as Div<f32>>::Output[src]
fn div(self, other: &'a f32) -> <f32 as Div<f32>>::Outputimpl Div<f32> for f32[src]
impl Div<f32> for f32type Output = f32
The resulting type after applying the / operator.
fn div(self, other: f32) -> f32[src]
fn div(self, other: f32) -> f32impl<'a> Div<f32> for &'a f32[src]
impl<'a> Div<f32> for &'a f32type Output = <f32 as Div<f32>>::Output
The resulting type after applying the / operator.
fn div(self, other: f32) -> <f32 as Div<f32>>::Output[src]
fn div(self, other: f32) -> <f32 as Div<f32>>::Outputimpl<'a, 'b> Div<&'a f32> for &'b f32[src]
impl<'a, 'b> Div<&'a f32> for &'b f32type Output = <f32 as Div<f32>>::Output
The resulting type after applying the / operator.
fn div(self, other: &'a f32) -> <f32 as Div<f32>>::Output[src]
fn div(self, other: &'a f32) -> <f32 as Div<f32>>::Outputimpl Clone for f32[src]
impl Clone for f32fn clone(&self) -> f32[src]
fn clone(&self) -> f32fn clone_from(&mut self, source: &Self)[src]
fn clone_from(&mut self, source: &Self)Performs copy-assignment from source. Read more
impl Debug for f32[src]
impl Debug for f32impl Default for f32[src]
impl Default for f32impl<'a> AddAssign<&'a f32> for f321.22.0[src]
impl<'a> AddAssign<&'a f32> for f32fn add_assign(&mut self, other: &'a f32)[src]
fn add_assign(&mut self, other: &'a f32)impl AddAssign<f32> for f321.8.0[src]
impl AddAssign<f32> for f32fn add_assign(&mut self, other: f32)[src]
fn add_assign(&mut self, other: f32)impl<'a> DivAssign<&'a f32> for f321.22.0[src]
impl<'a> DivAssign<&'a f32> for f32fn div_assign(&mut self, other: &'a f32)[src]
fn div_assign(&mut self, other: &'a f32)impl DivAssign<f32> for f321.8.0[src]
impl DivAssign<f32> for f32fn div_assign(&mut self, other: f32)[src]
fn div_assign(&mut self, other: f32)impl PartialEq<f32> for f32[src]
impl PartialEq<f32> for f32impl<'a> Add<f32> for &'a f32[src]
impl<'a> Add<f32> for &'a f32type Output = <f32 as Add<f32>>::Output
The resulting type after applying the + operator.
fn add(self, other: f32) -> <f32 as Add<f32>>::Output[src]
fn add(self, other: f32) -> <f32 as Add<f32>>::Outputimpl<'a> Add<&'a f32> for f32[src]
impl<'a> Add<&'a f32> for f32type Output = <f32 as Add<f32>>::Output
The resulting type after applying the + operator.
fn add(self, other: &'a f32) -> <f32 as Add<f32>>::Output[src]
fn add(self, other: &'a f32) -> <f32 as Add<f32>>::Outputimpl Add<f32> for f32[src]
impl Add<f32> for f32type Output = f32
The resulting type after applying the + operator.
fn add(self, other: f32) -> f32[src]
fn add(self, other: f32) -> f32impl<'a, 'b> Add<&'a f32> for &'b f32[src]
impl<'a, 'b> Add<&'a f32> for &'b f32type Output = <f32 as Add<f32>>::Output
The resulting type after applying the + operator.
fn add(self, other: &'a f32) -> <f32 as Add<f32>>::Output[src]
fn add(self, other: &'a f32) -> <f32 as Add<f32>>::Outputimpl PartialOrd<f32> for f32[src]
impl PartialOrd<f32> for f32fn partial_cmp(&self, other: &f32) -> Option<Ordering>[src]
fn partial_cmp(&self, other: &f32) -> Option<Ordering>fn lt(&self, other: &f32) -> bool[src]
fn lt(&self, other: &f32) -> boolfn le(&self, other: &f32) -> bool[src]
fn le(&self, other: &f32) -> boolfn ge(&self, other: &f32) -> bool[src]
fn ge(&self, other: &f32) -> boolfn gt(&self, other: &f32) -> bool[src]
fn gt(&self, other: &f32) -> boolimpl UpperExp for f32[src]
impl UpperExp for f32impl<'a> Mul<f32> for &'a f32[src]
impl<'a> Mul<f32> for &'a f32type Output = <f32 as Mul<f32>>::Output
The resulting type after applying the * operator.
fn mul(self, other: f32) -> <f32 as Mul<f32>>::Output[src]
fn mul(self, other: f32) -> <f32 as Mul<f32>>::Outputimpl<'a> Mul<&'a f32> for f32[src]
impl<'a> Mul<&'a f32> for f32type Output = <f32 as Mul<f32>>::Output
The resulting type after applying the * operator.
fn mul(self, other: &'a f32) -> <f32 as Mul<f32>>::Output[src]
fn mul(self, other: &'a f32) -> <f32 as Mul<f32>>::Outputimpl Mul<f32> for f32[src]
impl Mul<f32> for f32type Output = f32
The resulting type after applying the * operator.
fn mul(self, other: f32) -> f32[src]
fn mul(self, other: f32) -> f32impl<'a, 'b> Mul<&'a f32> for &'b f32[src]
impl<'a, 'b> Mul<&'a f32> for &'b f32type Output = <f32 as Mul<f32>>::Output
The resulting type after applying the * operator.
fn mul(self, other: &'a f32) -> <f32 as Mul<f32>>::Output[src]
fn mul(self, other: &'a f32) -> <f32 as Mul<f32>>::Outputimpl<'a, 'b> Rem<&'a f32> for &'b f32[src]
impl<'a, 'b> Rem<&'a f32> for &'b f32type Output = <f32 as Rem<f32>>::Output
The resulting type after applying the % operator.
fn rem(self, other: &'a f32) -> <f32 as Rem<f32>>::Output[src]
fn rem(self, other: &'a f32) -> <f32 as Rem<f32>>::Outputimpl Rem<f32> for f32[src]
impl Rem<f32> for f32type Output = f32
The resulting type after applying the % operator.
fn rem(self, other: f32) -> f32[src]
fn rem(self, other: f32) -> f32impl<'a> Rem<&'a f32> for f32[src]
impl<'a> Rem<&'a f32> for f32type Output = <f32 as Rem<f32>>::Output
The resulting type after applying the % operator.
fn rem(self, other: &'a f32) -> <f32 as Rem<f32>>::Output[src]
fn rem(self, other: &'a f32) -> <f32 as Rem<f32>>::Outputimpl<'a> Rem<f32> for &'a f32[src]
impl<'a> Rem<f32> for &'a f32type Output = <f32 as Rem<f32>>::Output
The resulting type after applying the % operator.
fn rem(self, other: f32) -> <f32 as Rem<f32>>::Output[src]
fn rem(self, other: f32) -> <f32 as Rem<f32>>::Outputimpl Float for f32[src]
impl Float for f32type Int = u32
🔬 This is a nightly-only experimental API. (compiler_builtins_lib)
Compiler builtins. Will never become stable.
A uint of the same with as the float
type SignedInt = i32
🔬 This is a nightly-only experimental API. (compiler_builtins_lib)
Compiler builtins. Will never become stable.
A int of the same with as the float
const ZERO: f32[src]
const ONE: f32[src]
const BITS: u32[src]
const SIGNIFICAND_BITS: u32[src]
const SIGN_MASK: <f32 as Float>::Int[src]
const SIGNIFICAND_MASK: <f32 as Float>::Int[src]
const IMPLICIT_BIT: <f32 as Float>::Int[src]
const EXPONENT_MASK: <f32 as Float>::Int[src]
fn repr(self) -> <f32 as Float>::Int[src]
fn repr(self) -> <f32 as Float>::Intfn signed_repr(self) -> <f32 as Float>::SignedInt[src]
fn signed_repr(self) -> <f32 as Float>::SignedIntfn from_repr(a: <f32 as Float>::Int) -> f32[src]
fn from_repr(a: <f32 as Float>::Int) -> f32fn from_parts(
sign: bool,
exponent: <f32 as Float>::Int,
significand: <f32 as Float>::Int
) -> f32[src]
fn from_parts(
sign: bool,
exponent: <f32 as Float>::Int,
significand: <f32 as Float>::Int
) -> f32fn normalize(significand: <f32 as Float>::Int) -> (i32, <f32 as Float>::Int)[src]
fn normalize(significand: <f32 as Float>::Int) -> (i32, <f32 as Float>::Int)const EXPONENT_BITS: u32[src]
🔬 This is a nightly-only experimental API. (compiler_builtins_lib)
Compiler builtins. Will never become stable.
The bitwidth of the exponent
const EXPONENT_MAX: u32[src]
🔬 This is a nightly-only experimental API. (compiler_builtins_lib)
Compiler builtins. Will never become stable.
The maximum value of the exponent
const EXPONENT_BIAS: u32[src]
🔬 This is a nightly-only experimental API. (compiler_builtins_lib)
Compiler builtins. Will never become stable.
The exponent bias value
Auto Trait Implementations
Blanket Implementations
impl<T> From for T[src]
impl<T> From for Timpl<T, U> TryFrom for T where
T: From<U>, [src]
impl<T, U> TryFrom for T where
T: From<U>, type Error = !
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>impl<T, U> TryInto for T where
U: TryFrom<T>, [src]
impl<T, U> TryInto for T where
U: TryFrom<T>, type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>impl<T, U> Into for T where
U: From<T>, [src]
impl<T, U> Into for T where
U: From<T>, impl<T> Borrow for T where
T: ?Sized, [src]
impl<T> Borrow for T where
T: ?Sized, impl<T> BorrowMut for T where
T: ?Sized, [src]
impl<T> BorrowMut for T where
T: ?Sized, ⓘImportant traits for &'_ mut Ifn borrow_mut(&mut self) -> &mut T[src]
fn borrow_mut(&mut self) -> &mut Timpl<T> Any for T where
T: 'static + ?Sized, [src]
impl<T> Any for T where
T: 'static + ?Sized, fn get_type_id(&self) -> TypeId[src]
fn get_type_id(&self) -> TypeIdimpl<T> ToOwned for T where
T: Clone, [src]
impl<T> ToOwned for T where
T: Clone, impl<T> ToString for T where
T: Display + ?Sized, [src]
impl<T> ToString for T where
T: Display + ?Sized,