Primitive Type f321.0.0 [−]
The 32-bit floating point type.
Methods
impl f32[src]
fn is_nan(self) -> bool
Returns 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
fn is_infinite(self) -> bool
Returns 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
fn is_finite(self) -> bool
Returns 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
fn is_normal(self) -> bool
Returns 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
fn classify(self) -> FpCategory
Returns 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
fn floor(self) -> f32
Returns the largest integer less than or equal to a number.
let f = 3.99_f32; let g = 3.0_f32; assert_eq!(f.floor(), 3.0); assert_eq!(g.floor(), 3.0);Run
fn ceil(self) -> f32
Returns the smallest integer greater than or equal to a number.
let f = 3.01_f32; let g = 4.0_f32; assert_eq!(f.ceil(), 4.0); assert_eq!(g.ceil(), 4.0);Run
fn round(self) -> f32
Returns the nearest integer to a number. Round half-way cases away from
0.0.
let f = 3.3_f32; let g = -3.3_f32; assert_eq!(f.round(), 3.0); assert_eq!(g.round(), -3.0);Run
fn trunc(self) -> f32
Returns the integer part of a number.
let f = 3.3_f32; let g = -3.7_f32; assert_eq!(f.trunc(), 3.0); assert_eq!(g.trunc(), -3.0);Run
fn fract(self) -> f32
Returns the fractional part of a number.
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
fn abs(self) -> f32
Computes the absolute value of self. Returns NAN if the
number is NAN.
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
fn signum(self) -> f32
Returns 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
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
fn is_sign_positive(self) -> bool
Returns true if self's sign bit is positive, including
+0.0 and INFINITY.
use std::f32; let nan = f32::NAN; let f = 7.0_f32; let g = -7.0_f32; assert!(f.is_sign_positive()); assert!(!g.is_sign_positive()); // Requires both tests to determine if is `NaN` assert!(!nan.is_sign_positive() && !nan.is_sign_negative());Run
fn is_sign_negative(self) -> bool
Returns true if self's sign is negative, including -0.0
and NEG_INFINITY.
use std::f32; let nan = f32::NAN; let f = 7.0f32; let g = -7.0f32; assert!(!f.is_sign_negative()); assert!(g.is_sign_negative()); // Requires both tests to determine if is `NaN`. assert!(!nan.is_sign_positive() && !nan.is_sign_negative());Run
fn mul_add(self, a: f32, b: f32) -> f32
Fused multiply-add. Computes (self * a) + b with only one rounding
error. This produces a more accurate result with better performance than
a separate multiplication operation followed by an add.
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
fn recip(self) -> f32
Takes 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
fn powi(self, n: i32) -> f32
Raises a number to an integer power.
Using this function is generally faster than using powf
use std::f32; let x = 2.0_f32; let abs_difference = (x.powi(2) - x*x).abs(); assert!(abs_difference <= f32::EPSILON);Run
fn powf(self, n: f32) -> f32
Raises a number to a floating point power.
use std::f32; let x = 2.0_f32; let abs_difference = (x.powf(2.0) - x*x).abs(); assert!(abs_difference <= f32::EPSILON);Run
fn sqrt(self) -> f32
Takes the square root of a number.
Returns NaN if self is a negative number.
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
fn exp(self) -> f32
Returns e^(self), (the exponential function).
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
fn exp2(self) -> f32
Returns 2^(self).
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
fn ln(self) -> f32
Returns the natural logarithm of the number.
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
fn log(self, base: f32) -> f32
Returns the logarithm of the number with respect to an arbitrary base.
use std::f32; let ten = 10.0f32; let two = 2.0f32; // log10(10) - 1 == 0 let abs_difference_10 = (ten.log(10.0) - 1.0).abs(); // log2(2) - 1 == 0 let abs_difference_2 = (two.log(2.0) - 1.0).abs(); assert!(abs_difference_10 <= f32::EPSILON); assert!(abs_difference_2 <= f32::EPSILON);Run
fn log2(self) -> f32
Returns the base 2 logarithm of the number.
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
fn log10(self) -> f32
Returns the base 10 logarithm of the number.
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
fn to_degrees(self) -> f321.7.0
Converts 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
fn to_radians(self) -> f321.7.0
Converts 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
fn max(self, other: f32) -> f32
Returns 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.
fn min(self, other: f32) -> f32
Returns 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.
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
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
fn cbrt(self) -> f32
Takes the cubic root of a number.
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
fn hypot(self, other: f32) -> f32
Calculates the length of the hypotenuse of a right-angle triangle given
legs of length x and y.
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
fn sin(self) -> f32
Computes the sine of a number (in radians).
use std::f32; let x = f32::consts::PI/2.0; let abs_difference = (x.sin() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
fn cos(self) -> f32
Computes the cosine of a number (in radians).
use std::f32; let x = 2.0*f32::consts::PI; let abs_difference = (x.cos() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
fn tan(self) -> f32
Computes the tangent of a number (in radians).
use std::f32; let x = f32::consts::PI / 4.0; let abs_difference = (x.tan() - 1.0).abs(); assert!(abs_difference <= f32::EPSILON);Run
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].
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
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].
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
fn atan(self) -> f32
Computes the arctangent of a number. Return value is in radians in the range [-pi/2, pi/2];
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
fn atan2(self, other: f32) -> f32
Computes the four quadrant arctangent of self (y) and other (x).
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)
use std::f32; let pi = f32::consts::PI; // All angles from horizontal right (+x) // 45 deg counter-clockwise let x1 = 3.0f32; let y1 = -3.0f32; // 135 deg 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
fn sin_cos(self) -> (f32, f32)
Simultaneously computes the sine and cosine of the number, x. Returns
(sin(x), cos(x)).
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
fn exp_m1(self) -> f32
Returns e^(self) - 1 in a way that is accurate even if the
number is close to zero.
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
fn ln_1p(self) -> f32
Returns ln(1+n) (natural logarithm) more accurately than if
the operations were performed separately.
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
fn sinh(self) -> f32
Hyperbolic sine function.
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
fn cosh(self) -> f32
Hyperbolic cosine function.
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
fn tanh(self) -> f32
Hyperbolic tangent function.
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
fn asinh(self) -> f32
Inverse hyperbolic sine function.
use std::f32; let x = 1.0f32; let f = x.sinh().asinh(); let abs_difference = (f - x).abs(); assert!(abs_difference <= f32::EPSILON);Run
fn acosh(self) -> f32
Inverse hyperbolic cosine function.
use std::f32; let x = 1.0f32; let f = x.cosh().acosh(); let abs_difference = (f - x).abs(); assert!(abs_difference <= f32::EPSILON);Run
fn atanh(self) -> f32
Inverse hyperbolic tangent function.
use std::f32; let e = f32::consts::E; let f = e.tanh().atanh(); let abs_difference = (f - e).abs(); assert!(abs_difference <= 1e-5);Run
fn to_bits(self) -> u32
🔬 This is a nightly-only experimental API. (float_bits_conv #40470)
recently added
Raw transmutation to u32.
Converts the f32 into its raw memory representation,
similar to the transmute function.
Note that this function is distinct from casting.
Examples
#![feature(float_bits_conv)] assert_ne!((1f32).to_bits(), 1f32 as u32); // to_bits() is not casting! assert_eq!((12.5f32).to_bits(), 0x41480000); Run
fn from_bits(v: u32) -> Self
🔬 This is a nightly-only experimental API. (float_bits_conv #40470)
recently added
Raw transmutation from u32.
Converts the given u32 containing the float's raw memory
representation into the f32 type, similar to the
transmute function.
There is only one difference to a bare transmute:
Due to the implications onto Rust's safety promises being
uncertain, if the representation of a signaling NaN "sNaN" float
is passed to the function, the implementation is allowed to
return a quiet NaN instead.
Note that this function is distinct from casting.
Examples
#![feature(float_bits_conv)] use std::f32; let v = f32::from_bits(0x41480000); let difference = (v - 12.5).abs(); assert!(difference <= 1e-5); // Example for a signaling NaN value: let snan = 0x7F800001; assert_ne!(f32::from_bits(snan).to_bits(), snan);Run
Trait Implementations
impl<'a> Sub<f32> for &'a f32[src]
type Output = <f32 as Sub<f32>>::Output
The resulting type after applying the - operator
fn sub(self, other: f32) -> <f32 as Sub<f32>>::Output
The method for the - operator
impl<'a, 'b> Sub<&'a f32> for &'b f32[src]
type Output = <f32 as Sub<f32>>::Output
The resulting type after applying the - operator
fn sub(self, other: &'a f32) -> <f32 as Sub<f32>>::Output
The method for the - operator
impl<'a> Sub<&'a f32> for f32[src]
type Output = <f32 as Sub<f32>>::Output
The resulting type after applying the - operator
fn sub(self, other: &'a f32) -> <f32 as Sub<f32>>::Output
The method for the - operator
impl Sub<f32> for f32[src]
type Output = f32
The resulting type after applying the - operator
fn sub(self, other: f32) -> f32
The method for the - operator
impl<'a> Neg for &'a f32[src]
type Output = <f32 as Neg>::Output
The resulting type after applying the - operator
fn neg(self) -> <f32 as Neg>::Output
The method for the unary - operator
impl Neg for f32[src]
type Output = f32
The resulting type after applying the - operator
fn neg(self) -> f32
The method for the unary - operator
impl Add<f32> for f32[src]
type Output = f32
The resulting type after applying the + operator
fn add(self, other: f32) -> f32
The method for the + operator
impl<'a> Add<f32> for &'a f32[src]
type Output = <f32 as Add<f32>>::Output
The resulting type after applying the + operator
fn add(self, other: f32) -> <f32 as Add<f32>>::Output
The method for the + operator
impl<'a, 'b> Add<&'a f32> for &'b f32[src]
type Output = <f32 as Add<f32>>::Output
The resulting type after applying the + operator
fn add(self, other: &'a f32) -> <f32 as Add<f32>>::Output
The method for the + operator
impl<'a> Add<&'a f32> for f32[src]
type Output = <f32 as Add<f32>>::Output
The resulting type after applying the + operator
fn add(self, other: &'a f32) -> <f32 as Add<f32>>::Output
The method for the + operator
impl AddAssign<f32> for f321.8.0[src]
fn add_assign(&mut self, other: f32)
The method for the += operator
impl DivAssign<f32> for f321.8.0[src]
fn div_assign(&mut self, other: f32)
The method for the /= operator
impl FromStr for f32[src]
type Err = ParseFloatError
The associated error which can be returned from parsing.
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'
- '.' (understood as 0)
- '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 Product<f32> for f321.12.0[src]
fn product<I>(iter: I) -> f32 where
I: Iterator<Item = f32>,
I: Iterator<Item = f32>,
Method which takes an iterator and generates Self from the elements by multiplying the items. Read more
impl<'a> Product<&'a f32> for f321.12.0[src]
fn product<I>(iter: I) -> f32 where
I: Iterator<Item = &'a f32>,
I: Iterator<Item = &'a f32>,
Method which takes an iterator and generates Self from the elements by multiplying the items. Read more
impl Sum<f32> for f321.12.0[src]
fn sum<I>(iter: I) -> f32 where
I: Iterator<Item = f32>,
I: Iterator<Item = f32>,
Method which takes an iterator and generates Self from the elements by "summing up" the items. Read more
impl<'a> Sum<&'a f32> for f321.12.0[src]
fn sum<I>(iter: I) -> f32 where
I: Iterator<Item = &'a f32>,
I: Iterator<Item = &'a f32>,
Method which takes an iterator and generates Self from the elements by "summing up" the items. Read more
impl From<u8> for f321.6.0[src]
impl From<u16> for f321.6.0[src]
impl From<i8> for f321.6.0[src]
impl From<i16> for f321.6.0[src]
impl Div<f32> for f32[src]
type Output = f32
The resulting type after applying the / operator
fn div(self, other: f32) -> f32
The method for the / operator
impl<'a, 'b> Div<&'a f32> for &'b f32[src]
type Output = <f32 as Div<f32>>::Output
The resulting type after applying the / operator
fn div(self, other: &'a f32) -> <f32 as Div<f32>>::Output
The method for the / operator
impl<'a> Div<&'a f32> for f32[src]
type Output = <f32 as Div<f32>>::Output
The resulting type after applying the / operator
fn div(self, other: &'a f32) -> <f32 as Div<f32>>::Output
The method for the / operator
impl<'a> Div<f32> for &'a f32[src]
type Output = <f32 as Div<f32>>::Output
The resulting type after applying the / operator
fn div(self, other: f32) -> <f32 as Div<f32>>::Output
The method for the / operator
impl Clone for f32[src]
fn clone(&self) -> f32
Returns a deep copy of the value.
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
impl Default for f32[src]
impl Display for f32[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter. Read more
impl SubAssign<f32> for f321.8.0[src]
fn sub_assign(&mut self, other: f32)
The method for the -= operator
impl PartialEq<f32> for f32[src]
fn eq(&self, other: &f32) -> bool
This method tests for self and other values to be equal, and is used by ==. Read more
fn ne(&self, other: &f32) -> bool
This method tests for !=.
impl RemAssign<f32> for f321.8.0[src]
fn rem_assign(&mut self, other: f32)
The method for the %= operator
impl Debug for f32[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl PartialOrd<f32> for f32[src]
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
fn lt(&self, other: &f32) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
fn le(&self, other: &f32) -> bool
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn ge(&self, other: &f32) -> bool
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn gt(&self, other: &f32) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
impl<'a> Mul<f32> for &'a f32[src]
type Output = <f32 as Mul<f32>>::Output
The resulting type after applying the * operator
fn mul(self, other: f32) -> <f32 as Mul<f32>>::Output
The method for the * operator
impl<'a> Mul<&'a f32> for f32[src]
type Output = <f32 as Mul<f32>>::Output
The resulting type after applying the * operator
fn mul(self, other: &'a f32) -> <f32 as Mul<f32>>::Output
The method for the * operator
impl Mul<f32> for f32[src]
type Output = f32
The resulting type after applying the * operator
fn mul(self, other: f32) -> f32
The method for the * operator
impl<'a, 'b> Mul<&'a f32> for &'b f32[src]
type Output = <f32 as Mul<f32>>::Output
The resulting type after applying the * operator
fn mul(self, other: &'a f32) -> <f32 as Mul<f32>>::Output
The method for the * operator
impl<'a> Rem<&'a f32> for f32[src]
type Output = <f32 as Rem<f32>>::Output
The resulting type after applying the % operator
fn rem(self, other: &'a f32) -> <f32 as Rem<f32>>::Output
The method for the % operator
impl Rem<f32> for f32[src]
type Output = f32
The resulting type after applying the % operator
fn rem(self, other: f32) -> f32
The method for the % operator
impl<'a, 'b> Rem<&'a f32> for &'b f32[src]
type Output = <f32 as Rem<f32>>::Output
The resulting type after applying the % operator
fn rem(self, other: &'a f32) -> <f32 as Rem<f32>>::Output
The method for the % operator
impl<'a> Rem<f32> for &'a f32[src]
type Output = <f32 as Rem<f32>>::Output
The resulting type after applying the % operator
fn rem(self, other: f32) -> <f32 as Rem<f32>>::Output
The method for the % operator
impl UpperExp for f32[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl LowerExp for f32[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl MulAssign<f32> for f321.8.0[src]
fn mul_assign(&mut self, other: f32)
The method for the *= operator