Primitive Type f641.0.0 [−]
The 64-bit floating point type.
Methods
impl f64[src]
fn is_nan(self) -> bool
Returns true if this value is NaN and false otherwise.
use std::f64; let nan = f64::NAN; let f = 7.0_f64; 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::f64; let f = 7.0f64; let inf = f64::INFINITY; let neg_inf = f64::NEG_INFINITY; let nan = f64::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::f64; let f = 7.0f64; let inf: f64 = f64::INFINITY; let neg_inf: f64 = f64::NEG_INFINITY; let nan: f64 = f64::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::f64; let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64 let max = f64::MAX; let lower_than_min = 1.0e-308_f64; let zero = 0.0f64; assert!(min.is_normal()); assert!(max.is_normal()); assert!(!zero.is_normal()); assert!(!f64::NAN.is_normal()); assert!(!f64::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::f64; let num = 12.4_f64; let inf = f64::INFINITY; assert_eq!(num.classify(), FpCategory::Normal); assert_eq!(inf.classify(), FpCategory::Infinite);Run
fn floor(self) -> f64
Returns the largest integer less than or equal to a number.
let f = 3.99_f64; let g = 3.0_f64; assert_eq!(f.floor(), 3.0); assert_eq!(g.floor(), 3.0);Run
fn ceil(self) -> f64
Returns the smallest integer greater than or equal to a number.
let f = 3.01_f64; let g = 4.0_f64; assert_eq!(f.ceil(), 4.0); assert_eq!(g.ceil(), 4.0);Run
fn round(self) -> f64
Returns the nearest integer to a number. Round half-way cases away from
0.0.
let f = 3.3_f64; let g = -3.3_f64; assert_eq!(f.round(), 3.0); assert_eq!(g.round(), -3.0);Run
fn trunc(self) -> f64
Returns the integer part of a number.
let f = 3.3_f64; let g = -3.7_f64; assert_eq!(f.trunc(), 3.0); assert_eq!(g.trunc(), -3.0);Run
fn fract(self) -> f64
Returns the fractional part of a number.
let x = 3.5_f64; let y = -3.5_f64; let abs_difference_x = (x.fract() - 0.5).abs(); let abs_difference_y = (y.fract() - (-0.5)).abs(); assert!(abs_difference_x < 1e-10); assert!(abs_difference_y < 1e-10);Run
fn abs(self) -> f64
Computes the absolute value of self. Returns NAN if the
number is NAN.
use std::f64; let x = 3.5_f64; let y = -3.5_f64; let abs_difference_x = (x.abs() - x).abs(); let abs_difference_y = (y.abs() - (-y)).abs(); assert!(abs_difference_x < 1e-10); assert!(abs_difference_y < 1e-10); assert!(f64::NAN.abs().is_nan());Run
fn signum(self) -> f64
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::f64; let f = 3.5_f64; assert_eq!(f.signum(), 1.0); assert_eq!(f64::NEG_INFINITY.signum(), -1.0); assert!(f64::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::f64; let nan: f64 = f64::NAN; let f = 7.0_f64; let g = -7.0_f64; 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_positive(self) -> bool
: renamed to is_sign_positive
fn is_sign_negative(self) -> bool
Returns true if self's sign is negative, including -0.0
and NEG_INFINITY.
use std::f64; let nan = f64::NAN; let f = 7.0_f64; let g = -7.0_f64; 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 is_negative(self) -> bool
: renamed to is_sign_negative
fn mul_add(self, a: f64, b: f64) -> f64
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.
let m = 10.0_f64; let x = 4.0_f64; let b = 60.0_f64; // 100.0 let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs(); assert!(abs_difference < 1e-10);Run
fn recip(self) -> f64
Takes the reciprocal (inverse) of a number, 1/x.
let x = 2.0_f64; let abs_difference = (x.recip() - (1.0/x)).abs(); assert!(abs_difference < 1e-10);Run
fn powi(self, n: i32) -> f64
Raises a number to an integer power.
Using this function is generally faster than using powf
let x = 2.0_f64; let abs_difference = (x.powi(2) - x*x).abs(); assert!(abs_difference < 1e-10);Run
fn powf(self, n: f64) -> f64
Raises a number to a floating point power.
let x = 2.0_f64; let abs_difference = (x.powf(2.0) - x*x).abs(); assert!(abs_difference < 1e-10);Run
fn sqrt(self) -> f64
Takes the square root of a number.
Returns NaN if self is a negative number.
let positive = 4.0_f64; let negative = -4.0_f64; let abs_difference = (positive.sqrt() - 2.0).abs(); assert!(abs_difference < 1e-10); assert!(negative.sqrt().is_nan());Run
fn exp(self) -> f64
Returns e^(self), (the exponential function).
let one = 1.0_f64; // e^1 let e = one.exp(); // ln(e) - 1 == 0 let abs_difference = (e.ln() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn exp2(self) -> f64
Returns 2^(self).
let f = 2.0_f64; // 2^2 - 4 == 0 let abs_difference = (f.exp2() - 4.0).abs(); assert!(abs_difference < 1e-10);Run
fn ln(self) -> f64
Returns the natural logarithm of the number.
let one = 1.0_f64; // e^1 let e = one.exp(); // ln(e) - 1 == 0 let abs_difference = (e.ln() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn log(self, base: f64) -> f64
Returns the logarithm of the number with respect to an arbitrary base.
let ten = 10.0_f64; let two = 2.0_f64; // 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 < 1e-10); assert!(abs_difference_2 < 1e-10);Run
fn log2(self) -> f64
Returns the base 2 logarithm of the number.
let two = 2.0_f64; // log2(2) - 1 == 0 let abs_difference = (two.log2() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn log10(self) -> f64
Returns the base 10 logarithm of the number.
let ten = 10.0_f64; // log10(10) - 1 == 0 let abs_difference = (ten.log10() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn to_degrees(self) -> f64
Converts radians to degrees.
use std::f64::consts; let angle = consts::PI; let abs_difference = (angle.to_degrees() - 180.0).abs(); assert!(abs_difference < 1e-10);Run
fn to_radians(self) -> f64
Converts degrees to radians.
use std::f64::consts; let angle = 180.0_f64; let abs_difference = (angle.to_radians() - consts::PI).abs(); assert!(abs_difference < 1e-10);Run
fn max(self, other: f64) -> f64
Returns the maximum of the two numbers.
let x = 1.0_f64; let y = 2.0_f64; assert_eq!(x.max(y), y);Run
If one of the arguments is NaN, then the other argument is returned.
fn min(self, other: f64) -> f64
Returns the minimum of the two numbers.
let x = 1.0_f64; let y = 2.0_f64; 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: f64) -> f64
: you probably meant (self - other).abs(): this operation is (self - other).max(0.0) (also known as fdim in C). If you truly need the positive difference, consider using that expression or the C function fdim, 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
let x = 3.0_f64; let y = -3.0_f64; 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-10); assert!(abs_difference_y < 1e-10);Run
fn cbrt(self) -> f64
Takes the cubic root of a number.
let x = 8.0_f64; // x^(1/3) - 2 == 0 let abs_difference = (x.cbrt() - 2.0).abs(); assert!(abs_difference < 1e-10);Run
fn hypot(self, other: f64) -> f64
Calculates the length of the hypotenuse of a right-angle triangle given
legs of length x and y.
let x = 2.0_f64; let y = 3.0_f64; // sqrt(x^2 + y^2) let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs(); assert!(abs_difference < 1e-10);Run
fn sin(self) -> f64
Computes the sine of a number (in radians).
use std::f64; let x = f64::consts::PI/2.0; let abs_difference = (x.sin() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn cos(self) -> f64
Computes the cosine of a number (in radians).
use std::f64; let x = 2.0*f64::consts::PI; let abs_difference = (x.cos() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn tan(self) -> f64
Computes the tangent of a number (in radians).
use std::f64; let x = f64::consts::PI/4.0; let abs_difference = (x.tan() - 1.0).abs(); assert!(abs_difference < 1e-14);Run
fn asin(self) -> f64
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::f64; let f = f64::consts::PI / 2.0; // asin(sin(pi/2)) let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs(); assert!(abs_difference < 1e-10);Run
fn acos(self) -> f64
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::f64; let f = f64::consts::PI / 4.0; // acos(cos(pi/4)) let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs(); assert!(abs_difference < 1e-10);Run
fn atan(self) -> f64
Computes the arctangent of a number. Return value is in radians in the range [-pi/2, pi/2];
let f = 1.0_f64; // atan(tan(1)) let abs_difference = (f.tan().atan() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn atan2(self, other: f64) -> f64
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::f64; let pi = f64::consts::PI; // All angles from horizontal right (+x) // 45 deg counter-clockwise let x1 = 3.0_f64; let y1 = -3.0_f64; // 135 deg clockwise let x2 = -3.0_f64; let y2 = 3.0_f64; 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 < 1e-10); assert!(abs_difference_2 < 1e-10);Run
fn sin_cos(self) -> (f64, f64)
Simultaneously computes the sine and cosine of the number, x. Returns
(sin(x), cos(x)).
use std::f64; let x = f64::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 < 1e-10); assert!(abs_difference_1 < 1e-10);Run
fn exp_m1(self) -> f64
Returns e^(self) - 1 in a way that is accurate even if the
number is close to zero.
let x = 7.0_f64; // e^(ln(7)) - 1 let abs_difference = (x.ln().exp_m1() - 6.0).abs(); assert!(abs_difference < 1e-10);Run
fn ln_1p(self) -> f64
Returns ln(1+n) (natural logarithm) more accurately than if
the operations were performed separately.
use std::f64; let x = f64::consts::E - 1.0; // ln(1 + (e - 1)) == ln(e) == 1 let abs_difference = (x.ln_1p() - 1.0).abs(); assert!(abs_difference < 1e-10);Run
fn sinh(self) -> f64
Hyperbolic sine function.
use std::f64; let e = f64::consts::E; let x = 1.0_f64; 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 < 1e-10);Run
fn cosh(self) -> f64
Hyperbolic cosine function.
use std::f64; let e = f64::consts::E; let x = 1.0_f64; 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 < 1.0e-10);Run
fn tanh(self) -> f64
Hyperbolic tangent function.
use std::f64; let e = f64::consts::E; let x = 1.0_f64; 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 < 1.0e-10);Run
fn asinh(self) -> f64
Inverse hyperbolic sine function.
let x = 1.0_f64; let f = x.sinh().asinh(); let abs_difference = (f - x).abs(); assert!(abs_difference < 1.0e-10);Run
fn acosh(self) -> f64
Inverse hyperbolic cosine function.
let x = 1.0_f64; let f = x.cosh().acosh(); let abs_difference = (f - x).abs(); assert!(abs_difference < 1.0e-10);Run
fn atanh(self) -> f64
Inverse hyperbolic tangent function.
use std::f64; let e = f64::consts::E; let f = e.tanh().atanh(); let abs_difference = (f - e).abs(); assert!(abs_difference < 1.0e-10);Run
fn to_bits(self) -> u64
🔬 This is a nightly-only experimental API. (float_bits_conv #40470)
recently added
Raw transmutation to u64.
Converts the f64 into its raw memory representation,
similar to the transmute function.
Note that this function is distinct from casting.
Examples
#![feature(float_bits_conv)] assert!((1f64).to_bits() != 1f64 as u64); // to_bits() is not casting! assert_eq!((12.5f64).to_bits(), 0x4029000000000000); Run
fn from_bits(v: u64) -> Self
🔬 This is a nightly-only experimental API. (float_bits_conv #40470)
recently added
Raw transmutation from u64.
Converts the given u64 containing the float's raw memory
representation into the f64 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::f64; let v = f64::from_bits(0x4029000000000000); let difference = (v - 12.5).abs(); assert!(difference <= 1e-5); // Example for a signaling NaN value: let snan = 0x7FF0000000000001; assert_ne!(f64::from_bits(snan).to_bits(), snan);Run
Trait Implementations
impl Add<f64> for f64[src]
type Output = f64
The resulting type after applying the + operator
fn add(self, other: f64) -> f64
The method for the + operator
impl<'a> Add<f64> for &'a f64[src]
type Output = <f64 as Add<f64>>::Output
The resulting type after applying the + operator
fn add(self, other: f64) -> <f64 as Add<f64>>::Output
The method for the + operator
impl<'a> Add<&'a f64> for f64[src]
type Output = <f64 as Add<f64>>::Output
The resulting type after applying the + operator
fn add(self, other: &'a f64) -> <f64 as Add<f64>>::Output
The method for the + operator
impl<'a, 'b> Add<&'a f64> for &'b f64[src]
type Output = <f64 as Add<f64>>::Output
The resulting type after applying the + operator
fn add(self, other: &'a f64) -> <f64 as Add<f64>>::Output
The method for the + operator
impl AddAssign<f64> for f641.8.0[src]
fn add_assign(&mut self, other: f64)
The method for the += operator
impl DivAssign<f64> for f641.8.0[src]
fn div_assign(&mut self, other: f64)
The method for the /= operator
impl Div<f64> for f64[src]
type Output = f64
The resulting type after applying the / operator
fn div(self, other: f64) -> f64
The method for the / operator
impl<'a> Div<f64> for &'a f64[src]
type Output = <f64 as Div<f64>>::Output
The resulting type after applying the / operator
fn div(self, other: f64) -> <f64 as Div<f64>>::Output
The method for the / operator
impl<'a> Div<&'a f64> for f64[src]
type Output = <f64 as Div<f64>>::Output
The resulting type after applying the / operator
fn div(self, other: &'a f64) -> <f64 as Div<f64>>::Output
The method for the / operator
impl<'a, 'b> Div<&'a f64> for &'b f64[src]
type Output = <f64 as Div<f64>>::Output
The resulting type after applying the / operator
fn div(self, other: &'a f64) -> <f64 as Div<f64>>::Output
The method for the / operator
impl From<i8> for f641.5.0[src]
impl From<i16> for f641.5.0[src]
impl From<i32> for f641.5.0[src]
impl From<u8> for f641.5.0[src]
impl From<u16> for f641.5.0[src]
impl From<u32> for f641.5.0[src]
impl From<f32> for f641.5.0[src]
impl SubAssign<f64> for f641.8.0[src]
fn sub_assign(&mut self, other: f64)
The method for the -= operator
impl RemAssign<f64> for f641.8.0[src]
fn rem_assign(&mut self, other: f64)
The method for the %= operator
impl FromStr for f64[src]
type Err = ParseFloatError
The associated error which can be returned from parsing.
fn from_str(src: &str) -> Result<f64, 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 Display for f64[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter. Read more
impl Clone for f64[src]
fn clone(&self) -> f64
Returns a deep copy of the value.
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
impl Default for f64[src]
impl PartialEq<f64> for f64[src]
fn eq(&self, other: &f64) -> bool
This method tests for self and other values to be equal, and is used by ==. Read more
fn ne(&self, other: &f64) -> bool
This method tests for !=.
impl Debug for f64[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl Mul<f64> for f64[src]
type Output = f64
The resulting type after applying the * operator
fn mul(self, other: f64) -> f64
The method for the * operator
impl<'a> Mul<f64> for &'a f64[src]
type Output = <f64 as Mul<f64>>::Output
The resulting type after applying the * operator
fn mul(self, other: f64) -> <f64 as Mul<f64>>::Output
The method for the * operator
impl<'a> Mul<&'a f64> for f64[src]
type Output = <f64 as Mul<f64>>::Output
The resulting type after applying the * operator
fn mul(self, other: &'a f64) -> <f64 as Mul<f64>>::Output
The method for the * operator
impl<'a, 'b> Mul<&'a f64> for &'b f64[src]
type Output = <f64 as Mul<f64>>::Output
The resulting type after applying the * operator
fn mul(self, other: &'a f64) -> <f64 as Mul<f64>>::Output
The method for the * operator
impl Rem<f64> for f64[src]
type Output = f64
The resulting type after applying the % operator
fn rem(self, other: f64) -> f64
The method for the % operator
impl<'a> Rem<f64> for &'a f64[src]
type Output = <f64 as Rem<f64>>::Output
The resulting type after applying the % operator
fn rem(self, other: f64) -> <f64 as Rem<f64>>::Output
The method for the % operator
impl<'a> Rem<&'a f64> for f64[src]
type Output = <f64 as Rem<f64>>::Output
The resulting type after applying the % operator
fn rem(self, other: &'a f64) -> <f64 as Rem<f64>>::Output
The method for the % operator
impl<'a, 'b> Rem<&'a f64> for &'b f64[src]
type Output = <f64 as Rem<f64>>::Output
The resulting type after applying the % operator
fn rem(self, other: &'a f64) -> <f64 as Rem<f64>>::Output
The method for the % operator
impl PartialOrd<f64> for f64[src]
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
fn lt(&self, other: &f64) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
fn le(&self, other: &f64) -> 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: &f64) -> 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: &f64) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
impl UpperExp for f64[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl MulAssign<f64> for f641.8.0[src]
fn mul_assign(&mut self, other: f64)
The method for the *= operator
impl Sub<f64> for f64[src]
type Output = f64
The resulting type after applying the - operator
fn sub(self, other: f64) -> f64
The method for the - operator
impl<'a> Sub<f64> for &'a f64[src]
type Output = <f64 as Sub<f64>>::Output
The resulting type after applying the - operator
fn sub(self, other: f64) -> <f64 as Sub<f64>>::Output
The method for the - operator
impl<'a> Sub<&'a f64> for f64[src]
type Output = <f64 as Sub<f64>>::Output
The resulting type after applying the - operator
fn sub(self, other: &'a f64) -> <f64 as Sub<f64>>::Output
The method for the - operator
impl<'a, 'b> Sub<&'a f64> for &'b f64[src]
type Output = <f64 as Sub<f64>>::Output
The resulting type after applying the - operator
fn sub(self, other: &'a f64) -> <f64 as Sub<f64>>::Output
The method for the - operator
impl Neg for f64[src]
type Output = f64
The resulting type after applying the - operator
fn neg(self) -> f64
The method for the unary - operator
impl<'a> Neg for &'a f64[src]
type Output = <f64 as Neg>::Output
The resulting type after applying the - operator
fn neg(self) -> <f64 as Neg>::Output
The method for the unary - operator
impl LowerExp for f64[src]
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl Product<f64> for f641.12.0[src]
fn product<I>(iter: I) -> f64 where
I: Iterator<Item = f64>,
I: Iterator<Item = f64>,
Method which takes an iterator and generates Self from the elements by multiplying the items. Read more
impl<'a> Product<&'a f64> for f641.12.0[src]
fn product<I>(iter: I) -> f64 where
I: Iterator<Item = &'a f64>,
I: Iterator<Item = &'a f64>,
Method which takes an iterator and generates Self from the elements by multiplying the items. Read more
impl Sum<f64> for f641.12.0[src]
fn sum<I>(iter: I) -> f64 where
I: Iterator<Item = f64>,
I: Iterator<Item = f64>,
Method which takes an iterator and generates Self from the elements by "summing up" the items. Read more