Struct rug::Float [−][src]
#[repr(transparent)]pub struct Float { /* fields omitted */ }
A multi-precision floating-point number with arbitrarily large precision and correct rounding
The precision has to be set during construction. The rounding method of the required operations can be specified, and the direction of the rounding is returned.
Examples
use rug::float::Round; use rug::ops::DivAssignRound; use rug::Float; use std::cmp::Ordering; // A precision of 32 significant bits is specified here. // (The primitive `f32` has a precision of 24 and // `f64` has a precision of 53.) let mut two_thirds_down = Float::with_val(32, 2.0); let dir = two_thirds_down.div_assign_round(3.0, Round::Down); // since we rounded down, direction is Ordering::Less assert_eq!(dir, Ordering::Less); let mut two_thirds_up = Float::with_val(32, 2.0); let dir = two_thirds_up.div_assign_round(3.0, Round::Up); // since we rounded up, direction is Ordering::Greater assert_eq!(dir, Ordering::Greater); let diff_expected = 2.0_f64.powi(-32); let diff = two_thirds_up - two_thirds_down; assert_eq!(diff, diff_expected);
Operations on two borrowed Float
numbers result in an
incomplete-computation value that has to be assigned to a new
Float
value.
use rug::Float; let a = Float::with_val(53, 10.5); let b = Float::with_val(53, -1.25); let a_b_ref = &a + &b; let a_b = Float::with_val(53, a_b_ref); assert_eq!(a_b, 9.25);
As a special case, when an incomplete-computation value is
obtained from multiplying two Float
references, it can be added to
or subtracted from another Float
(or reference). This will result in
a fused multiply-accumulate operation, with only one rounding
operation taking place.
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 24 in binary is 11000. let a = Float::with_val(4, 24); // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 + 1.5 * -13 = 4.5 let add = Float::with_val(4, &a + &mul1 * &mul2); assert_eq!(add, 4.5); // 24 - 1.5 * -13 = 43.5, rounded to 44 using four bits of precision. let sub = a - &mul1 * &mul2; assert_eq!(sub, 44); // With separate addition and multiplication: let a = Float::with_val(4, 24); // No borrows, so multiplication is computed immediately. // 1.5 * -13 = -19.5 (binary -10011.1), rounded to -20. let separate_add = a + mul1 * mul2; assert_eq!(separate_add, 4);
The incomplete-computation value obtained from multiplying two
Float
references can also be added to or subtracted from another
such incomplete-computation value, so that two muliplications
and an addition are fused with only one rounding operation taking
place.
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 + 12 * 2 = 60 let add = Float::with_val(53, &a * &b + &c * &d); assert_eq!(add, 60); // 24 * 1.5 - 12 * 2 = 12 let sub = Float::with_val(53, &a * &b - &c * &d); assert_eq!(sub, 12);
The Float
type supports various functions. Most methods have four
versions:
- The first method consumes the operand and rounds the returned
Float
to the nearest representable value. - The second method has a “
_mut
” suffix, mutates the operand and rounds it the nearest representable value. - The third method has a “
_round
” suffix, mutates the operand, applies the specified rounding method, and returns the rounding direction:Ordering::Less
if the stored value is less than the exact result,Ordering::Equal
if the stored value is equal to the exact result,Ordering::Greater
if the stored value is greater than the exact result.
- The fourth method has a “
_ref
” suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to aFloat
; the rounding method is selected during the assignment.
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let expected = 0.9490_f64; // 1. consume the operand, round to nearest let a = Float::with_val(53, 1.25); let sin_a = a.sin(); assert!((sin_a - expected).abs() < 0.0001); // 2. mutate the operand, round to nearest let mut b = Float::with_val(53, 1.25); b.sin_mut(); assert!((b - expected).abs() < 0.0001); // 3. mutate the operand, apply specified rounding let mut c = Float::with_val(4, 1.25); // using 4 significant bits, 0.9490 is rounded down to 0.9375 let dir = c.sin_round(Round::Nearest); assert_eq!(c, 0.9375); assert_eq!(dir, Ordering::Less); // 4. borrow the operand let d = Float::with_val(53, 1.25); let r = d.sin_ref(); let sin_d = Float::with_val(53, r); assert!((sin_d - expected).abs() < 0.0001); // d was not consumed assert_eq!(d, 1.25);
The following example is a translation of the MPFR sample found on the MPFR website. The program computes a lower bound on 1 + 1/1! + 1/2! + … + 1/100! using 200-bit precision. The program writes:
Sum is 2.7182818284590452353602874713526624977572470936999595749669131
extern crate rug; use rug::float::{Round}; use rug::Float; use rug::ops::{AddAssignRound, AssignRound, MulAssignRound}; fn main() { let mut t = Float::with_val(200, 1.0); let mut s = Float::with_val(200, 1.0); let mut u = Float::new(200); for i in 1..101_u32 { // multiply t by i in place, round towards plus infinity t.mul_assign_round(i, Round::Up); // set u to 1/t, round towards minus infinity u.assign_round(t.recip_ref(), Round::Down); // increase s by u in place, round towards minus infinity s.add_assign_round(&u, Round::Down); } // `None` means the number of printed digits depends on the precision let sr = s.to_string_radix_round(10, None, Round::Down); println!("Sum is {}", sr); }
Methods
impl Float
[src]
impl Float
pub fn new(prec: u32) -> Self
[src]
pub fn new(prec: u32) -> Self
Create a new Float
with the specified precision and with
value 0.
Panics
Panics if prec
is out of the allowed range.
Examples
use rug::Float; let f = Float::new(53); assert_eq!(f.prec(), 53); assert_eq!(f, 0);
pub fn with_val<T>(prec: u32, val: T) -> Self where
Float: Assign<T>,
[src]
pub fn with_val<T>(prec: u32, val: T) -> Self where
Float: Assign<T>,
Create a new Float
with the specified precision and with
the given value, rounding to the nearest.
Panics
Panics if prec
is out of the allowed range.
Examples
use rug::Float; let f = Float::with_val(53, 1.3); assert_eq!(f.prec(), 53); assert_eq!(f, 1.3);
pub fn with_val_round<T>(prec: u32, val: T, round: Round) -> (Self, Ordering) where
Self: AssignRound<T, Round = Round, Ordering = Ordering>,
[src]
pub fn with_val_round<T>(prec: u32, val: T, round: Round) -> (Self, Ordering) where
Self: AssignRound<T, Round = Round, Ordering = Ordering>,
Create a new Float
with the specified precision and with
the given value, applying the specified rounding method.
Panics
Panics if prec
is out of the allowed range.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let (f1, dir) = Float::with_val_round(4, 3.3, Round::Nearest); // 3.3 with precision 4 is rounded down to 3.25 assert_eq!(f1.prec(), 4); assert_eq!(f1, 3.25); assert_eq!(dir, Ordering::Less); let (f2, dir) = Float::with_val_round(4, 3.3, Round::Up); // 3.3 rounded up to 3.5 assert_eq!(f2.prec(), 4); assert_eq!(f2, 3.5); assert_eq!(dir, Ordering::Greater);
pub fn prec(&self) -> u32
[src]
pub fn prec(&self) -> u32
pub fn set_prec(&mut self, prec: u32)
[src]
pub fn set_prec(&mut self, prec: u32)
Sets the precision, rounding to the nearest.
Panics
Panics if prec
is out of the allowed range.
Examples
use rug::Float; // 16.25 has seven significant bits (binary 10000.01) let mut f = Float::with_val(53, 16.25); f.set_prec(5); assert_eq!(f, 16); assert_eq!(f.prec(), 5);
pub fn set_prec_round(&mut self, prec: u32, round: Round) -> Ordering
[src]
pub fn set_prec_round(&mut self, prec: u32, round: Round) -> Ordering
Sets the precision, applying the specified rounding method.
Panics
Panics if prec
is out of the allowed range.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; // 16.25 has seven significant bits (binary 10000.01) let mut f = Float::with_val(53, 16.25); let dir = f.set_prec_round(5, Round::Up); assert_eq!(f, 17); assert_eq!(dir, Ordering::Greater); assert_eq!(f.prec(), 5);
pub unsafe fn from_raw(raw: mpfr_t) -> Self
[src]
pub unsafe fn from_raw(raw: mpfr_t) -> Self
Creates a Float
from an initialized
MPFR floating-point number.
Safety
- The value must be initialized.
- The
gmp_mpfr_sys::mpfr::mpfr_t
type can be considered as a kind of pointer, so there can be multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::mpfr; use rug::Float; use std::mem; fn main() { let f = unsafe { let mut m = mem::uninitialized(); mpfr::init2(&mut m, 53); mpfr::set_d(&mut m, -14.5, mpfr::rnd_t::RNDN); // m is initialized and unique Float::from_raw(m) }; assert_eq!(f, -14.5); // since f is a Float now, deallocation is automatic }
pub fn into_raw(self) -> mpfr_t
[src]
pub fn into_raw(self) -> mpfr_t
Converts a Float
into an
MPFR floating-point number.
The returned object should be freed to avoid memory leaks.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::mpfr; use rug::Float; fn main() { let f = Float::with_val(53, -14.5); let mut m = f.into_raw(); unsafe { let d = mpfr::get_d(&m, mpfr::rnd_t::RNDN); assert_eq!(d, -14.5); // free object to prevent memory leak mpfr::clear(&mut m); } }
pub fn as_raw(&self) -> *const mpfr_t
[src]
pub fn as_raw(&self) -> *const mpfr_t
Returns a pointer to the inner MPFR floating-point number.
The returned pointer will be valid for as long as self
is
valid.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::mpfr; use rug::Float; fn main() { let f = Float::with_val(53, -14.5); let m_ptr = f.as_raw(); unsafe { let d = mpfr::get_d(m_ptr, mpfr::rnd_t::RNDN); assert_eq!(d, -14.5); } // f is still valid assert_eq!(f, -14.5); }
pub fn as_raw_mut(&mut self) -> *mut mpfr_t
[src]
pub fn as_raw_mut(&mut self) -> *mut mpfr_t
Returns an unsafe mutable pointer to the inner MPFR floating-point number.
The returned pointer will be valid for as long as self
is
valid.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::mpfr; use rug::Float; fn main() { let mut f = Float::with_val(53, -14.5); let m_ptr = f.as_raw_mut(); unsafe { mpfr::add_ui(m_ptr, m_ptr, 10, mpfr::rnd_t::RNDN); } assert_eq!(f, -4.5); }
pub fn parse<S>(src: S) -> Result<ParseIncomplete, ParseFloatError> where
S: AsRef<[u8]>,
[src]
pub fn parse<S>(src: S) -> Result<ParseIncomplete, ParseFloatError> where
S: AsRef<[u8]>,
Parses a decimal string slice (&str
) or byte slice
(&[u8]
) into a Float
.
AssignRound<Src> for Float
is implemented
with the unwrapped returned
incomplete-computation value as Src
.
The string can start with an optional minus or plus sign and
must then have one or more significant digits with an optional
decimal point. This can optionally be followed by an exponent;
the exponent can start with a separator “e
”, “E
” or “@
”,
and is followed by an optional minus or plus sign and by one
or more decimal digits.
Alternatively, the string can indicate the special values
infinity or NaN. Infinity can be represented as "inf"
,
"infinity"
, "@inf@"
or "@infinity@"
,and NaN can be
represented as "nan"
or "@nan@"
. All of these special
representations are case insensitive. The NaN representation
may also include a possibly-empty string of ASCII letters,
digits and underscores enclosed in brackets, for example
"nan(char_sequence_1)"
.
ASCII whitespace is ignored everywhere in the string except in
the substrings specified above for special values; for example
" @inf@ "
is accepted but "@ inf @"
is not. Underscores
are ignored anywhere in digit strings except before the first
digit and between the exponent separator and the first digit
of the exponent.
Examples
use rug::Float; let valid = Float::parse("12.25e-4"); let f = Float::with_val(53, valid.unwrap()); assert_eq!(f, 12.25e-4); let invalid = Float::parse(".e-4"); assert!(invalid.is_err());
pub fn parse_radix<S>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseFloatError> where
S: AsRef<[u8]>,
[src]
pub fn parse_radix<S>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseFloatError> where
S: AsRef<[u8]>,
Parses a string slice (&str
) or byte slice
(&[u8]
) into a Float
.
AssignRound<Src> for Float
is implemented
with the unwrapped returned
incomplete-computation value as Src
.
The string can start with an optional minus or plus sign and
must then have one or more significant digits with an optional
point. This can optionally be followed by an exponent; the
exponent can start with a separator “e
” or “E
” if the
radix ≤ 10, or “@
” for any radix, and is followed by an
optional minus or plus sign and by one or more decimal digits.
Alternatively, the string can indicate the special values
infinity or NaN. If the radix ≤ 10, infinity can be
represented as "inf"
or "infinity"
, and NaN can be
represented as "nan"
. For any radix, infinity can also be
represented as "@inf@"
or "@infinity@"
, and NaN can be
represented as "@nan@"
. All of these special representations
are case insensitive. The NaN representation may also include
a possibly-empty string of ASCII letters, digits and
underscores enclosed in brackets, for example
"nan(char_sequence_1)"
.
ASCII whitespace is ignored everywhere in the string except in
the substrings specified above for special values; for example
" @inf@ "
is accepted but "@ inf @"
is not. Underscores
are ignored anywhere in digit strings except before the first
digit and between the exponent separator and the first digit
of the exponent.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::Float; let valid1 = Float::parse_radix("12.23e-4", 4); let f1 = Float::with_val(53, valid1.unwrap()); assert_eq!(f1, (2.0 + 4.0 * 1.0 + 0.25 * (2.0 + 0.25 * 3.0)) / 256.0); let valid2 = Float::parse_radix("12.yz@2", 36); let f2 = Float::with_val(53, valid2.unwrap()); assert_eq!(f2, 35 + 36 * (34 + 36 * (2 + 36 * 1))); let invalid = Float::parse_radix("ffe-2", 16); assert!(invalid.is_err());
pub fn to_integer(&self) -> Option<Integer>
[src]
pub fn to_integer(&self) -> Option<Integer>
If the value is a finite number, converts it to
an Integer
rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 13.7); let i = match f.to_integer() { Some(i) => i, None => unreachable!(), }; assert_eq!(i, 14);
pub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>
[src]
pub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>
If the value is a finite number, converts it to
an Integer
applying the specified rounding method.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let f = Float::with_val(53, 13.7); let (i, dir) = match f.to_integer_round(Round::Down) { Some(i_dir) => i_dir, None => unreachable!(), }; assert_eq!(i, 13); assert_eq!(dir, Ordering::Less);
pub fn to_integer_exp(&self) -> Option<(Integer, i32)>
[src]
pub fn to_integer_exp(&self) -> Option<(Integer, i32)>
If the value is a finite number, returns an
Integer
and exponent such that it is exactly equal to the
integer multiplied by two raised to the power of the exponent.
Examples
use rug::float::Special; use rug::{Assign, Float}; let mut float = Float::with_val(16, 6.5); // 6.5 in binary is 110.1 // Since the precision is 16 bits, this becomes // 1101_0000_0000_0000 times two to the power of -12 let (int, exp) = float.to_integer_exp().unwrap(); assert_eq!(int, 0b1101_0000_0000_0000); assert_eq!(exp, -13); float.assign(0); let (zero, _) = float.to_integer_exp().unwrap(); assert_eq!(zero, 0); float.assign(Special::Infinity); assert!(float.to_integer_exp().is_none());
pub fn to_rational(&self) -> Option<Rational>
[src]
pub fn to_rational(&self) -> Option<Rational>
If the value is a finite number, returns a
Rational
number preserving all the precision of the value.
If the compiler supports TryFrom
, this conversion can also
be performed using Rational::try_from(&float)
or
Rational::try_from(float)
.
Examples
use rug::float::Round; use rug::{Float, Rational}; use std::cmp::Ordering; use std::str::FromStr; // Consider the number 123,456,789 / 10,000,000,000. let parse = Float::parse("0.0123456789").unwrap(); let (f, f_rounding) = Float::with_val_round(35, parse, Round::Down); assert_eq!(f_rounding, Ordering::Less); let r = Rational::from_str("123456789/10000000000").unwrap(); // Set fr to the value of f exactly. let fr = f.to_rational().unwrap(); // Since f == fr and f was rounded down, r != fr. assert_ne!(r, fr); let (frf, frf_rounding) = Float::with_val_round(35, &fr, Round::Down); assert_eq!(frf_rounding, Ordering::Equal); assert_eq!(frf, f); assert_eq!(format!("{:.9}", frf), "1.23456789e-2");
In the following example, the Float
values can be
represented exactly.
use rug::Float; let large_f = Float::with_val(16, 6.5); let large_r = large_f.to_rational().unwrap(); let small_f = Float::with_val(16, -0.125); let small_r = small_f.to_rational().unwrap(); assert_eq!(*large_r.numer(), 13); assert_eq!(*large_r.denom(), 2); assert_eq!(*small_r.numer(), -1); assert_eq!(*small_r.denom(), 8);
pub fn to_i32_saturating(&self) -> Option<i32>
[src]
pub fn to_i32_saturating(&self) -> Option<i32>
Converts to an i32
, rounding to the nearest.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::{Assign, Float}; use std::{i32, u32}; let mut f = Float::with_val(53, -13.7); assert_eq!(f.to_i32_saturating(), Some(-14)); f.assign(-1e40); assert_eq!(f.to_i32_saturating(), Some(i32::MIN)); f.assign(u32::MAX); assert_eq!(f.to_i32_saturating(), Some(i32::MAX));
pub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>
[src]
pub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>
Converts to an i32
, applying the specified rounding method.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::float::Round; use rug::Float; let f = Float::with_val(53, -13.7); assert_eq!(f.to_i32_saturating_round(Round::Up), Some(-13));
pub fn to_u32_saturating(&self) -> Option<u32>
[src]
pub fn to_u32_saturating(&self) -> Option<u32>
Converts to a u32
, rounding to the nearest.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::{Assign, Float}; use std::u32; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_u32_saturating(), Some(14)); f.assign(-1); assert_eq!(f.to_u32_saturating(), Some(0)); f.assign(1e40); assert_eq!(f.to_u32_saturating(), Some(u32::MAX));
pub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>
[src]
pub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>
Converts to a u32
, applying the specified rounding method.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::float::Round; use rug::Float; let f = Float::with_val(53, 13.7); assert_eq!(f.to_u32_saturating_round(Round::Down), Some(13));
pub fn to_f32(&self) -> f32
[src]
pub fn to_f32(&self) -> f32
Converts to an f32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::{Assign, Float}; use std::f32; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_f32(), 13.7); f.assign(1e300); assert_eq!(f.to_f32(), f32::INFINITY); f.assign(1e-300); assert_eq!(f.to_f32(), 0.0);
pub fn to_f32_round(&self, round: Round) -> f32
[src]
pub fn to_f32_round(&self, round: Round) -> f32
Converts to an f32
, applying the specified rounding
method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; use std::f32; let f = Float::with_val(53, 1.0 + (-50f64).exp2()); assert_eq!(f.to_f32_round(Round::Up), 1.0 + f32::EPSILON);
pub fn to_f64(&self) -> f64
[src]
pub fn to_f64(&self) -> f64
Converts to an f64
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::{Assign, Float}; use std::f64; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_f64(), 13.7); f.assign(1e300); f.square_mut(); assert_eq!(f.to_f64(), f64::INFINITY);
pub fn to_f64_round(&self, round: Round) -> f64
[src]
pub fn to_f64_round(&self, round: Round) -> f64
Converts to an f64
, applying the specified rounding
method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; use std::f64; // (2.0 ^ -90) + 1 let f: Float = Float::with_val(100, -90).exp2() + 1; assert_eq!(f.to_f64_round(Round::Up), 1.0 + f64::EPSILON);
pub fn to_f32_exp(&self) -> (f32, i32)
[src]
pub fn to_f32_exp(&self) -> (f32, i32)
Converts to an f32
and an exponent, rounding to the
nearest.
The returned f32
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::Float; let zero = Float::new(64); let (d0, exp0) = zero.to_f32_exp(); assert_eq!((d0, exp0), (0.0, 0)); let three_eighths = Float::with_val(64, 0.375); let (d3_8, exp3_8) = three_eighths.to_f32_exp(); assert_eq!((d3_8, exp3_8), (0.75, -1));
pub fn to_f32_exp_round(&self, round: Round) -> (f32, i32)
[src]
pub fn to_f32_exp_round(&self, round: Round) -> (f32, i32)
Converts to an f32
and an exponent, applying the specified
rounding method.
The returned f32
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; let frac_10_3 = Float::with_val(64, 10) / 3u32; let (f_down, exp_down) = frac_10_3.to_f32_exp_round(Round::Down); assert_eq!((f_down, exp_down), (0.8333333, 2)); let (f_up, exp_up) = frac_10_3.to_f32_exp_round(Round::Up); assert_eq!((f_up, exp_up), (0.8333334, 2));
pub fn to_f64_exp(&self) -> (f64, i32)
[src]
pub fn to_f64_exp(&self) -> (f64, i32)
Converts to an f64
and an exponent, rounding to the
nearest.
The returned f64
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::Float; let zero = Float::new(64); let (d0, exp0) = zero.to_f64_exp(); assert_eq!((d0, exp0), (0.0, 0)); let three_eighths = Float::with_val(64, 0.375); let (d3_8, exp3_8) = three_eighths.to_f64_exp(); assert_eq!((d3_8, exp3_8), (0.75, -1));
pub fn to_f64_exp_round(&self, round: Round) -> (f64, i32)
[src]
pub fn to_f64_exp_round(&self, round: Round) -> (f64, i32)
Converts to an f64
and an exponent, applying the specified
rounding method.
The returned f64
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; let frac_10_3 = Float::with_val(64, 10) / 3u32; let (f_down, exp_down) = frac_10_3.to_f64_exp_round(Round::Down); assert_eq!((f_down, exp_down), (0.8333333333333333, 2)); let (f_up, exp_up) = frac_10_3.to_f64_exp_round(Round::Up); assert_eq!((f_up, exp_up), (0.8333333333333334, 2));
pub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
[src]
pub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
Returns a string representation of self
for the specified
radix
rounding to the nearest.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::float::Special; use rug::Float; let neg_inf = Float::with_val(53, Special::NegInfinity); assert_eq!(neg_inf.to_string_radix(10, None), "-inf"); assert_eq!(neg_inf.to_string_radix(16, None), "-@inf@"); let twentythree = Float::with_val(8, 23); assert_eq!(twentythree.to_string_radix(10, None), "2.300e1"); assert_eq!(twentythree.to_string_radix(16, None), "1.70@1"); assert_eq!(twentythree.to_string_radix(10, Some(2)), "2.3e1"); assert_eq!(twentythree.to_string_radix(16, Some(4)), "1.700@1");
pub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: Round
) -> String
[src]
pub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: Round
) -> String
Returns a string representation of self
for the specified
radix
applying the specified rounding method.
The exponent is encoded in decimal. The output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::float::Round; use rug::Float; let twentythree = Float::with_val(8, 23.3); let down = twentythree.to_string_radix_round(10, Some(2), Round::Down); assert_eq!(down, "2.3e1"); let up = twentythree.to_string_radix_round(10, Some(2), Round::Up); assert_eq!(up, "2.4e1");
pub fn as_neg(&self) -> BorrowFloat
[src]
pub fn as_neg(&self) -> BorrowFloat
Borrows a negated copy of the Float
.
The returned object implements
Deref<Target = Float>
.
This method performs a shallow copy and negates it, and negation does not change the allocated data.
Examples
use rug::Float; let f = Float::with_val(53, 4.2); let neg_f = f.as_neg(); assert_eq!(*neg_f, -4.2); // methods taking &self can be used on the returned object let reneg_f = neg_f.as_neg(); assert_eq!(*reneg_f, 4.2); assert_eq!(*reneg_f, f);
pub fn as_abs(&self) -> BorrowFloat
[src]
pub fn as_abs(&self) -> BorrowFloat
Borrows an absolute copy of the Float
.
The returned object implements
Deref<Target = Float>
.
This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.
Examples
use rug::Float; let f = Float::with_val(53, -4.2); let abs_f = f.as_abs(); assert_eq!(*abs_f, 4.2); // methods taking &self can be used on the returned object let reabs_f = abs_f.as_abs(); assert_eq!(*reabs_f, 4.2); assert_eq!(*reabs_f, *abs_f);
pub fn as_ord(&self) -> &OrdFloat
[src]
pub fn as_ord(&self) -> &OrdFloat
Borrows the Float
as an ordered floating-point number of
type OrdFloat
.
Examples
use rug::float::Special; use rug::Float; use std::cmp::Ordering; let nan_f = Float::with_val(53, Special::Nan); let nan = nan_f.as_ord(); assert_eq!(nan.cmp(nan), Ordering::Equal); let neg_inf_f = Float::with_val(53, Special::NegInfinity); let neg_inf = neg_inf_f.as_ord(); assert_eq!(nan.cmp(neg_inf), Ordering::Less); let zero_f = Float::with_val(53, Special::Zero); let zero = zero_f.as_ord(); let neg_zero_f = Float::with_val(53, Special::NegZero); let neg_zero = neg_zero_f.as_ord(); assert_eq!(zero.cmp(neg_zero), Ordering::Greater);
pub fn is_integer(&self) -> bool
[src]
pub fn is_integer(&self) -> bool
Returns true
if self
is an integer.
Examples
use rug::Float; let mut f = Float::with_val(53, 13.5); assert!(!f.is_integer()); f *= 2; assert!(f.is_integer());
pub fn is_nan(&self) -> bool
[src]
pub fn is_nan(&self) -> bool
Returns true
if self
is not a number.
Examples
use rug::Float; let mut f = Float::with_val(53, 0); assert!(!f.is_nan()); f /= 0; assert!(f.is_nan());
pub fn is_infinite(&self) -> bool
[src]
pub fn is_infinite(&self) -> bool
Returns true
if self
is plus or minus infinity.
Examples
use rug::Float; let mut f = Float::with_val(53, 1); assert!(!f.is_infinite()); f /= 0; assert!(f.is_infinite());
pub fn is_finite(&self) -> bool
[src]
pub fn is_finite(&self) -> bool
Returns true
if self
is a finite number, that is neither
NaN nor infinity.
Examples
use rug::Float; let mut f = Float::with_val(53, 1); assert!(f.is_finite()); f /= 0; assert!(!f.is_finite());
pub fn is_zero(&self) -> bool
[src]
pub fn is_zero(&self) -> bool
Returns true
if self
is plus or minus zero.
Examples
use rug::float::Special; use rug::{Assign, Float}; let mut f = Float::with_val(53, Special::Zero); assert!(f.is_zero()); f.assign(Special::NegZero); assert!(f.is_zero()); f += 1; assert!(!f.is_zero());
pub fn is_normal(&self) -> bool
[src]
pub fn is_normal(&self) -> bool
Returns true
if self
is a normal number, that is neither
NaN, nor infinity, nor zero. Note that Float
cannot be
subnormal.
Examples
use rug::float::Special; use rug::{Assign, Float}; let mut f = Float::with_val(53, Special::Zero); assert!(!f.is_normal()); f += 5.2; assert!(f.is_normal()); f.assign(Special::Infinity); assert!(!f.is_normal()); f.assign(Special::Nan); assert!(!f.is_normal());
pub fn classify(&self) -> FpCategory
[src]
pub fn classify(&self) -> FpCategory
Returns the floating-point category of the number. Note that
Float
cannot be subnormal.
Examples
use rug::float::Special; use rug::Float; use std::num::FpCategory; let nan = Float::with_val(53, Special::Nan); let infinite = Float::with_val(53, Special::Infinity); let zero = Float::with_val(53, Special::Zero); let normal = Float::with_val(53, 2.3); assert_eq!(nan.classify(), FpCategory::Nan); assert_eq!(infinite.classify(), FpCategory::Infinite); assert_eq!(zero.classify(), FpCategory::Zero); assert_eq!(normal.classify(), FpCategory::Normal);
pub fn cmp0(&self) -> Option<Ordering>
[src]
pub fn cmp0(&self) -> Option<Ordering>
Returns the same result as
self.partial_cmp(&0)
, but is faster.
Examples
use rug::float::Special; use rug::{Assign, Float}; use std::cmp::Ordering; let mut f = Float::with_val(53, Special::NegZero); assert_eq!(f.cmp0(), Some(Ordering::Equal)); f += 5.2; assert_eq!(f.cmp0(), Some(Ordering::Greater)); f.assign(Special::NegInfinity); assert_eq!(f.cmp0(), Some(Ordering::Less)); f.assign(Special::Nan); assert_eq!(f.cmp0(), None);
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
[src]
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
Compares the absolute values of self
and other
.
Examples
use rug::Float; use std::cmp::Ordering; let a = Float::with_val(53, -10); let b = Float::with_val(53, 4); assert_eq!(a.partial_cmp(&b), Some(Ordering::Less)); assert_eq!(a.cmp_abs(&b), Some(Ordering::Greater));
pub fn get_exp(&self) -> Option<i32>
[src]
pub fn get_exp(&self) -> Option<i32>
If the value is a normal number, returns its exponent.
The significand is assumed to be in the range 0.5 ≤ x < 1.
Examples
use rug::{Assign, Float}; // -(2.0 ^ 32) == -(0.5 * 2 ^ 33) let mut f = Float::with_val(53, -32f64.exp2()); assert_eq!(f.get_exp(), Some(33)); // 0.8 * 2 ^ -39 f.assign(0.8 * (-39f64).exp2()); assert_eq!(f.get_exp(), Some(-39)); f.assign(0); assert_eq!(f.get_exp(), None);
pub fn get_significand(&self) -> Option<BorrowInteger>
[src]
pub fn get_significand(&self) -> Option<BorrowInteger>
If the value is a normal number, returns a
reference to its significand as an Integer
.
The unwrapped returned object implements
Deref<Target = Integer>
.
The number of significant bits of a
returned significand is at least equal to the
precision, but can be larger. It is usually rounded
up to a multiple of 32 or 64 depending on the implementation;
in this case, the extra least significant bits will be zero.
The value of self
is exactly equal to the returned
Integer
divided by two raised to the power of the number
of significant bits and multiplied by
two raised to the power of the exponent of
self
.
Unlike the to_integer_exp
method which returns an owned
Integer
, this method only performs a shallow copy and does
not allocate any memory.
Examples
use rug::Float; let float = Float::with_val(16, 6.5); // 6.5 in binary is 110.1 = 0.1101 times two to the power of 3 let exp = float.get_exp().unwrap(); assert_eq!(exp, 3); let significand = float.get_significand().unwrap(); let sig_bits = significand.significant_bits(); // sig_bits must be greater or equal to precision assert!(sig_bits >= 16); let (check_int, check_exp) = float.to_integer_exp().unwrap(); assert_eq!(check_int << sig_bits << (check_exp - exp), *significand);
pub fn is_sign_positive(&self) -> bool
[src]
pub fn is_sign_positive(&self) -> bool
Returns true
if the value is positive, +0 or NaN without a
negative sign.
Examples
use rug::Float; let pos = Float::with_val(53, 1.0); let neg = Float::with_val(53, -1.0); assert!(pos.is_sign_positive()); assert!(!neg.is_sign_positive());
pub fn is_sign_negative(&self) -> bool
[src]
pub fn is_sign_negative(&self) -> bool
Returns true
if the value is negative, −0 or NaN with a
negative sign.
Examples
use rug::Float; let neg = Float::with_val(53, -1.0); let pos = Float::with_val(53, 1.0); assert!(neg.is_sign_negative()); assert!(!pos.is_sign_negative());
pub fn next_toward(&mut self, to: &Self)
[src]
pub fn next_toward(&mut self, to: &Self)
Sets to the next value towards to
.
Examples
use rug::Float; let to = Float::with_val(8, 100); // 32.5 in binary is 100000.10 // 32.75 in binary is 100000.11 let mut f = Float::with_val(8, 32.5); f.next_toward(&to); assert_eq!(f, 32.75);
pub fn next_up(&mut self)
[src]
pub fn next_up(&mut self)
Sets to the next value towards +∞.
Examples
use rug::Float; // 32.5 in binary is 100000.10 // 32.75 in binary is 100000.11 let mut f = Float::with_val(8, 32.5); f.next_up(); assert_eq!(f, 32.75);
pub fn next_down(&mut self)
[src]
pub fn next_down(&mut self)
Sets to the next value towards −∞.
Examples
use rug::Float; // 32.5 in binary is 100000.10 // 32.25 in binary is 100000.01 let mut f = Float::with_val(8, 32.5); f.next_down(); assert_eq!(f, 32.25);
pub fn subnormalize_ieee(&mut self) -> &mut Self
[src]
pub fn subnormalize_ieee(&mut self) -> &mut Self
Emulate subnormal numbers for precisions specified in IEEE 754, rounding to the nearest.
Subnormalization is only performed for precisions specified in IEEE 754:
- binary16 with 16 storage bits and a precision of 11 bits,
- binary32 (single precision) with 32 storage bits and a precision of 24 bits,
- binary64 (double precision) with 64 storage bits and a precision of 53 bits,
- binary{k} with k storage bits where k is a multiple of 32 and k ≥ 128, and a precision of k − round(4 × log2 k) + 13 bits.
This method has no effect if the value is not in the subnormal range.
Examples
use rug::Float; use std::f32; // minimum single subnormal is 0.5 * 2 ^ -148 = 2 ^ -149 let single_min_subnormal = (-149f64).exp2(); assert_eq!(single_min_subnormal, single_min_subnormal as f32 as f64); let single_cannot = single_min_subnormal * 1.25; assert_eq!(single_min_subnormal, single_cannot as f32 as f64); let mut f = Float::with_val(24, single_cannot); assert_eq!(f.to_f64(), single_cannot); f.subnormalize_ieee(); assert_eq!(f.to_f64(), single_min_subnormal);
pub fn subnormalize_ieee_round(
&mut self,
prev_rounding: Ordering,
round: Round
) -> Ordering
[src]
pub fn subnormalize_ieee_round(
&mut self,
prev_rounding: Ordering,
round: Round
) -> Ordering
Emulate subnormal numbers for precisions specified in IEEE 754, applying the specified rounding method.
Subnormalization is only performed for precisions specified in IEEE 754:
- binary16 with 16 storage bits and a precision of 11 bits,
- binary32 (single precision) with 32 storage bits and a precision of 24 bits,
- binary64 (double precision) with 64 storage bits and a precision of 53 bits,
- binary{k} with k storage bits where k is a multiple of 32 and k ≥ 128, and a precision of k − round(4 × log2 k) + 13 bits.
This method simply propagates prev_rounding
if the value is
not in the subnormal range.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; use std::f32; // minimum single subnormal is 0.5 * 2 ^ -148 = 2 ^ -149 let single_min_subnormal = (-149f64).exp2(); assert_eq!(single_min_subnormal, single_min_subnormal as f32 as f64); let single_cannot = single_min_subnormal * 1.25; assert_eq!(single_min_subnormal, single_cannot as f32 as f64); let mut f = Float::with_val(24, single_cannot); assert_eq!(f.to_f64(), single_cannot); let dir = f.subnormalize_ieee_round(Ordering::Equal, Round::Up); assert_eq!(f.to_f64(), single_min_subnormal * 2.0); assert_eq!(dir, Ordering::Greater);
pub fn subnormalize(&mut self, normal_exp_min: i32) -> &mut Self
[src]
pub fn subnormalize(&mut self, normal_exp_min: i32) -> &mut Self
Emulate subnormal numbers, rounding to the nearest.
Subnormalization is only performed when the exponent lies
within the subnormal range, that is when
normal_exp_min
− precision + 1 ≤ exponent < normal_exp_min
.
For example, for IEEE 754 single precision, the precision is
24 and normal_exp_min
is −125, so the subnormal range would
be −148 ≤ exponent < −125.
This method has no effect if the value is not in the subnormal range.
Examples
use rug::Float; use std::f32; // minimum single subnormal is 0.5 * 2 ^ -148 = 2 ^ -149 let single_min_subnormal = (-149f64).exp2(); assert_eq!(single_min_subnormal, single_min_subnormal as f32 as f64); let single_cannot = single_min_subnormal * 1.25; assert_eq!(single_min_subnormal, single_cannot as f32 as f64); let mut f = Float::with_val(24, single_cannot); assert_eq!(f.to_f64(), single_cannot); f.subnormalize(-125); assert_eq!(f.to_f64(), single_min_subnormal);
pub fn subnormalize_round(
&mut self,
normal_exp_min: i32,
prev_rounding: Ordering,
round: Round
) -> Ordering
[src]
pub fn subnormalize_round(
&mut self,
normal_exp_min: i32,
prev_rounding: Ordering,
round: Round
) -> Ordering
Emulate subnormal numbers, applying the specified rounding method.
Subnormalization is only performed when the exponent lies
within the subnormal range, that is when
normal_exp_min
− precision + 1 ≤ exponent < normal_exp_min
.
For example, for IEEE 754 single precision, the precision is
24 and normal_exp_min
is −125, so the subnormal range would
be −148 ≤ exponent < −125.
This method simply propagates prev_rounding
if the value is
not in the subnormal range.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; use std::f32; // minimum single subnormal is 0.5 * 2 ^ -148 = 2 ^ -149 let single_min_subnormal = (-149f64).exp2(); assert_eq!(single_min_subnormal, single_min_subnormal as f32 as f64); let single_cannot = single_min_subnormal * 1.25; assert_eq!(single_min_subnormal, single_cannot as f32 as f64); let mut f = Float::with_val(24, single_cannot); assert_eq!(f.to_f64(), single_cannot); let dir = f.subnormalize_round(-125, Ordering::Equal, Round::Up); assert_eq!(f.to_f64(), single_min_subnormal * 2.0); assert_eq!(dir, Ordering::Greater);
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
[src]
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Adds a list of Float
values with correct rounding.
Assign<Src> for Float
,
AssignRound<Src> for Float
,
AddAssign<Src> for Float
,
AddAssignRound<Src> for Float
and
Add<Src> for Float
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::float::Round; use rug::ops::AddAssignRound; use rug::Float; use std::cmp::Ordering; // Give each value only 4 bits of precision for example purposes. let values = [ Float::with_val(4, 5.0), Float::with_val(4, 1024.0), Float::with_val(4, -1024.0), Float::with_val(4, -4.5), ]; // The result should still be exact if it fits. let r = Float::sum(values.iter()); let sum = Float::with_val(4, r); assert_eq!(sum, 0.5); let mut f = Float::with_val(4, 15.0); // 15.5 using 4 bits of precision becomes 16.0 let r = Float::sum(values.iter()); let dir = f.add_assign_round(r, Round::Nearest); assert_eq!(f, 16.0); assert_eq!(dir, Ordering::Greater);
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
[src]
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
Finds the dot product of a list of Float
value pairs with
correct rounding.
Assign<Src> for Float
,
AssignRound<Src> for Float
,
AddAssign<Src> for Float
,
AddAssignRound<Src> for Float
and
Add<Src> for Float
are implemented with the
returned incomplete-computation value as Src
.
This method will produce a result with correct rounding, except for some cases where underflow or overflow occurs in intermediate products.
Examples
use rug::Float; let a = [Float::with_val(53, 2.75), Float::with_val(53, -1.25)]; let b = [Float::with_val(53, 10.5), Float::with_val(53, 0.5)]; let r = Float::dot(a.iter().zip(b.iter())); let dot = Float::with_val(53, r); let expected = 2.75 * 10.5 - 1.25 * 0.5; assert_eq!(dot, expected);
pub fn mul_add(self, mul: &Self, add: &Self) -> Self
[src]
pub fn mul_add(self, mul: &Self, add: &Self) -> Self
Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.
a.mul_add(&b, &c)
produces a result like &a * &b + &c
, but
a
is consumed and the result produced uses its precision.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let add = Float::with_val(4, 24); // 1.5 * -13 + 24 = 4.5 let mul_add = mul1.mul_add(&mul2, &add); assert_eq!(mul_add, 4.5);
pub fn mul_add_mut(&mut self, mul: &Self, add: &Self)
[src]
pub fn mul_add_mut(&mut self, mul: &Self, add: &Self)
Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.
a.mul_add_mut(&b, &c)
produces a result like &a * &b + &c
,
but stores the result in a
using its precision.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mut mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let add = Float::with_val(4, 24); // 1.5 * -13 + 24 = 4.5 mul1.mul_add_mut(&mul2, &add); assert_eq!(mul1, 4.5);
pub fn mul_add_round(
&mut self,
mul: &Self,
add: &Self,
round: Round
) -> Ordering
[src]
pub fn mul_add_round(
&mut self,
mul: &Self,
add: &Self,
round: Round
) -> Ordering
Multiplies and adds in one fused operation, applying the specified rounding method with only one rounding error.
a.mul_add_round(&b, &c, round)
produces a result like
ans.assign_round(&a * &b + &c, round)
, but stores the result
in a
using its precision rather than in another Float
like ans
.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mut mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let add = Float::with_val(4, 24); // 1.5 * -13 + 24 = 4.5 let dir = mul1.mul_add_round(&mul2, &add, Round::Nearest); assert_eq!(mul1, 4.5); assert_eq!(dir, Ordering::Equal);
pub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
[src]
pub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
Multiplies and adds in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_add_ref(&b, &c)
produces the exact same result as
&a * &b + &c
.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let add = Float::with_val(4, 24); // 1.5 * -13 + 24 = 4.5 let ans = Float::with_val(4, mul1.mul_add_ref(&mul2, &add)); assert_eq!(ans, 4.5);
pub fn mul_sub(self, mul: &Self, sub: &Self) -> Self
[src]
pub fn mul_sub(self, mul: &Self, sub: &Self) -> Self
Multiplies and subtracts in one fused operation, rounding to the nearest with only one rounding error.
a.mul_sub(&b, &c)
produces a result like &a * &b - &c
, but
a
is consumed and the result produced uses its precision.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let sub = Float::with_val(4, 24); // 1.5 * -13 - 24 = -43.5, rounded to 44 using four bits of precision. let mul_sub = mul1.mul_sub(&mul2, &sub); assert_eq!(mul_sub, -44);
pub fn mul_sub_mut(&mut self, mul: &Self, sub: &Self)
[src]
pub fn mul_sub_mut(&mut self, mul: &Self, sub: &Self)
Multiplies and subtracts in one fused operation, rounding to the nearest with only one rounding error.
a.mul_sub_mut(&b, &c)
produces a result like &a * &b - &c
,
but stores the result in a
using its precision.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mut mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let sub = Float::with_val(4, 24); // 1.5 * -13 - 24 = -43.5, rounded to 44 using four bits of precision. mul1.mul_sub_mut(&mul2, &sub); assert_eq!(mul1, -44);
pub fn mul_sub_round(
&mut self,
mul: &Self,
sub: &Self,
round: Round
) -> Ordering
[src]
pub fn mul_sub_round(
&mut self,
mul: &Self,
sub: &Self,
round: Round
) -> Ordering
Multiplies and subtracts in one fused operation, applying the specified rounding method with only one rounding error.
a.mul_sub_round(&b, &c, round)
produces a result like
ans.assign_round(&a * &b - &c, round)
, but stores the result
in a
using its precision rather than in another Float
like ans
.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mut mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let sub = Float::with_val(4, 24); // 1.5 * -13 - 24 = -43.5, rounded to 44 using four bits of precision. let dir = mul1.mul_sub_round(&mul2, &sub, Round::Nearest); assert_eq!(mul1, -44); assert_eq!(dir, Ordering::Less);
pub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
[src]
pub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
Multiplies and subtracts in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_sub_ref(&b, &c)
produces the exact same result as
&a * &b - &c
.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let sub = Float::with_val(4, 24); // 1.5 * -13 - 24 = -43.5, rounded to 44 using four bits of precision. let ans = Float::with_val(4, mul1.mul_sub_ref(&mul2, &sub)); assert_eq!(ans, -44);
pub fn mul_add_mul(self, mul: &Self, add_mul1: &Self, add_mul2: &Self) -> Self
[src]
pub fn mul_add_mul(self, mul: &Self, add_mul1: &Self, add_mul2: &Self) -> Self
Multiplies two products and adds them in one fused operation, rounding to the nearest with only one rounding error.
a.mul_add_mul(&b, &c, &d)
produces a result like
&a * &b + &c * &d
, but a
is consumed and the result
produced uses its precision.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 + 12 * 2 = 60 let mul_add_mul = a.mul_add_mul(&b, &c, &d); assert_eq!(mul_add_mul, 60);
pub fn mul_add_mul_mut(&mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self)
[src]
pub fn mul_add_mul_mut(&mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self)
Multiplies two products and adds them in one fused operation, rounding to the nearest with only one rounding error.
a.mul_add_mul_mut(&b, &c, &d)
produces a result like
&a * &b + &c * &d
, but stores the result in a
using its
precision.
Examples
use rug::Float; let mut a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 + 12 * 2 = 60 a.mul_add_mul_mut(&b, &c, &d); assert_eq!(a, 60);
pub fn mul_add_mul_round(
&mut self,
mul: &Self,
add_mul1: &Self,
add_mul2: &Self,
round: Round
) -> Ordering
[src]
pub fn mul_add_mul_round(
&mut self,
mul: &Self,
add_mul1: &Self,
add_mul2: &Self,
round: Round
) -> Ordering
Multiplies two produces and adds them in one fused operation, applying the specified rounding method with only one rounding error.
a.mul_add_mul_round(&b, &c, &d, round)
produces a result
like ans.assign_round(&a * &b + &c * &d, round)
, but stores
the result in a
using its precision rather than in another
Float
like ans
.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let mut a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 + 12 * 2 = 60 let dir = a.mul_add_mul_round(&b, &c, &d, Round::Nearest); assert_eq!(a, 60); assert_eq!(dir, Ordering::Equal);
pub fn mul_add_mul_ref<'a>(
&'a self,
mul: &'a Self,
add_mul1: &'a Self,
add_mul2: &'a Self
) -> MulAddMulIncomplete<'a>
[src]
pub fn mul_add_mul_ref<'a>(
&'a self,
mul: &'a Self,
add_mul1: &'a Self,
add_mul2: &'a Self
) -> MulAddMulIncomplete<'a>
Multiplies two products and adds them in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_add_mul_ref(&b, &c, &d)
produces the exact same result
as &a * &b + &c * &d
.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 + 12 * 2 = 60 let ans = Float::with_val(53, a.mul_add_mul_ref(&b, &c, &d)); assert_eq!(ans, 60);
pub fn mul_sub_mul(self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self) -> Self
[src]
pub fn mul_sub_mul(self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self) -> Self
Multiplies two products and subtracts them in one fused operation, rounding to the nearest with only one rounding error.
a.mul_sub_mul(&b, &c, &d)
produces a result like
&a * &b - &c * &d
, but a
is consumed and the result
produced uses its precision.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 - 12 * 2 = 12 let mul_sub_mul = a.mul_sub_mul(&b, &c, &d); assert_eq!(mul_sub_mul, 12);
pub fn mul_sub_mul_mut(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self)
[src]
pub fn mul_sub_mul_mut(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self)
Multiplies two products and subtracts them in one fused operation, rounding to the nearest with only one rounding error.
a.mul_sub_mul_mut(&b, &c, &d)
produces a result like
&a * &b - &c * &d
, but stores the result in a
using its
precision.
Examples
use rug::Float; let mut a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 - 12 * 2 = 12 a.mul_sub_mul_mut(&b, &c, &d); assert_eq!(a, 12);
pub fn mul_sub_mul_round(
&mut self,
mul: &Self,
sub_mul1: &Self,
sub_mul2: &Self,
round: Round
) -> Ordering
[src]
pub fn mul_sub_mul_round(
&mut self,
mul: &Self,
sub_mul1: &Self,
sub_mul2: &Self,
round: Round
) -> Ordering
Multiplies two produces and subtracts them in one fused operation, applying the specified rounding method with only one rounding error.
a.mul_sub_mul_round(&b, &c, &d, round)
produces a result
like ans.assign_round(&a * &b - &c * &d, round)
, but stores
the result in a
using its precision rather than in another
Float
like ans
.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let mut a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 - 12 * 2 = 12 let dir = a.mul_sub_mul_round(&b, &c, &d, Round::Nearest); assert_eq!(a, 12); assert_eq!(dir, Ordering::Equal);
pub fn mul_sub_mul_ref<'a>(
&'a self,
mul: &'a Self,
sub_mul1: &'a Self,
sub_mul2: &'a Self
) -> MulSubMulIncomplete<'a>
[src]
pub fn mul_sub_mul_ref<'a>(
&'a self,
mul: &'a Self,
sub_mul1: &'a Self,
sub_mul2: &'a Self
) -> MulSubMulIncomplete<'a>
Multiplies two products and subtracts them in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_sub_mul_ref(&b, &c, &d)
produces the exact same result
as &a * &b - &c * &d
.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 - 12 * 2 = 12 let ans = Float::with_val(53, a.mul_sub_mul_ref(&b, &c, &d)); assert_eq!(ans, 12);
pub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete
[src]
pub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete
Raises base
to the power of exponent
.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let p = Float::u_pow_u(13, 6); let f = Float::with_val(53, p); assert_eq!(f, 13u32.pow(6));
pub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete
[src]
pub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete
Raises base
to the power of exponent
.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let p = Float::i_pow_u(-13, 5); let f = Float::with_val(53, p); assert_eq!(f, -13i32.pow(5));
pub fn square(self) -> Self
[src]
pub fn square(self) -> Self
Computes the square, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 5.0); let square = f.square(); assert_eq!(square, 25.0);
pub fn square_mut(&mut self)
[src]
pub fn square_mut(&mut self)
Computes the square, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 5.0); f.square_mut(); assert_eq!(f, 25.0);
pub fn square_round(&mut self, round: Round) -> Ordering
[src]
pub fn square_round(&mut self, round: Round) -> Ordering
Computes the square, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 5 in binary is 101 let mut f = Float::with_val(3, 5.0); // 25 in binary is 11001 (more than 3 bits of precision). // 25 (11001) is rounded up to 28 (11100). let dir = f.square_round(Round::Up); assert_eq!(f, 28.0); assert_eq!(dir, Ordering::Greater);
pub fn square_ref(&self) -> SquareIncomplete
[src]
pub fn square_ref(&self) -> SquareIncomplete
Computes the square.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 5.0); let r = f.square_ref(); let square = Float::with_val(53, r); assert_eq!(square, 25.0);
pub fn sqrt(self) -> Self
[src]
pub fn sqrt(self) -> Self
Computes the square root, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 25.0); let sqrt = f.sqrt(); assert_eq!(sqrt, 5.0);
pub fn sqrt_mut(&mut self)
[src]
pub fn sqrt_mut(&mut self)
Computes the square root, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 25.0); f.sqrt_mut(); assert_eq!(f, 5.0);
pub fn sqrt_round(&mut self, round: Round) -> Ordering
[src]
pub fn sqrt_round(&mut self, round: Round) -> Ordering
Computes the square root, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 5 in binary is 101 let mut f = Float::with_val(4, 5.0); // sqrt(5) in binary is 10.00111100... // sqrt(5) is rounded to 2.25 (10.01). let dir = f.sqrt_round(Round::Nearest); assert_eq!(f, 2.25); assert_eq!(dir, Ordering::Greater);
pub fn sqrt_ref(&self) -> SqrtIncomplete
[src]
pub fn sqrt_ref(&self) -> SqrtIncomplete
Computes the square root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 25.0); let r = f.sqrt_ref(); let sqrt = Float::with_val(53, r); assert_eq!(sqrt, 5.0);
pub fn sqrt_u(u: u32) -> SqrtUIncomplete
[src]
pub fn sqrt_u(u: u32) -> SqrtUIncomplete
Computes the square root of u
.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let s = Float::sqrt_u(25); let f = Float::with_val(53, s); assert_eq!(f, 5.0);
pub fn recip_sqrt(self) -> Self
[src]
pub fn recip_sqrt(self) -> Self
Computes the reciprocal square root, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 16.0); let recip_sqrt = f.recip_sqrt(); assert_eq!(recip_sqrt, 0.25);
pub fn recip_sqrt_mut(&mut self)
[src]
pub fn recip_sqrt_mut(&mut self)
Computes the reciprocal square root, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 16.0); f.recip_sqrt_mut(); assert_eq!(f, 0.25);
pub fn recip_sqrt_round(&mut self, round: Round) -> Ordering
[src]
pub fn recip_sqrt_round(&mut self, round: Round) -> Ordering
Computes the reciprocal square root, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 5 in binary is 101 let mut f = Float::with_val(4, 5.0); // 1/sqrt(5) in binary is 0.01110010... // 1/sqrt(5) is rounded to 0.4375 (0.01110). let dir = f.recip_sqrt_round(Round::Nearest); assert_eq!(f, 0.4375); assert_eq!(dir, Ordering::Less);
pub fn recip_sqrt_ref(&self) -> RecipSqrtIncomplete
[src]
pub fn recip_sqrt_ref(&self) -> RecipSqrtIncomplete
Computes the reciprocal square root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 16.0); let r = f.recip_sqrt_ref(); let recip_sqrt = Float::with_val(53, r); assert_eq!(recip_sqrt, 0.25);
pub fn cbrt(self) -> Self
[src]
pub fn cbrt(self) -> Self
Computes the cube root, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 125.0); let cbrt = f.cbrt(); assert_eq!(cbrt, 5.0);
pub fn cbrt_mut(&mut self)
[src]
pub fn cbrt_mut(&mut self)
Computes the cube root, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 125.0); f.cbrt_mut(); assert_eq!(f, 5.0);
pub fn cbrt_round(&mut self, round: Round) -> Ordering
[src]
pub fn cbrt_round(&mut self, round: Round) -> Ordering
Computes the cube root, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 5 in binary is 101 let mut f = Float::with_val(4, 5.0); // cbrt(5) in binary is 1.101101... // cbrt(5) is rounded to 1.75 (1.110). let dir = f.cbrt_round(Round::Nearest); assert_eq!(f, 1.75); assert_eq!(dir, Ordering::Greater);
pub fn cbrt_ref(&self) -> CbrtIncomplete
[src]
pub fn cbrt_ref(&self) -> CbrtIncomplete
Computes the cube root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 125.0); let r = f.cbrt_ref(); let cbrt = Float::with_val(53, r); assert_eq!(cbrt, 5.0);
pub fn root(self, k: u32) -> Self
[src]
pub fn root(self, k: u32) -> Self
Computes the kth root, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 625.0); let root = f.root(4); assert_eq!(root, 5.0);
pub fn root_mut(&mut self, k: u32)
[src]
pub fn root_mut(&mut self, k: u32)
Computes the kth root, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 625.0); f.root_mut(4); assert_eq!(f, 5.0);
pub fn root_round(&mut self, k: u32, round: Round) -> Ordering
[src]
pub fn root_round(&mut self, k: u32, round: Round) -> Ordering
Computes the kth root, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 5 in binary is 101 let mut f = Float::with_val(4, 5.0); // fourth root of 5 in binary is 1.01111... // fourth root of 5 is rounded to 1.5 (1.100). let dir = f.root_round(4, Round::Nearest); assert_eq!(f, 1.5); assert_eq!(dir, Ordering::Greater);
pub fn root_ref(&self, k: u32) -> RootIncomplete
[src]
pub fn root_ref(&self, k: u32) -> RootIncomplete
Computes the kth root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 625.0); let r = f.root_ref(4); let root = Float::with_val(53, r); assert_eq!(root, 5.0);
pub fn abs(self) -> Self
[src]
pub fn abs(self) -> Self
Computes the absolute value.
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let abs = f.abs(); assert_eq!(abs, 23.5);
pub fn abs_mut(&mut self)
[src]
pub fn abs_mut(&mut self)
Computes the absolute value.
Examples
use rug::Float; let mut f = Float::with_val(53, -23.5); f.abs_mut(); assert_eq!(f, 23.5);
pub fn abs_ref(&self) -> AbsIncomplete
[src]
pub fn abs_ref(&self) -> AbsIncomplete
Computes the absolute value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let r = f.abs_ref(); let abs = Float::with_val(53, r); assert_eq!(abs, 23.5);
pub fn signum(self) -> Self
[src]
pub fn signum(self) -> Self
Computes the signum.
- 1.0 if the value is positive, +0.0 or +∞
- −1.0 if the value is negative, −0.0 or −∞
- NaN if the value is NaN
Examples
use rug::Float; assert_eq!(Float::with_val(53, -23.5).signum(), -1); assert_eq!(Float::with_val(53, -0.0).signum(), -1); assert_eq!(Float::with_val(53, 0.0).signum(), 1); assert_eq!(Float::with_val(53, 23.5).signum(), 1);
pub fn signum_mut(&mut self)
[src]
pub fn signum_mut(&mut self)
Computes the signum.
- 1.0 if the value is positive, +0.0 or +∞
- −1.0 if the value is negative, −0.0 or −∞
- NaN if the value is NaN
Examples
use rug::Float; let mut f = Float::with_val(53, -23.5); f.signum_mut(); assert_eq!(f, -1);
pub fn signum_ref(&self) -> SignumIncomplete
[src]
pub fn signum_ref(&self) -> SignumIncomplete
Computes the signum.
- 1.0 if the value is positive, +0.0 or +∞
- −1.0 if the value is negative, −0.0 or −∞
- NaN if the value is NaN
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let r = f.signum_ref(); let signum = Float::with_val(53, r); assert_eq!(signum, -1);
pub fn clamp<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'b Max, Round = Round, Ordering = Ordering>,
[src]
pub fn clamp<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'b Max, Round = Round, Ordering = Ordering>,
Clamps the value within the specified bounds, rounding to the nearest.
Panics
Panics if the maximum value is less than the minimum value,
unless assigning any of them to self
produces the same value
with the same rounding direction.
Examples
use rug::Float; let min = -1.5; let max = 1.5; let too_small = Float::with_val(53, -2.5); let clamped1 = too_small.clamp(&min, &max); assert_eq!(clamped1, -1.5); let in_range = Float::with_val(53, 0.5); let clamped2 = in_range.clamp(&min, &max); assert_eq!(clamped2, 0.5);
pub fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'b Max, Round = Round, Ordering = Ordering>,
[src]
pub fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'b Max, Round = Round, Ordering = Ordering>,
Clamps the value within the specified bounds, rounding to the nearest.
Panics
Panics if the maximum value is less than the minimum value,
unless assigning any of them to self
produces the same value
with the same rounding direction.
Examples
use rug::Float; let min = -1.5; let max = 1.5; let mut too_small = Float::with_val(53, -2.5); too_small.clamp_mut(&min, &max); assert_eq!(too_small, -1.5); let mut in_range = Float::with_val(53, 0.5); in_range.clamp_mut(&min, &max); assert_eq!(in_range, 0.5);
pub fn clamp_round<'a, 'b, Min, Max>(
&mut self,
min: &'a Min,
max: &'b Max,
round: Round
) -> Ordering where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'b Max, Round = Round, Ordering = Ordering>,
[src]
pub fn clamp_round<'a, 'b, Min, Max>(
&mut self,
min: &'a Min,
max: &'b Max,
round: Round
) -> Ordering where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'b Max, Round = Round, Ordering = Ordering>,
Clamps the value within the specified bounds, applying the specified rounding method.
Panics
Panics if the maximum value is less than the minimum value,
unless assigning any of them to self
produces the same value
with the same rounding direction.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let min = Float::with_val(53, -1.5); let max = Float::with_val(53, 1.5); let mut too_small = Float::with_val(53, -2.5); let dir1 = too_small.clamp_round(&min, &max, Round::Nearest); assert_eq!(too_small, -1.5); assert_eq!(dir1, Ordering::Equal); let mut in_range = Float::with_val(53, 0.5); let dir2 = in_range.clamp_round(&min, &max, Round::Nearest); assert_eq!(in_range, 0.5); assert_eq!(dir2, Ordering::Equal);
pub fn clamp_ref<'a, Min, Max>(
&'a self,
min: &'a Min,
max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
[src]
pub fn clamp_ref<'a, Min, Max>(
&'a self,
min: &'a Min,
max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
Clamps the value within the specified bounds.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
Panics
Panics if the maximum value is less than the minimum value, unless assigning any of them to the target produces the same value with the same rounding direction.
Examples
use rug::Float; let min = -1.5; let max = 1.5; let too_small = Float::with_val(53, -2.5); let r1 = too_small.clamp_ref(&min, &max); let clamped1 = Float::with_val(53, r1); assert_eq!(clamped1, -1.5); let in_range = Float::with_val(53, 0.5); let r2 = in_range.clamp_ref(&min, &max); let clamped2 = Float::with_val(53, r2); assert_eq!(clamped2, 0.5);
pub fn recip(self) -> Self
[src]
pub fn recip(self) -> Self
Computes the reciprocal, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, -0.25); let recip = f.recip(); assert_eq!(recip, -4.0);
pub fn recip_mut(&mut self)
[src]
pub fn recip_mut(&mut self)
Computes the reciprocal, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, -0.25); f.recip_mut(); assert_eq!(f, -4.0);
pub fn recip_round(&mut self, round: Round) -> Ordering
[src]
pub fn recip_round(&mut self, round: Round) -> Ordering
Computes the reciprocal, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 5 in binary is 101 let mut f = Float::with_val(4, -5.0); // 1/5 in binary is 0.00110011... // 1/5 is rounded to 0.203125 (0.001101). let dir = f.recip_round(Round::Nearest); assert_eq!(f, -0.203125); assert_eq!(dir, Ordering::Less);
pub fn recip_ref(&self) -> RecipIncomplete
[src]
pub fn recip_ref(&self) -> RecipIncomplete
Computes the reciprocal.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.25); let r = f.recip_ref(); let recip = Float::with_val(53, r); assert_eq!(recip, -4.0);
pub fn min(self, other: &Self) -> Self
[src]
pub fn min(self, other: &Self) -> Self
Finds the minimum, rounding to the nearest.
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, -2); let min = a.min(&b); assert_eq!(min, -2);
pub fn min_mut(&mut self, other: &Self)
[src]
pub fn min_mut(&mut self, other: &Self)
Finds the minimum, rounding to the nearest.
Examples
use rug::Float; let mut a = Float::with_val(53, 5.2); let b = Float::with_val(53, -2); a.min_mut(&b); assert_eq!(a, -2);
pub fn min_round(&mut self, other: &Self, round: Round) -> Ordering
[src]
pub fn min_round(&mut self, other: &Self, round: Round) -> Ordering
Finds the minimum, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; let mut a = Float::with_val(53, 5.2); let b = Float::with_val(53, -2); let dir = a.min_round(&b, Round::Nearest); assert_eq!(a, -2); assert_eq!(dir, Ordering::Equal);
pub fn min_ref<'a>(&'a self, other: &'a Self) -> MinIncomplete
[src]
pub fn min_ref<'a>(&'a self, other: &'a Self) -> MinIncomplete
Finds the minimum.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, -2); let r = a.min_ref(&b); let min = Float::with_val(53, r); assert_eq!(min, -2);
pub fn max(self, other: &Self) -> Self
[src]
pub fn max(self, other: &Self) -> Self
Finds the maximum, rounding to the nearest.
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, 12.5); let max = a.max(&b); assert_eq!(max, 12.5);
pub fn max_mut(&mut self, other: &Self)
[src]
pub fn max_mut(&mut self, other: &Self)
Finds the maximum, rounding to the nearest.
Examples
use rug::Float; let mut a = Float::with_val(53, 5.2); let b = Float::with_val(53, 12.5); a.max_mut(&b); assert_eq!(a, 12.5);
pub fn max_round(&mut self, other: &Self, round: Round) -> Ordering
[src]
pub fn max_round(&mut self, other: &Self, round: Round) -> Ordering
Finds the maximum, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; let mut a = Float::with_val(53, 5.2); let b = Float::with_val(53, 12.5); let dir = a.max_round(&b, Round::Nearest); assert_eq!(a, 12.5); assert_eq!(dir, Ordering::Equal);
pub fn max_ref<'a>(&'a self, other: &'a Self) -> MaxIncomplete
[src]
pub fn max_ref<'a>(&'a self, other: &'a Self) -> MaxIncomplete
Finds the maximum.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, 12.5); let r = a.max_ref(&b); let max = Float::with_val(53, r); assert_eq!(max, 12.5);
pub fn positive_diff(self, other: &Self) -> Self
[src]
pub fn positive_diff(self, other: &Self) -> Self
Computes the positive difference between self
and
other
, rounding to the nearest.
The positive difference is self
− other
if self
>
other
, zero if self
≤ other
, or NaN if any operand
is NaN.
Examples
use rug::Float; let a = Float::with_val(53, 12.5); let b = Float::with_val(53, 7.3); let diff1 = a.positive_diff(&b); assert_eq!(diff1, 5.2); let diff2 = diff1.positive_diff(&b); assert_eq!(diff2, 0);
pub fn positive_diff_mut(&mut self, other: &Self)
[src]
pub fn positive_diff_mut(&mut self, other: &Self)
Computes the positive difference between self
and
other
, rounding to the nearest.
The positive difference is self
− other
if self
>
other
, zero if self
≤ other
, or NaN if any operand
is NaN.
Examples
use rug::Float; let mut a = Float::with_val(53, 12.5); let b = Float::with_val(53, 7.3); a.positive_diff_mut(&b); assert_eq!(a, 5.2); a.positive_diff_mut(&b); assert_eq!(a, 0);
pub fn positive_diff_round(&mut self, other: &Self, round: Round) -> Ordering
[src]
pub fn positive_diff_round(&mut self, other: &Self, round: Round) -> Ordering
Computes the positive difference between self
and
other
, applying the specified rounding method.
The positive difference is self
− other
if self
>
other
, zero if self
≤ other
, or NaN if any operand
is NaN.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; let mut a = Float::with_val(53, 12.5); let b = Float::with_val(53, 7.3); let dir = a.positive_diff_round(&b, Round::Nearest); assert_eq!(a, 5.2); assert_eq!(dir, Ordering::Equal); let dir = a.positive_diff_round(&b, Round::Nearest); assert_eq!(a, 0); assert_eq!(dir, Ordering::Equal);
pub fn positive_diff_ref<'a>(
&'a self,
other: &'a Self
) -> PositiveDiffIncomplete
[src]
pub fn positive_diff_ref<'a>(
&'a self,
other: &'a Self
) -> PositiveDiffIncomplete
Computes the positive difference.
The positive difference is self
− other
if self
>
other
, zero if self
≤ other
, or NaN if any operand
is NaN.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let a = Float::with_val(53, 12.5); let b = Float::with_val(53, 7.3); let rab = a.positive_diff_ref(&b); let ab = Float::with_val(53, rab); assert_eq!(ab, 5.2); let rba = b.positive_diff_ref(&a); let ba = Float::with_val(53, rba); assert_eq!(ba, 0);
pub fn ln(self) -> Self
[src]
pub fn ln(self) -> Self
Computes the natural logarithm, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let ln = f.ln(); let expected = 0.4055_f64; assert!((ln - expected).abs() < 0.0001);
pub fn ln_mut(&mut self)
[src]
pub fn ln_mut(&mut self)
Computes the natural logarithm, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.5); f.ln_mut(); let expected = 0.4055_f64; assert!((f - expected).abs() < 0.0001);
pub fn ln_round(&mut self, round: Round) -> Ordering
[src]
pub fn ln_round(&mut self, round: Round) -> Ordering
Computes the natural logarithm, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5); // ln(1.5) = 0.4055 // using 4 significant bits: 0.40625 let dir = f.ln_round(Round::Nearest); assert_eq!(f, 0.40625); assert_eq!(dir, Ordering::Greater);
pub fn ln_ref(&self) -> LnIncomplete
[src]
pub fn ln_ref(&self) -> LnIncomplete
Computes the natural logarithm.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let ln = Float::with_val(53, f.ln_ref()); let expected = 0.4055_f64; assert!((ln - expected).abs() < 0.0001);
pub fn ln_u(u: u32) -> LnUIncomplete
[src]
pub fn ln_u(u: u32) -> LnUIncomplete
Computes the natural logarithm of u
.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let l = Float::ln_u(3); let f = Float::with_val(53, l); let expected = 1.0986f64; assert!((f - expected).abs() < 0.0001);
pub fn log2(self) -> Self
[src]
pub fn log2(self) -> Self
Computes the logarithm to base 2, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log2 = f.log2(); let expected = 0.5850_f64; assert!((log2 - expected).abs() < 0.0001);
pub fn log2_mut(&mut self)
[src]
pub fn log2_mut(&mut self)
Computes the logarithm to base 2, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.5); f.log2_mut(); let expected = 0.5850_f64; assert!((f - expected).abs() < 0.0001);
pub fn log2_round(&mut self, round: Round) -> Ordering
[src]
pub fn log2_round(&mut self, round: Round) -> Ordering
Computes the logarithm to base 2, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5); // log2(1.5) = 0.5850 // using 4 significant bits: 0.5625 let dir = f.log2_round(Round::Nearest); assert_eq!(f, 0.5625); assert_eq!(dir, Ordering::Less);
pub fn log2_ref(&self) -> Log2Incomplete
[src]
pub fn log2_ref(&self) -> Log2Incomplete
Computes the logarithm to base 2.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log2 = Float::with_val(53, f.log2_ref()); let expected = 0.5850_f64; assert!((log2 - expected).abs() < 0.0001);
pub fn log10(self) -> Self
[src]
pub fn log10(self) -> Self
Computes the logarithm to base 10, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log10 = f.log10(); let expected = 0.1761_f64; assert!((log10 - expected).abs() < 0.0001);
pub fn log10_mut(&mut self)
[src]
pub fn log10_mut(&mut self)
Computes the logarithm to base 10, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.5); f.log10_mut(); let expected = 0.1761_f64; assert!((f - expected).abs() < 0.0001);
pub fn log10_round(&mut self, round: Round) -> Ordering
[src]
pub fn log10_round(&mut self, round: Round) -> Ordering
Computes the logarithm to base 10, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5); // log10(1.5) = 0.1761 // using 4 significant bits: 0.171875 let dir = f.log10_round(Round::Nearest); assert_eq!(f, 0.171875); assert_eq!(dir, Ordering::Less);
pub fn log10_ref(&self) -> Log10Incomplete
[src]
pub fn log10_ref(&self) -> Log10Incomplete
Computes the logarithm to base 10.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log10 = Float::with_val(53, f.log10_ref()); let expected = 0.1761_f64; assert!((log10 - expected).abs() < 0.0001);
pub fn exp(self) -> Self
[src]
pub fn exp(self) -> Self
Computes the exponential, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp = f.exp(); let expected = 4.4817_f64; assert!((exp - expected).abs() < 0.0001);
pub fn exp_mut(&mut self)
[src]
pub fn exp_mut(&mut self)
Computes the exponential, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.5); f.exp_mut(); let expected = 4.4817_f64; assert!((f - expected).abs() < 0.0001);
pub fn exp_round(&mut self, round: Round) -> Ordering
[src]
pub fn exp_round(&mut self, round: Round) -> Ordering
Computes the exponential, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5); // exp(1.5) = 4.4817 // using 4 significant bits: 4.5 let dir = f.exp_round(Round::Nearest); assert_eq!(f, 4.5); assert_eq!(dir, Ordering::Greater);
pub fn exp_ref(&self) -> ExpIncomplete
[src]
pub fn exp_ref(&self) -> ExpIncomplete
Computes the exponential.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp = Float::with_val(53, f.exp_ref()); let expected = 4.4817_f64; assert!((exp - expected).abs() < 0.0001);
pub fn exp2(self) -> Self
[src]
pub fn exp2(self) -> Self
Computes 2 to the power of self
, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp2 = f.exp2(); let expected = 2.8284_f64; assert!((exp2 - expected).abs() < 0.0001);
pub fn exp2_mut(&mut self)
[src]
pub fn exp2_mut(&mut self)
Computes 2 to the power of self
, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.5); f.exp2_mut(); let expected = 2.8284_f64; assert!((f - expected).abs() < 0.0001);
pub fn exp2_round(&mut self, round: Round) -> Ordering
[src]
pub fn exp2_round(&mut self, round: Round) -> Ordering
Computes 2 to the power of self
, applying the specified
rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5); // exp2(1.5) = 2.8284 // using 4 significant bits: 2.75 let dir = f.exp2_round(Round::Nearest); assert_eq!(f, 2.75); assert_eq!(dir, Ordering::Less);
pub fn exp2_ref(&self) -> Exp2Incomplete
[src]
pub fn exp2_ref(&self) -> Exp2Incomplete
Computes 2 to the power of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp2 = Float::with_val(53, f.exp2_ref()); let expected = 2.8284_f64; assert!((exp2 - expected).abs() < 0.0001);
pub fn exp10(self) -> Self
[src]
pub fn exp10(self) -> Self
Computes 10 to the power of self
, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp10 = f.exp10(); let expected = 31.6228_f64; assert!((exp10 - expected).abs() < 0.0001);
pub fn exp10_mut(&mut self)
[src]
pub fn exp10_mut(&mut self)
Computes 10 to the power of self
, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.5); f.exp10_mut(); let expected = 31.6228_f64; assert!((f - expected).abs() < 0.0001);
pub fn exp10_round(&mut self, round: Round) -> Ordering
[src]
pub fn exp10_round(&mut self, round: Round) -> Ordering
Computes 10 to the power of self
, applying the specified
rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5); // exp10(1.5) = 31.6228 // using 4 significant bits: 32 let dir = f.exp10_round(Round::Nearest); assert_eq!(f, 32); assert_eq!(dir, Ordering::Greater);
pub fn exp10_ref(&self) -> Exp10Incomplete
[src]
pub fn exp10_ref(&self) -> Exp10Incomplete
Computes 10 to the power of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp10 = Float::with_val(53, f.exp10_ref()); let expected = 31.6228_f64; assert!((exp10 - expected).abs() < 0.0001);
pub fn sin(self) -> Self
[src]
pub fn sin(self) -> Self
Computes the sine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sin = f.sin(); let expected = 0.9490_f64; assert!((sin - expected).abs() < 0.0001);
pub fn sin_mut(&mut self)
[src]
pub fn sin_mut(&mut self)
Computes the sine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.sin_mut(); let expected = 0.9490_f64; assert!((f - expected).abs() < 0.0001);
pub fn sin_round(&mut self, round: Round) -> Ordering
[src]
pub fn sin_round(&mut self, round: Round) -> Ordering
Computes the sine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // sin(1.25) = 0.9490 // using 4 significant bits: 0.9375 let dir = f.sin_round(Round::Nearest); assert_eq!(f, 0.9375); assert_eq!(dir, Ordering::Less);
pub fn sin_ref(&self) -> SinIncomplete
[src]
pub fn sin_ref(&self) -> SinIncomplete
Computes the sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sin = Float::with_val(53, f.sin_ref()); let expected = 0.9490_f64; assert!((sin - expected).abs() < 0.0001);
pub fn cos(self) -> Self
[src]
pub fn cos(self) -> Self
Computes the cosine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cos = f.cos(); let expected = 0.3153_f64; assert!((cos - expected).abs() < 0.0001);
pub fn cos_mut(&mut self)
[src]
pub fn cos_mut(&mut self)
Computes the cosine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.cos_mut(); let expected = 0.3153_f64; assert!((f - expected).abs() < 0.0001);
pub fn cos_round(&mut self, round: Round) -> Ordering
[src]
pub fn cos_round(&mut self, round: Round) -> Ordering
Computes the cosine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // cos(1.25) = 0.3153 // using 4 significant bits: 0.3125 let dir = f.cos_round(Round::Nearest); assert_eq!(f, 0.3125); assert_eq!(dir, Ordering::Less);
pub fn cos_ref(&self) -> CosIncomplete
[src]
pub fn cos_ref(&self) -> CosIncomplete
Computes the cosine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cos = Float::with_val(53, f.cos_ref()); let expected = 0.3153_f64; assert!((cos - expected).abs() < 0.0001);
pub fn tan(self) -> Self
[src]
pub fn tan(self) -> Self
Computes the tangent, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tan = f.tan(); let expected = 3.0096_f64; assert!((tan - expected).abs() < 0.0001);
pub fn tan_mut(&mut self)
[src]
pub fn tan_mut(&mut self)
Computes the tangent, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.tan_mut(); let expected = 3.0096_f64; assert!((f - expected).abs() < 0.0001);
pub fn tan_round(&mut self, round: Round) -> Ordering
[src]
pub fn tan_round(&mut self, round: Round) -> Ordering
Computes the tangent, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // tan(1.25) = 3.0096 // using 4 significant bits: 3.0 let dir = f.tan_round(Round::Nearest); assert_eq!(f, 3.0); assert_eq!(dir, Ordering::Less);
pub fn tan_ref(&self) -> TanIncomplete
[src]
pub fn tan_ref(&self) -> TanIncomplete
Computes the tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tan = Float::with_val(53, f.tan_ref()); let expected = 3.0096_f64; assert!((tan - expected).abs() < 0.0001);
pub fn sin_cos(self, cos: Self) -> (Self, Self)
[src]
pub fn sin_cos(self, cos: Self) -> (Self, Self)
Computes the sine and cosine of self
, rounding to the
nearest.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let (sin, cos) = f.sin_cos(Float::new(53)); let expected_sin = 0.9490_f64; let expected_cos = 0.3153_f64; assert!((sin - expected_sin).abs() < 0.0001); assert!((cos - expected_cos).abs() < 0.0001);
pub fn sin_cos_mut(&mut self, cos: &mut Self)
[src]
pub fn sin_cos_mut(&mut self, cos: &mut Self)
Computes the sine and cosine of self
, rounding to the
nearest.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Float; let mut sin = Float::with_val(53, 1.25); let mut cos = Float::new(53); sin.sin_cos_mut(&mut cos); let expected_sin = 0.9490_f64; let expected_cos = 0.3153_f64; assert!((sin - expected_sin).abs() < 0.0001); assert!((cos - expected_cos).abs() < 0.0001);
pub fn sin_cos_round(
&mut self,
cos: &mut Self,
round: Round
) -> (Ordering, Ordering)
[src]
pub fn sin_cos_round(
&mut self,
cos: &mut Self,
round: Round
) -> (Ordering, Ordering)
Computes the sine and cosine of self
, applying the specified
rounding method.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut sin = Float::with_val(4, 1.25); let mut cos = Float::new(4); // sin(1.25) = 0.9490, using 4 significant bits: 0.9375 // cos(1.25) = 0.3153, using 4 significant bits: 0.3125 let (dir_sin, dir_cos) = sin.sin_cos_round(&mut cos, Round::Nearest); assert_eq!(sin, 0.9375); assert_eq!(dir_sin, Ordering::Less); assert_eq!(cos, 0.3125); assert_eq!(dir_cos, Ordering::Less);
pub fn sin_cos_ref(&self) -> SinCosIncomplete
[src]
pub fn sin_cos_ref(&self) -> SinCosIncomplete
Computes the sine and cosine.
Assign<Src> for (Float, Float)
,
Assign<Src> for (&mut Float, &mut Float)
,
AssignRound<Src> for (Float, Float)
and
AssignRound<Src> for (&mut Float, &mut Float)
are implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Float}; use rug::float::Round; use rug::ops::AssignRound; use std::cmp::Ordering; let phase = Float::with_val(53, 1.25); let (mut sin, mut cos) = (Float::new(53), Float::new(53)); let sin_cos = phase.sin_cos_ref(); (&mut sin, &mut cos).assign(sin_cos); let expected_sin = 0.9490_f64; let expected_cos = 0.3153_f64; assert!((sin - expected_sin).abs() < 0.0001); assert!((cos - expected_cos).abs() < 0.0001); // using 4 significant bits: sin = 0.9375 // using 4 significant bits: cos = 0.3125 let (mut sin_4, mut cos_4) = (Float::new(4), Float::new(4)); let sin_cos = phase.sin_cos_ref(); let (dir_sin, dir_cos) = (&mut sin_4, &mut cos_4) .assign_round(sin_cos, Round::Nearest); assert_eq!(sin_4, 0.9375); assert_eq!(dir_sin, Ordering::Less); assert_eq!(cos_4, 0.3125); assert_eq!(dir_cos, Ordering::Less);
pub fn sec(self) -> Self
[src]
pub fn sec(self) -> Self
Computes the secant, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sec = f.sec(); let expected = 3.1714_f64; assert!((sec - expected).abs() < 0.0001);
pub fn sec_mut(&mut self)
[src]
pub fn sec_mut(&mut self)
Computes the secant, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.sec_mut(); let expected = 3.1714_f64; assert!((f - expected).abs() < 0.0001);
pub fn sec_round(&mut self, round: Round) -> Ordering
[src]
pub fn sec_round(&mut self, round: Round) -> Ordering
Computes the secant, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // sec(1.25) = 3.1714 // using 4 significant bits: 3.25 let dir = f.sec_round(Round::Nearest); assert_eq!(f, 3.25); assert_eq!(dir, Ordering::Greater);
pub fn sec_ref(&self) -> SecIncomplete
[src]
pub fn sec_ref(&self) -> SecIncomplete
Computes the secant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sec = Float::with_val(53, f.sec_ref()); let expected = 3.1714_f64; assert!((sec - expected).abs() < 0.0001);
pub fn csc(self) -> Self
[src]
pub fn csc(self) -> Self
Computes the cosecant, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csc = f.csc(); let expected = 1.0538_f64; assert!((csc - expected).abs() < 0.0001);
pub fn csc_mut(&mut self)
[src]
pub fn csc_mut(&mut self)
Computes the cosecant, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.csc_mut(); let expected = 1.0538_f64; assert!((f - expected).abs() < 0.0001);
pub fn csc_round(&mut self, round: Round) -> Ordering
[src]
pub fn csc_round(&mut self, round: Round) -> Ordering
Computes the cosecant, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // csc(1.25) = 1.0538 // using 4 significant bits: 1.0 let dir = f.csc_round(Round::Nearest); assert_eq!(f, 1.0); assert_eq!(dir, Ordering::Less);
pub fn csc_ref(&self) -> CscIncomplete
[src]
pub fn csc_ref(&self) -> CscIncomplete
Computes the cosecant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csc = Float::with_val(53, f.csc_ref()); let expected = 1.0538_f64; assert!((csc - expected).abs() < 0.0001);
pub fn cot(self) -> Self
[src]
pub fn cot(self) -> Self
Computes the cotangent, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cot = f.cot(); let expected = 0.3323_f64; assert!((cot - expected).abs() < 0.0001);
pub fn cot_mut(&mut self)
[src]
pub fn cot_mut(&mut self)
Computes the cotangent, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.cot_mut(); let expected = 0.3323_f64; assert!((f - expected).abs() < 0.0001);
pub fn cot_round(&mut self, round: Round) -> Ordering
[src]
pub fn cot_round(&mut self, round: Round) -> Ordering
Computes the cotangent, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // cot(1.25) = 0.3323 // using 4 significant bits: 0.34375 let dir = f.cot_round(Round::Nearest); assert_eq!(f, 0.34375); assert_eq!(dir, Ordering::Greater);
pub fn cot_ref(&self) -> CotIncomplete
[src]
pub fn cot_ref(&self) -> CotIncomplete
Computes the cotangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cot = Float::with_val(53, f.cot_ref()); let expected = 0.3323_f64; assert!((cot - expected).abs() < 0.0001);
pub fn asin(self) -> Self
[src]
pub fn asin(self) -> Self
Computes the arc-sine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let asin = f.asin(); let expected = -0.8481_f64; assert!((asin - expected).abs() < 0.0001);
pub fn asin_mut(&mut self)
[src]
pub fn asin_mut(&mut self)
Computes the arc-sine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, -0.75); f.asin_mut(); let expected = -0.8481_f64; assert!((f - expected).abs() < 0.0001);
pub fn asin_round(&mut self, round: Round) -> Ordering
[src]
pub fn asin_round(&mut self, round: Round) -> Ordering
Computes the arc-sine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, -0.75); // asin(-0.75) = -0.8481 // using 4 significant bits: -0.875 let dir = f.asin_round(Round::Nearest); assert_eq!(f, -0.875); assert_eq!(dir, Ordering::Less);
pub fn asin_ref(&self) -> AsinIncomplete
[src]
pub fn asin_ref(&self) -> AsinIncomplete
Computes the arc-sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let asin = Float::with_val(53, f.asin_ref()); let expected = -0.8481_f64; assert!((asin - expected).abs() < 0.0001);
pub fn acos(self) -> Self
[src]
pub fn acos(self) -> Self
Computes the arc-cosine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let acos = f.acos(); let expected = 2.4189_f64; assert!((acos - expected).abs() < 0.0001);
pub fn acos_mut(&mut self)
[src]
pub fn acos_mut(&mut self)
Computes the arc-cosine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, -0.75); f.acos_mut(); let expected = 2.4189_f64; assert!((f - expected).abs() < 0.0001);
pub fn acos_round(&mut self, round: Round) -> Ordering
[src]
pub fn acos_round(&mut self, round: Round) -> Ordering
Computes the arc-cosine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, -0.75); // acos(-0.75) = 2.4189 // using 4 significant bits: 2.5 let dir = f.acos_round(Round::Nearest); assert_eq!(f, 2.5); assert_eq!(dir, Ordering::Greater);
pub fn acos_ref(&self) -> AcosIncomplete
[src]
pub fn acos_ref(&self) -> AcosIncomplete
Computes the arc-cosine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let acos = Float::with_val(53, f.acos_ref()); let expected = 2.4189_f64; assert!((acos - expected).abs() < 0.0001);
pub fn atan(self) -> Self
[src]
pub fn atan(self) -> Self
Computes the arc-tangent, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let atan = f.atan(); let expected = -0.6435_f64; assert!((atan - expected).abs() < 0.0001);
pub fn atan_mut(&mut self)
[src]
pub fn atan_mut(&mut self)
Computes the arc-tangent, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, -0.75); f.atan_mut(); let expected = -0.6435_f64; assert!((f - expected).abs() < 0.0001);
pub fn atan_round(&mut self, round: Round) -> Ordering
[src]
pub fn atan_round(&mut self, round: Round) -> Ordering
Computes the arc-tangent, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, -0.75); // atan(-0.75) = -0.6435 // using 4 significant bits: -0.625 let dir = f.atan_round(Round::Nearest); assert_eq!(f, -0.625); assert_eq!(dir, Ordering::Greater);
pub fn atan_ref(&self) -> AtanIncomplete
[src]
pub fn atan_ref(&self) -> AtanIncomplete
Computes the arc-tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let atan = Float::with_val(53, f.atan_ref()); let expected = -0.6435_f64; assert!((atan - expected).abs() < 0.0001);
pub fn atan2(self, x: &Self) -> Self
[src]
pub fn atan2(self, x: &Self) -> Self
Computes the arc-tangent2 of self
and x
, rounding to
the nearest.
This is similar to the arc-tangent of self / x
, but
has an output range of 2π rather than π.
Examples
use rug::Float; let y = Float::with_val(53, 3.0); let x = Float::with_val(53, -4.0); let atan2 = y.atan2(&x); let expected = 2.4981_f64; assert!((atan2 - expected).abs() < 0.0001);
pub fn atan2_mut(&mut self, x: &Self)
[src]
pub fn atan2_mut(&mut self, x: &Self)
Computes the arc-tangent2 of self
and x
, rounding to
the nearest.
This is similar to the arc-tangent of self / x
, but
has an output range of 2π rather than π.
Examples
use rug::Float; let mut y = Float::with_val(53, 3.0); let x = Float::with_val(53, -4.0); y.atan2_mut(&x); let expected = 2.4981_f64; assert!((y - expected).abs() < 0.0001);
pub fn atan2_round(&mut self, x: &Self, round: Round) -> Ordering
[src]
pub fn atan2_round(&mut self, x: &Self, round: Round) -> Ordering
Computes the arc-tangent2 of self
and x
, applying the
specified rounding method.
This is similar to the arc-tangent of self / x
, but
has an output range of 2π rather than π.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut y = Float::with_val(4, 3.0); let x = Float::with_val(4, -4.0); // atan2(3.0, -4.0) = 2.4981 // using 4 significant bits: 2.5 let dir = y.atan2_round(&x, Round::Nearest); assert_eq!(y, 2.5); assert_eq!(dir, Ordering::Greater);
pub fn atan2_ref<'a>(&'a self, x: &'a Self) -> Atan2Incomplete
[src]
pub fn atan2_ref<'a>(&'a self, x: &'a Self) -> Atan2Incomplete
Computes the arc-tangent.
This is similar to the arc-tangent of self / x
, but
has an output range of 2π rather than π.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let y = Float::with_val(53, 3.0); let x = Float::with_val(53, -4.0); let r = y.atan2_ref(&x); let atan2 = Float::with_val(53, r); let expected = 2.4981_f64; assert!((atan2 - expected).abs() < 0.0001);
pub fn sinh(self) -> Self
[src]
pub fn sinh(self) -> Self
Computes the hyperbolic sine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sinh = f.sinh(); let expected = 1.6019_f64; assert!((sinh - expected).abs() < 0.0001);
pub fn sinh_mut(&mut self)
[src]
pub fn sinh_mut(&mut self)
Computes the hyperbolic sine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.sinh_mut(); let expected = 1.6019_f64; assert!((f - expected).abs() < 0.0001);
pub fn sinh_round(&mut self, round: Round) -> Ordering
[src]
pub fn sinh_round(&mut self, round: Round) -> Ordering
Computes the hyperbolic sine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // sinh(1.25) = 1.6019 // using 4 significant bits: 1.625 let dir = f.sinh_round(Round::Nearest); assert_eq!(f, 1.625); assert_eq!(dir, Ordering::Greater);
pub fn sinh_ref(&self) -> SinhIncomplete
[src]
pub fn sinh_ref(&self) -> SinhIncomplete
Computes the hyperbolic sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sinh = Float::with_val(53, f.sinh_ref()); let expected = 1.6019_f64; assert!((sinh - expected).abs() < 0.0001);
pub fn cosh(self) -> Self
[src]
pub fn cosh(self) -> Self
Computes the hyperbolic cosine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cosh = f.cosh(); let expected = 1.8884_f64; assert!((cosh - expected).abs() < 0.0001);
pub fn cosh_mut(&mut self)
[src]
pub fn cosh_mut(&mut self)
Computes the hyperbolic cosine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.cosh_mut(); let expected = 1.8884_f64; assert!((f - expected).abs() < 0.0001);
pub fn cosh_round(&mut self, round: Round) -> Ordering
[src]
pub fn cosh_round(&mut self, round: Round) -> Ordering
Computes the hyperbolic cosine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // cosh(1.25) = 1.8884 // using 4 significant bits: 1.875 let dir = f.cosh_round(Round::Nearest); assert_eq!(f, 1.875); assert_eq!(dir, Ordering::Less);
pub fn cosh_ref(&self) -> CoshIncomplete
[src]
pub fn cosh_ref(&self) -> CoshIncomplete
Computes the hyperbolic cosine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cosh = Float::with_val(53, f.cosh_ref()); let expected = 1.8884_f64; assert!((cosh - expected).abs() < 0.0001);
pub fn tanh(self) -> Self
[src]
pub fn tanh(self) -> Self
Computes the hyperbolic tangent, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tanh = f.tanh(); let expected = 0.8483_f64; assert!((tanh - expected).abs() < 0.0001);
pub fn tanh_mut(&mut self)
[src]
pub fn tanh_mut(&mut self)
Computes the hyperbolic tangent, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.tanh_mut(); let expected = 0.8483_f64; assert!((f - expected).abs() < 0.0001);
pub fn tanh_round(&mut self, round: Round) -> Ordering
[src]
pub fn tanh_round(&mut self, round: Round) -> Ordering
Computes the hyperbolic tangent, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // tanh(1.25) = 0.8483 // using 4 significant bits: 0.875 let dir = f.tanh_round(Round::Nearest); assert_eq!(f, 0.875); assert_eq!(dir, Ordering::Greater);
pub fn tanh_ref(&self) -> TanhIncomplete
[src]
pub fn tanh_ref(&self) -> TanhIncomplete
Computes the hyperbolic tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tanh = Float::with_val(53, f.tanh_ref()); let expected = 0.8483_f64; assert!((tanh - expected).abs() < 0.0001);
pub fn sinh_cosh(self, cos: Self) -> (Self, Self)
[src]
pub fn sinh_cosh(self, cos: Self) -> (Self, Self)
Computes the hyperbolic sine and cosine of self
,
rounding to the nearest.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let (sinh, cosh) = f.sinh_cosh(Float::new(53)); let expected_sinh = 1.6019_f64; let expected_cosh = 1.8884_f64; assert!((sinh - expected_sinh).abs() < 0.0001); assert!((cosh - expected_cosh).abs() < 0.0001);
pub fn sinh_cosh_mut(&mut self, cos: &mut Self)
[src]
pub fn sinh_cosh_mut(&mut self, cos: &mut Self)
Computes the hyperbolic sine and cosine of self
,
rounding to the nearest.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Float; let mut sinh = Float::with_val(53, 1.25); let mut cosh = Float::new(53); sinh.sinh_cosh_mut(&mut cosh); let expected_sinh = 1.6019_f64; let expected_cosh = 1.8884_f64; assert!((sinh - expected_sinh).abs() < 0.0001); assert!((cosh - expected_cosh).abs() < 0.0001);
pub fn sinh_cosh_round(
&mut self,
cos: &mut Self,
round: Round
) -> (Ordering, Ordering)
[src]
pub fn sinh_cosh_round(
&mut self,
cos: &mut Self,
round: Round
) -> (Ordering, Ordering)
Computes the hyperbolic sine and cosine of self
,
applying the specified rounding method.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut sinh = Float::with_val(4, 1.25); let mut cosh = Float::new(4); // sinh(1.25) = 1.6019, using 4 significant bits: 1.625 // cosh(1.25) = 1.8884, using 4 significant bits: 1.875 let (dir_sinh, dir_cosh) = sinh.sinh_cosh_round(&mut cosh, Round::Nearest); assert_eq!(sinh, 1.625); assert_eq!(dir_sinh, Ordering::Greater); assert_eq!(cosh, 1.875); assert_eq!(dir_cosh, Ordering::Less);
pub fn sinh_cosh_ref(&self) -> SinhCoshIncomplete
[src]
pub fn sinh_cosh_ref(&self) -> SinhCoshIncomplete
Computes the hyperbolic sine and cosine.
Assign<Src> for (Float, Float)
,
Assign<Src> for (&mut Float, &mut Float)
,
AssignRound<Src> for (Float, Float)
and
AssignRound<Src> for (&mut Float, &mut Float)
are implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Float}; use rug::float::Round; use rug::ops::AssignRound; use std::cmp::Ordering; let phase = Float::with_val(53, 1.25); let (mut sinh, mut cosh) = (Float::new(53), Float::new(53)); let sinh_cosh = phase.sinh_cosh_ref(); (&mut sinh, &mut cosh).assign(sinh_cosh); let expected_sinh = 1.6019_f64; let expected_cosh = 1.8884_f64; assert!((sinh - expected_sinh).abs() < 0.0001); assert!((cosh - expected_cosh).abs() < 0.0001); // using 4 significant bits: sin = 1.625 // using 4 significant bits: cos = 1.875 let (mut sinh_4, mut cosh_4) = (Float::new(4), Float::new(4)); let sinh_cosh = phase.sinh_cosh_ref(); let (dir_sinh, dir_cosh) = (&mut sinh_4, &mut cosh_4) .assign_round(sinh_cosh, Round::Nearest); assert_eq!(sinh_4, 1.625); assert_eq!(dir_sinh, Ordering::Greater); assert_eq!(cosh_4, 1.875); assert_eq!(dir_cosh, Ordering::Less);
pub fn sech(self) -> Self
[src]
pub fn sech(self) -> Self
Computes the hyperbolic secant, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sech = f.sech(); let expected = 0.5295_f64; assert!((sech - expected).abs() < 0.0001);
pub fn sech_mut(&mut self)
[src]
pub fn sech_mut(&mut self)
Computes the hyperbolic secant, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.sech_mut(); let expected = 0.5295_f64; assert!((f - expected).abs() < 0.0001);
pub fn sech_round(&mut self, round: Round) -> Ordering
[src]
pub fn sech_round(&mut self, round: Round) -> Ordering
Computes the hyperbolic secant, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // sech(1.25) = 0.5295 // using 4 significant bits: 0.5 let dir = f.sech_round(Round::Nearest); assert_eq!(f, 0.5); assert_eq!(dir, Ordering::Less);
pub fn sech_ref(&self) -> SechIncomplete
[src]
pub fn sech_ref(&self) -> SechIncomplete
Computes the hyperbolic secant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sech = Float::with_val(53, f.sech_ref()); let expected = 0.5295_f64; assert!((sech - expected).abs() < 0.0001);
pub fn csch(self) -> Self
[src]
pub fn csch(self) -> Self
Computes the hyperbolic cosecant, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csch = f.csch(); let expected = 0.6243_f64; assert!((csch - expected).abs() < 0.0001);
pub fn csch_mut(&mut self)
[src]
pub fn csch_mut(&mut self)
Computes the hyperbolic cosecant, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.csch_mut(); let expected = 0.6243_f64; assert!((f - expected).abs() < 0.0001);
pub fn csch_round(&mut self, round: Round) -> Ordering
[src]
pub fn csch_round(&mut self, round: Round) -> Ordering
Computes the hyperbolic cosecant, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // csch(1.25) = 0.6243 // using 4 significant bits: 0.625 let dir = f.csch_round(Round::Nearest); assert_eq!(f, 0.625); assert_eq!(dir, Ordering::Greater);
pub fn csch_ref(&self) -> CschIncomplete
[src]
pub fn csch_ref(&self) -> CschIncomplete
Computes the hyperbolic cosecant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csch = Float::with_val(53, f.csch_ref()); let expected = 0.6243_f64; assert!((csch - expected).abs() < 0.0001);
pub fn coth(self) -> Self
[src]
pub fn coth(self) -> Self
Computes the hyperbolic cotangent, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let coth = f.coth(); let expected = 1.1789_f64; assert!((coth - expected).abs() < 0.0001);
pub fn coth_mut(&mut self)
[src]
pub fn coth_mut(&mut self)
Computes the hyperbolic cotangent, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.coth_mut(); let expected = 1.1789_f64; assert!((f - expected).abs() < 0.0001);
pub fn coth_round(&mut self, round: Round) -> Ordering
[src]
pub fn coth_round(&mut self, round: Round) -> Ordering
Computes the hyperbolic cotangent, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // coth(1.25) = 1.1789 // using 4 significant bits: 1.125 let dir = f.coth_round(Round::Nearest); assert_eq!(f, 1.125); assert_eq!(dir, Ordering::Less);
pub fn coth_ref(&self) -> CothIncomplete
[src]
pub fn coth_ref(&self) -> CothIncomplete
Computes the hyperbolic cotangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let coth = Float::with_val(53, f.coth_ref()); let expected = 1.1789_f64; assert!((coth - expected).abs() < 0.0001);
pub fn asinh(self) -> Self
[src]
pub fn asinh(self) -> Self
Computes the inverse hyperbolic sine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let asinh = f.asinh(); let expected = 1.0476_f64; assert!((asinh - expected).abs() < 0.0001);
pub fn asinh_mut(&mut self)
[src]
pub fn asinh_mut(&mut self)
Computes the inverse hyperbolic sine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.asinh_mut(); let expected = 1.0476_f64; assert!((f - expected).abs() < 0.0001);
pub fn asinh_round(&mut self, round: Round) -> Ordering
[src]
pub fn asinh_round(&mut self, round: Round) -> Ordering
Computes the inverse hyperbolic sine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // asinh(1.25) = 1.0476 // using 4 significant bits: 1.0 let dir = f.asinh_round(Round::Nearest); assert_eq!(f, 1.0); assert_eq!(dir, Ordering::Less);
pub fn asinh_ref(&self) -> AsinhIncomplete
[src]
pub fn asinh_ref(&self) -> AsinhIncomplete
Computes the inverse hyperbolic sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let asinh = Float::with_val(53, f.asinh_ref()); let expected = 1.0476_f64; assert!((asinh - expected).abs() < 0.0001);
pub fn acosh(self) -> Self
[src]
pub fn acosh(self) -> Self
Computes the inverse hyperbolic cosine, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let acosh = f.acosh(); let expected = 0.6931_f64; assert!((acosh - expected).abs() < 0.0001);
pub fn acosh_mut(&mut self)
[src]
pub fn acosh_mut(&mut self)
Computes the inverse hyperbolic cosine, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.acosh_mut(); let expected = 0.6931_f64; assert!((f - expected).abs() < 0.0001);
pub fn acosh_round(&mut self, round: Round) -> Ordering
[src]
pub fn acosh_round(&mut self, round: Round) -> Ordering
Computes the inverse hyperbolic cosine, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // acosh(1.25) = 0.6931 // using 4 significant bits: 0.6875 let dir = f.acosh_round(Round::Nearest); assert_eq!(f, 0.6875); assert_eq!(dir, Ordering::Less);
pub fn acosh_ref(&self) -> AcoshIncomplete
[src]
pub fn acosh_ref(&self) -> AcoshIncomplete
Computes the inverse hyperbolic cosine
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let acosh = Float::with_val(53, f.acosh_ref()); let expected = 0.6931_f64; assert!((acosh - expected).abs() < 0.0001);
pub fn atanh(self) -> Self
[src]
pub fn atanh(self) -> Self
Computes the inverse hyperbolic tangent, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 0.75); let atanh = f.atanh(); let expected = 0.9730_f64; assert!((atanh - expected).abs() < 0.0001);
pub fn atanh_mut(&mut self)
[src]
pub fn atanh_mut(&mut self)
Computes the inverse hyperbolic tangent, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 0.75); f.atanh_mut(); let expected = 0.9730_f64; assert!((f - expected).abs() < 0.0001);
pub fn atanh_round(&mut self, round: Round) -> Ordering
[src]
pub fn atanh_round(&mut self, round: Round) -> Ordering
Computes the inverse hyperbolic tangent, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 0.75); // atanh(0.75) = 0.9730 // using 4 significant bits: 1.0 let dir = f.atanh_round(Round::Nearest); assert_eq!(f, 1.0); assert_eq!(dir, Ordering::Greater);
pub fn atanh_ref(&self) -> AtanhIncomplete
[src]
pub fn atanh_ref(&self) -> AtanhIncomplete
Computes the inverse hyperbolic tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 0.75); let atanh = Float::with_val(53, f.atanh_ref()); let expected = 0.9730_f64; assert!((atanh - expected).abs() < 0.0001);
pub fn factorial(n: u32) -> FactorialIncomplete
[src]
pub fn factorial(n: u32) -> FactorialIncomplete
Computes the factorial of n.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; // 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 let n = Float::factorial(10); let f = Float::with_val(53, n); assert_eq!(f, 3628800.0);
pub fn ln_1p(self) -> Self
[src]
pub fn ln_1p(self) -> Self
Computes the natural logarithm of one plus self
, rounding to
the nearest.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let ln_1p = f.ln_1p(); let expected = 1.4989_f64 * two_to_m10; assert!((ln_1p - expected).abs() < 0.0001 * two_to_m10);
pub fn ln_1p_mut(&mut self)
[src]
pub fn ln_1p_mut(&mut self)
Computes the natural logarithm of one plus self
, rounding to
the nearest.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let mut f = Float::with_val(53, 1.5 * two_to_m10); f.ln_1p_mut(); let expected = 1.4989_f64 * two_to_m10; assert!((f - expected).abs() < 0.0001 * two_to_m10);
pub fn ln_1p_round(&mut self, round: Round) -> Ordering
[src]
pub fn ln_1p_round(&mut self, round: Round) -> Ordering
Computes the natural logarithm of one plus self
, applying
the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; let two_to_m10 = (-10f64).exp2(); // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5 * two_to_m10); // ln_1p(1.5 * 2 ^ -10) = 1.4989 * 2 ^ -10 // using 4 significant bits: 1.5 * 2 ^ -10 let dir = f.ln_1p_round(Round::Nearest); assert_eq!(f, 1.5 * two_to_m10); assert_eq!(dir, Ordering::Greater);
pub fn ln_1p_ref(&self) -> Ln1pIncomplete
[src]
pub fn ln_1p_ref(&self) -> Ln1pIncomplete
Computes the natural logorithm of one plus the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let ln_1p = Float::with_val(53, f.ln_1p_ref()); let expected = 1.4989_f64 * two_to_m10; assert!((ln_1p - expected).abs() < 0.0001 * two_to_m10);
pub fn exp_m1(self) -> Self
[src]
pub fn exp_m1(self) -> Self
Subtracts one from the exponential of self
, rounding to the
nearest.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let exp_m1 = f.exp_m1(); let expected = 1.5011_f64 * two_to_m10; assert!((exp_m1 - expected).abs() < 0.0001 * two_to_m10);
pub fn exp_m1_mut(&mut self)
[src]
pub fn exp_m1_mut(&mut self)
Subtracts one from the exponential of self
, rounding to the
nearest.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let mut f = Float::with_val(53, 1.5 * two_to_m10); f.exp_m1_mut(); let expected = 1.5011_f64 * two_to_m10; assert!((f - expected).abs() < 0.0001 * two_to_m10);
pub fn exp_m1_round(&mut self, round: Round) -> Ordering
[src]
pub fn exp_m1_round(&mut self, round: Round) -> Ordering
Subtracts one from the exponential of self
, applying the
specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; let two_to_m10 = (-10f64).exp2(); // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.5 * two_to_m10); // exp_m1(1.5 * 2 ^ -10) = 1.5011 * 2 ^ -10 // using 4 significant bits: 1.5 * 2 ^ -10 let dir = f.exp_m1_round(Round::Nearest); assert_eq!(f, 1.5 * two_to_m10); assert_eq!(dir, Ordering::Less);
pub fn exp_m1_ref(&self) -> ExpM1Incomplete
[src]
pub fn exp_m1_ref(&self) -> ExpM1Incomplete
Computes one less than the exponential of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let exp_m1 = Float::with_val(53, f.exp_m1_ref()); let expected = 1.5011_f64 * two_to_m10; assert!((exp_m1 - expected).abs() < 0.0001 * two_to_m10);
pub fn eint(self) -> Self
[src]
pub fn eint(self) -> Self
Computes the exponential integral, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let eint = f.eint(); let expected = 2.5810_f64; assert!((eint - expected).abs() < 0.0001);
pub fn eint_mut(&mut self)
[src]
pub fn eint_mut(&mut self)
Computes the exponential integral, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.eint_mut(); let expected = 2.5810_f64; assert!((f - expected).abs() < 0.0001);
pub fn eint_round(&mut self, round: Round) -> Ordering
[src]
pub fn eint_round(&mut self, round: Round) -> Ordering
Computes the exponential integral, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // eint(1.25) = 2.5810 // using 4 significant bits: 2.5 let dir = f.eint_round(Round::Nearest); assert_eq!(f, 2.5); assert_eq!(dir, Ordering::Less);
pub fn eint_ref(&self) -> EintIncomplete
[src]
pub fn eint_ref(&self) -> EintIncomplete
Computes the exponential integral.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let eint = Float::with_val(53, f.eint_ref()); let expected = 2.5810_f64; assert!((eint - expected).abs() < 0.0001);
pub fn li2(self) -> Self
[src]
pub fn li2(self) -> Self
Computes the real part of the dilogarithm of self
, rounding
to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let li2 = f.li2(); let expected = 2.1902_f64; assert!((li2 - expected).abs() < 0.0001);
pub fn li2_mut(&mut self)
[src]
pub fn li2_mut(&mut self)
Computes the real part of the dilogarithm of self
, rounding
to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.li2_mut(); let expected = 2.1902_f64; assert!((f - expected).abs() < 0.0001);
pub fn li2_round(&mut self, round: Round) -> Ordering
[src]
pub fn li2_round(&mut self, round: Round) -> Ordering
Computes the real part of the dilogarithm of self
, applying
the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // li2(1.25) = 2.1902 // using 4 significant bits: 2.25 let dir = f.li2_round(Round::Nearest); assert_eq!(f, 2.25); assert_eq!(dir, Ordering::Greater);
pub fn li2_ref(&self) -> Li2Incomplete
[src]
pub fn li2_ref(&self) -> Li2Incomplete
Computes the real part of the dilogarithm of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let li2 = Float::with_val(53, f.li2_ref()); let expected = 2.1902_f64; assert!((li2 - expected).abs() < 0.0001);
pub fn gamma(self) -> Self
[src]
pub fn gamma(self) -> Self
Computes the value of the gamma function on self
, rounding
to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let gamma = f.gamma(); let expected = 0.9064_f64; assert!((gamma - expected).abs() < 0.0001);
pub fn gamma_mut(&mut self)
[src]
pub fn gamma_mut(&mut self)
Computes the value of the gamma function on self
, rounding
to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.gamma_mut(); let expected = 0.9064_f64; assert!((f - expected).abs() < 0.0001);
pub fn gamma_round(&mut self, round: Round) -> Ordering
[src]
pub fn gamma_round(&mut self, round: Round) -> Ordering
Computes the value of the gamma function on self
, applying
the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // gamma(1.25) = 0.9064 // using 4 significant bits: 0.9375 let dir = f.gamma_round(Round::Nearest); assert_eq!(f, 0.9375); assert_eq!(dir, Ordering::Greater);
pub fn gamma_ref(&self) -> GammaIncomplete
[src]
pub fn gamma_ref(&self) -> GammaIncomplete
Computes the gamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let gamma = Float::with_val(53, f.gamma_ref()); let expected = 0.9064_f64; assert!((gamma - expected).abs() < 0.0001);
pub fn gamma_inc(self, x: &Self) -> Self
[src]
pub fn gamma_inc(self, x: &Self) -> Self
Computes the value of the upper incomplete gamma function
on self
and x
, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let x = Float::with_val(53, 2.5); let gamma_inc = f.gamma_inc(&x); let expected = 0.1116_f64; assert!((gamma_inc - expected).abs() < 0.0001);
pub fn gamma_inc_mut(&mut self, x: &Self)
[src]
pub fn gamma_inc_mut(&mut self, x: &Self)
Computes the value of the upper incomplete gamma function
on self
, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); let x = Float::with_val(53, 2.5); f.gamma_inc_mut(&x); let expected = 0.1116_f64; assert!((f - expected).abs() < 0.0001);
pub fn gamma_inc_round(&mut self, x: &Self, round: Round) -> Ordering
[src]
pub fn gamma_inc_round(&mut self, x: &Self, round: Round) -> Ordering
Computes the value of the upper incomplete gamma function
on self
, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); let x = Float::with_val(53, 2.5); // gamma_inc(1.25, 2.5) = 0.1116 // using 4 significant bits: 0.109375 let dir = f.gamma_inc_round(&x, Round::Nearest); assert_eq!(f, 0.109375); assert_eq!(dir, Ordering::Less);
pub fn gamma_inc_ref<'a>(&'a self, x: &'a Self) -> GammaIncIncomplete
[src]
pub fn gamma_inc_ref<'a>(&'a self, x: &'a Self) -> GammaIncIncomplete
Computes the upper incomplete gamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let x = Float::with_val(53, 2.5); let gamma_inc = Float::with_val(53, f.gamma_inc_ref(&x)); let expected = 0.1116_f64; assert!((gamma_inc - expected).abs() < 0.0001);
pub fn ln_gamma(self) -> Self
[src]
pub fn ln_gamma(self) -> Self
Computes the logarithm of the gamma function on self
,
rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ln_gamma = f.ln_gamma(); let expected = -0.0983_f64; assert!((ln_gamma - expected).abs() < 0.0001);
pub fn ln_gamma_mut(&mut self)
[src]
pub fn ln_gamma_mut(&mut self)
Computes the logarithm of the gamma function on self
,
rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.ln_gamma_mut(); let expected = -0.0983_f64; assert!((f - expected).abs() < 0.0001);
pub fn ln_gamma_round(&mut self, round: Round) -> Ordering
[src]
pub fn ln_gamma_round(&mut self, round: Round) -> Ordering
Computes the logarithm of the gamma function on self
,
applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // ln_gamma(1.25) = -0.0983 // using 4 significant bits: -0.1015625 let dir = f.ln_gamma_round(Round::Nearest); assert_eq!(f, -0.1015625); assert_eq!(dir, Ordering::Less);
pub fn ln_gamma_ref(&self) -> LnGammaIncomplete
[src]
pub fn ln_gamma_ref(&self) -> LnGammaIncomplete
Computes the logarithm of the gamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ln_gamma = Float::with_val(53, f.ln_gamma_ref()); let expected = -0.0983_f64; assert!((ln_gamma - expected).abs() < 0.0001);
pub fn ln_abs_gamma(self) -> (Self, Ordering)
[src]
pub fn ln_abs_gamma(self) -> (Self, Ordering)
Computes the logarithm of the absolute value of the gamma
function on self
, rounding to the nearest.
Returns Ordering::Less
if the gamma function is negative, or
Ordering::Greater
if the gamma function is positive.
Examples
use rug::float::Constant; use rug::Float; use std::cmp::Ordering; // gamma of 1/2 is sqrt(pi) let ln_gamma_64 = Float::with_val(64, Constant::Pi).sqrt().ln(); let f = Float::with_val(53, 0.5); let (ln_gamma, sign) = f.ln_abs_gamma(); // gamma of 1/2 is positive assert_eq!(sign, Ordering::Greater); // check to 53 significant bits assert_eq!(ln_gamma, Float::with_val(53, &ln_gamma_64));
If the gamma function is negative, the sign returned is
Ordering::Less
.
use rug::float::Constant; use rug::Float; use std::cmp::Ordering; // gamma of -1/2 is -2 * sqrt(pi) let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32; let ln_gamma_64 = abs_gamma_64.ln(); let f = Float::with_val(53, -0.5); let (ln_gamma, sign) = f.ln_abs_gamma(); // gamma of -1/2 is negative assert_eq!(sign, Ordering::Less); // check to 53 significant bits assert_eq!(ln_gamma, Float::with_val(53, &ln_gamma_64));
pub fn ln_abs_gamma_mut(&mut self) -> Ordering
[src]
pub fn ln_abs_gamma_mut(&mut self) -> Ordering
Computes the logarithm of the absolute value of the gamma
function on self
, rounding to the nearest.
Returns Ordering::Less
if the gamma function is negative, or
Ordering::Greater
if the gamma function is positive.
Examples
use rug::float::Constant; use rug::Float; use std::cmp::Ordering; // gamma of -1/2 is -2 * sqrt(pi) let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32; let ln_gamma_64 = abs_gamma_64.ln(); let mut f = Float::with_val(53, -0.5); let sign = f.ln_abs_gamma_mut(); // gamma of -1/2 is negative assert_eq!(sign, Ordering::Less); // check to 53 significant bits assert_eq!(f, Float::with_val(53, &ln_gamma_64));
pub fn ln_abs_gamma_round(&mut self, round: Round) -> (Ordering, Ordering)
[src]
pub fn ln_abs_gamma_round(&mut self, round: Round) -> (Ordering, Ordering)
Computes the logarithm of the absolute value of the gamma
function on self
, applying the specified rounding method.
The returned tuple contains:
- The logarithm of the absolute value of the gamma function.
- The rounding direction.
Examples
use rug::float::{Constant, Round}; use rug::Float; use std::cmp::Ordering; // gamma of -1/2 is -2 * sqrt(pi) let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32; let ln_gamma_64 = abs_gamma_64.ln(); let mut f = Float::with_val(53, -0.5); let (sign, dir) = f.ln_abs_gamma_round(Round::Nearest); // gamma of -1/2 is negative assert_eq!(sign, Ordering::Less); // check is correct to 53 significant bits let (check, check_dir) = Float::with_val_round(53, &ln_gamma_64, Round::Nearest); assert_eq!(f, check); assert_eq!(dir, check_dir);
pub fn ln_abs_gamma_ref(&self) -> LnAbsGammaIncomplete
[src]
pub fn ln_abs_gamma_ref(&self) -> LnAbsGammaIncomplete
Computes the logarithm of the absolute value of the gamma
function on val
.
Assign<Src> for (Float, Ordering)
,
Assign<Src> for (&mut Float, &mut Ordering)
,
AssignRound<Src> for (Float, Ordering)
and
AssignRound<Src> for (&mut Float, &mut Ordering)
are implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::float::Constant; use rug::{Assign, Float}; use std::cmp::Ordering; let neg1_2 = Float::with_val(53, -0.5); // gamma of -1/2 is -2 * sqrt(pi) let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32; let ln_gamma_64 = abs_gamma_64.ln(); // Assign rounds to the nearest let r = neg1_2.ln_abs_gamma_ref(); let (mut f, mut sign) = (Float::new(53), Ordering::Equal); (&mut f, &mut sign).assign(r); // gamma of -1/2 is negative assert_eq!(sign, Ordering::Less); // check to 53 significant bits assert_eq!(f, Float::with_val(53, &ln_gamma_64));
pub fn digamma(self) -> Self
[src]
pub fn digamma(self) -> Self
Computes the value of the Digamma function on self
, rounding
to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let digamma = f.digamma(); let expected = -0.2275_f64; assert!((digamma - expected).abs() < 0.0001);
pub fn digamma_mut(&mut self)
[src]
pub fn digamma_mut(&mut self)
Computes the value of the Digamma function on self
, rounding
to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.digamma_mut(); let expected = -0.2275_f64; assert!((f - expected).abs() < 0.0001);
pub fn digamma_round(&mut self, round: Round) -> Ordering
[src]
pub fn digamma_round(&mut self, round: Round) -> Ordering
Computes the value of the Digamma function on self
, applying
the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // digamma(1.25) = -0.2275 // using 4 significant bits: -0.234375 let dir = f.digamma_round(Round::Nearest); assert_eq!(f, -0.234375); assert_eq!(dir, Ordering::Less);
pub fn digamma_ref(&self) -> DigammaIncomplete
[src]
pub fn digamma_ref(&self) -> DigammaIncomplete
Computes the Digamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let digamma = Float::with_val(53, f.digamma_ref()); let expected = -0.2275_f64; assert!((digamma - expected).abs() < 0.0001);
pub fn zeta(self) -> Self
[src]
pub fn zeta(self) -> Self
Computes the value of the Riemann Zeta function on self
,
rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let zeta = f.zeta(); let expected = 4.5951_f64; assert!((zeta - expected).abs() < 0.0001);
pub fn zeta_mut(&mut self)
[src]
pub fn zeta_mut(&mut self)
Computes the value of the Riemann Zeta function on self
,
rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.zeta_mut(); let expected = 4.5951_f64; assert!((f - expected).abs() < 0.0001);
pub fn zeta_round(&mut self, round: Round) -> Ordering
[src]
pub fn zeta_round(&mut self, round: Round) -> Ordering
Computes the value of the Riemann Zeta function on self
,
applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // zeta(1.25) = 4.5951 // using 4 significant bits: 4.5 let dir = f.zeta_round(Round::Nearest); assert_eq!(f, 4.5); assert_eq!(dir, Ordering::Less);
pub fn zeta_ref(&self) -> ZetaIncomplete
[src]
pub fn zeta_ref(&self) -> ZetaIncomplete
Computes the Riemann Zeta function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let zeta = Float::with_val(53, f.zeta_ref()); let expected = 4.5951_f64; assert!((zeta - expected).abs() < 0.0001);
pub fn zeta_u(u: u32) -> ZetaUIncomplete
[src]
pub fn zeta_u(u: u32) -> ZetaUIncomplete
Computes the Riemann Zeta function on u.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let z = Float::zeta_u(3); let f = Float::with_val(53, z); let expected = 1.2021_f64; assert!((f - expected).abs() < 0.0001);
pub fn erf(self) -> Self
[src]
pub fn erf(self) -> Self
Computes the value of the error function, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let erf = f.erf(); let expected = 0.9229_f64; assert!((erf - expected).abs() < 0.0001);
pub fn erf_mut(&mut self)
[src]
pub fn erf_mut(&mut self)
Computes the value of the error function, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.erf_mut(); let expected = 0.9229_f64; assert!((f - expected).abs() < 0.0001);
pub fn erf_round(&mut self, round: Round) -> Ordering
[src]
pub fn erf_round(&mut self, round: Round) -> Ordering
Computes the value of the error function, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // erf(1.25) = 0.9229 // using 4 significant bits: 0.9375 let dir = f.erf_round(Round::Nearest); assert_eq!(f, 0.9375); assert_eq!(dir, Ordering::Greater);
pub fn erf_ref(&self) -> ErfIncomplete
[src]
pub fn erf_ref(&self) -> ErfIncomplete
Computes the error function.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let erf = Float::with_val(53, f.erf_ref()); let expected = 0.9229_f64; assert!((erf - expected).abs() < 0.0001);
pub fn erfc(self) -> Self
[src]
pub fn erfc(self) -> Self
Computes the value of the complementary error function, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let erfc = f.erfc(); let expected = 0.0771_f64; assert!((erfc - expected).abs() < 0.0001);
pub fn erfc_mut(&mut self)
[src]
pub fn erfc_mut(&mut self)
Computes the value of the complementary error function, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.erfc_mut(); let expected = 0.0771_f64; assert!((f - expected).abs() < 0.0001);
pub fn erfc_round(&mut self, round: Round) -> Ordering
[src]
pub fn erfc_round(&mut self, round: Round) -> Ordering
Computes the value of the complementary error function, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // erfc(1.25) = 0.0771 // using 4 significant bits: 0.078125 let dir = f.erfc_round(Round::Nearest); assert_eq!(f, 0.078125); assert_eq!(dir, Ordering::Greater);
pub fn erfc_ref(&self) -> ErfcIncomplete
[src]
pub fn erfc_ref(&self) -> ErfcIncomplete
Computes the complementary error function.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let erfc = Float::with_val(53, f.erfc_ref()); let expected = 0.0771_f64; assert!((erfc - expected).abs() < 0.0001);
pub fn j0(self) -> Self
[src]
pub fn j0(self) -> Self
Computes the value of the first kind Bessel function of order 0, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j0 = f.j0(); let expected = 0.6459_f64; assert!((j0 - expected).abs() < 0.0001);
pub fn j0_mut(&mut self)
[src]
pub fn j0_mut(&mut self)
Computes the value of the first kind Bessel function of order 0, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.j0_mut(); let expected = 0.6459_f64; assert!((f - expected).abs() < 0.0001);
pub fn j0_round(&mut self, round: Round) -> Ordering
[src]
pub fn j0_round(&mut self, round: Round) -> Ordering
Computes the value of the first kind Bessel function of order 0, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // j0(1.25) = 0.6459 // using 4 significant bits: 0.625 let dir = f.j0_round(Round::Nearest); assert_eq!(f, 0.625); assert_eq!(dir, Ordering::Less);
pub fn j0_ref(&self) -> J0Incomplete
[src]
pub fn j0_ref(&self) -> J0Incomplete
Computes the first kind Bessel function of order 0.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j0 = Float::with_val(53, f.j0_ref()); let expected = 0.6459_f64; assert!((j0 - expected).abs() < 0.0001);
pub fn j1(self) -> Self
[src]
pub fn j1(self) -> Self
Computes the value of the first kind Bessel function of order 1, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j1 = f.j1(); let expected = 0.5106_f64; assert!((j1 - expected).abs() < 0.0001);
pub fn j1_mut(&mut self)
[src]
pub fn j1_mut(&mut self)
Computes the value of the first kind Bessel function of order 1, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.j1_mut(); let expected = 0.5106_f64; assert!((f - expected).abs() < 0.0001);
pub fn j1_round(&mut self, round: Round) -> Ordering
[src]
pub fn j1_round(&mut self, round: Round) -> Ordering
Computes the value of the first kind Bessel function of order 1, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // j1(1.25) = 0.5106 // using 4 significant bits: 0.5 let dir = f.j1_round(Round::Nearest); assert_eq!(f, 0.5); assert_eq!(dir, Ordering::Less);
pub fn j1_ref(&self) -> J1Incomplete
[src]
pub fn j1_ref(&self) -> J1Incomplete
Computes the first kind Bessel function of order 1.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j1 = Float::with_val(53, f.j1_ref()); let expected = 0.5106_f64; assert!((j1 - expected).abs() < 0.0001);
pub fn jn(self, n: i32) -> Self
[src]
pub fn jn(self, n: i32) -> Self
Computes the value of the first kind Bessel function of order n, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j2 = f.jn(2); let expected = 0.1711_f64; assert!((j2 - expected).abs() < 0.0001);
pub fn jn_mut(&mut self, n: i32)
[src]
pub fn jn_mut(&mut self, n: i32)
Computes the value of the first kind Bessel function of order n, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.jn_mut(2); let expected = 0.1711_f64; assert!((f - expected).abs() < 0.0001);
pub fn jn_round(&mut self, n: i32, round: Round) -> Ordering
[src]
pub fn jn_round(&mut self, n: i32, round: Round) -> Ordering
Computes the value of the first kind Bessel function of order n, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // j2(1.25) = 0.1711 // using 4 significant bits: 0.171875 let dir = f.jn_round(2, Round::Nearest); assert_eq!(f, 0.171875); assert_eq!(dir, Ordering::Greater);
pub fn jn_ref(&self, n: i32) -> JnIncomplete
[src]
pub fn jn_ref(&self, n: i32) -> JnIncomplete
Computes the first kind Bessel function of order n.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j2 = Float::with_val(53, f.jn_ref(2)); let expected = 0.1711_f64; assert!((j2 - expected).abs() < 0.0001);
pub fn y0(self) -> Self
[src]
pub fn y0(self) -> Self
Computes the value of the second kind Bessel function of order 0, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y0 = f.y0(); let expected = 0.2582_f64; assert!((y0 - expected).abs() < 0.0001);
pub fn y0_mut(&mut self)
[src]
pub fn y0_mut(&mut self)
Computes the value of the second kind Bessel function of order 0, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.y0_mut(); let expected = 0.2582_f64; assert!((f - expected).abs() < 0.0001);
pub fn y0_round(&mut self, round: Round) -> Ordering
[src]
pub fn y0_round(&mut self, round: Round) -> Ordering
Computes the value of the second kind Bessel function of order 0, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // y0(1.25) = 0.2582 // using 4 significant bits: 0.25 let dir = f.y0_round(Round::Nearest); assert_eq!(f, 0.25); assert_eq!(dir, Ordering::Less);
pub fn y0_ref(&self) -> Y0Incomplete
[src]
pub fn y0_ref(&self) -> Y0Incomplete
Computes the second kind Bessel function of order 0.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y0 = Float::with_val(53, f.y0_ref()); let expected = 0.2582_f64; assert!((y0 - expected).abs() < 0.0001);
pub fn y1(self) -> Self
[src]
pub fn y1(self) -> Self
Computes the value of the second kind Bessel function of order 1, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y1 = f.y1(); let expected = -0.5844_f64; assert!((y1 - expected).abs() < 0.0001);
pub fn y1_mut(&mut self)
[src]
pub fn y1_mut(&mut self)
Computes the value of the second kind Bessel function of order 1, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.y1_mut(); let expected = -0.5844_f64; assert!((f - expected).abs() < 0.0001);
pub fn y1_round(&mut self, round: Round) -> Ordering
[src]
pub fn y1_round(&mut self, round: Round) -> Ordering
Computes the value of the second kind Bessel function of order 1, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // y1(1.25) = -0.5844 // using 4 significant bits: -0.5625 let dir = f.y1_round(Round::Nearest); assert_eq!(f, -0.5625); assert_eq!(dir, Ordering::Greater);
pub fn y1_ref(&self) -> Y1Incomplete
[src]
pub fn y1_ref(&self) -> Y1Incomplete
Computes the second kind Bessel function of order 1.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y1 = Float::with_val(53, f.y1_ref()); let expected = -0.5844_f64; assert!((y1 - expected).abs() < 0.0001);
pub fn yn(self, n: i32) -> Self
[src]
pub fn yn(self, n: i32) -> Self
Computes the value of the second kind Bessel function of order n, rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y2 = f.yn(2); let expected = -1.1932_f64; assert!((y2 - expected).abs() < 0.0001);
pub fn yn_mut(&mut self, n: i32)
[src]
pub fn yn_mut(&mut self, n: i32)
Computes the value of the second kind Bessel function of order n, rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.yn_mut(2); let expected = -1.1932_f64; assert!((f - expected).abs() < 0.0001);
pub fn yn_round(&mut self, n: i32, round: Round) -> Ordering
[src]
pub fn yn_round(&mut self, n: i32, round: Round) -> Ordering
Computes the value of the second kind Bessel function of order n, applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // y2(1.25) = -1.1932 // using 4 significant bits: -1.25 let dir = f.yn_round(2, Round::Nearest); assert_eq!(f, -1.25); assert_eq!(dir, Ordering::Less);
pub fn yn_ref(&self, n: i32) -> YnIncomplete
[src]
pub fn yn_ref(&self, n: i32) -> YnIncomplete
Computes the second kind Bessel function of order n.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y2 = Float::with_val(53, f.yn_ref(2)); let expected = -1.1932_f64; assert!((y2 - expected).abs() < 0.0001);
pub fn agm(self, other: &Self) -> Self
[src]
pub fn agm(self, other: &Self) -> Self
Computes the arithmetic-geometric mean of self
and other
,
rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); let agm = f.agm(&g); let expected = 2.3295_f64; assert!((agm - expected).abs() < 0.0001);
pub fn agm_mut(&mut self, other: &Self)
[src]
pub fn agm_mut(&mut self, other: &Self)
Computes the arithmetic-geometric mean of self
and other
,
rounding to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); f.agm_mut(&g); let expected = 2.3295_f64; assert!((f - expected).abs() < 0.0001);
pub fn agm_round(&mut self, other: &Self, round: Round) -> Ordering
[src]
pub fn agm_round(&mut self, other: &Self, round: Round) -> Ordering
Computes the arithmetic-geometric mean of self
and other
,
applying the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); let g = Float::with_val(4, 3.75); // agm(1.25, 3.75) = 2.3295 // using 4 significant bits: 2.25 let dir = f.agm_round(&g, Round::Nearest); assert_eq!(f, 2.25); assert_eq!(dir, Ordering::Less);
pub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete
[src]
pub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete
Computes the arithmetic-geometric mean.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); let agm = Float::with_val(53, f.agm_ref(&g)); let expected = 2.3295_f64; assert!((agm - expected).abs() < 0.0001);
pub fn hypot(self, other: &Self) -> Self
[src]
pub fn hypot(self, other: &Self) -> Self
Computes the Euclidean norm of self
and other
, rounding to
the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); let hypot = f.hypot(&g); let expected = 3.9528_f64; assert!((hypot - expected).abs() < 0.0001);
pub fn hypot_mut(&mut self, other: &Self)
[src]
pub fn hypot_mut(&mut self, other: &Self)
Computes the Euclidean norm of self
and other
, rounding to
the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); f.hypot_mut(&g); let expected = 3.9528_f64; assert!((f - expected).abs() < 0.0001);
pub fn hypot_round(&mut self, other: &Self, round: Round) -> Ordering
[src]
pub fn hypot_round(&mut self, other: &Self, round: Round) -> Ordering
Computes the Euclidean norm of self
and other
, applying
the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); let g = Float::with_val(4, 3.75); // hypot(1.25) = 3.9528 // using 4 significant bits: 4.0 let dir = f.hypot_round(&g, Round::Nearest); assert_eq!(f, 4.0); assert_eq!(dir, Ordering::Greater);
pub fn hypot_ref<'a>(&'a self, other: &'a Self) -> HypotIncomplete
[src]
pub fn hypot_ref<'a>(&'a self, other: &'a Self) -> HypotIncomplete
Computes the Euclidean norm.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); let hypot = Float::with_val(53, f.hypot_ref(&g)); let expected = 3.9528_f64; assert!((hypot - expected).abs() < 0.0001);
pub fn ai(self) -> Self
[src]
pub fn ai(self) -> Self
Computes the value of the Airy function Ai on self
, rounding
to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ai = f.ai(); let expected = 0.0996_f64; assert!((ai - expected).abs() < 0.0001);
pub fn ai_mut(&mut self)
[src]
pub fn ai_mut(&mut self)
Computes the value of the Airy function Ai on self
, rounding
to the nearest.
Examples
use rug::Float; let mut f = Float::with_val(53, 1.25); f.ai_mut(); let expected = 0.0996_f64; assert!((f - expected).abs() < 0.0001);
pub fn ai_round(&mut self, round: Round) -> Ordering
[src]
pub fn ai_round(&mut self, round: Round) -> Ordering
Computes the value of the Airy function Ai on self
, applying
the specified rounding method.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut f = Float::with_val(4, 1.25); // ai(1.25) = 0.0996 // using 4 significant bits: 0.1015625 let dir = f.ai_round(Round::Nearest); assert_eq!(f, 0.1015625); assert_eq!(dir, Ordering::Greater);
pub fn ai_ref(&self) -> AiIncomplete
[src]
pub fn ai_ref(&self) -> AiIncomplete
Computes the Airy function Ai on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ai = Float::with_val(53, f.ai_ref()); let expected = 0.0996_f64; assert!((ai - expected).abs() < 0.0001);
pub fn ceil(self) -> Self
[src]
pub fn ceil(self) -> Self
Rounds up to the next higher integer.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let ceil1 = f1.ceil(); assert_eq!(ceil1, -23); let f2 = Float::with_val(53, 23.75); let ceil2 = f2.ceil(); assert_eq!(ceil2, 24);
pub fn ceil_mut(&mut self)
[src]
pub fn ceil_mut(&mut self)
Rounds up to the next higher integer.
Examples
use rug::Float; let mut f1 = Float::with_val(53, -23.75); f1.ceil_mut(); assert_eq!(f1, -23); let mut f2 = Float::with_val(53, 23.75); f2.ceil_mut(); assert_eq!(f2, 24);
pub fn ceil_ref(&self) -> CeilIncomplete
[src]
pub fn ceil_ref(&self) -> CeilIncomplete
Rounds up to the next higher integer. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let ceil1 = Float::with_val(53, f1.ceil_ref()); assert_eq!(ceil1, -23); let f2 = Float::with_val(53, 23.75); let ceil2 = Float::with_val(53, f2.ceil_ref()); assert_eq!(ceil2, 24);
pub fn floor(self) -> Self
[src]
pub fn floor(self) -> Self
Rounds down to the next lower integer.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let floor1 = f1.floor(); assert_eq!(floor1, -24); let f2 = Float::with_val(53, 23.75); let floor2 = f2.floor(); assert_eq!(floor2, 23);
pub fn floor_mut(&mut self)
[src]
pub fn floor_mut(&mut self)
Rounds down to the next lower integer.
Examples
use rug::Float; let mut f1 = Float::with_val(53, -23.75); f1.floor_mut(); assert_eq!(f1, -24); let mut f2 = Float::with_val(53, 23.75); f2.floor_mut(); assert_eq!(f2, 23);
pub fn floor_ref(&self) -> FloorIncomplete
[src]
pub fn floor_ref(&self) -> FloorIncomplete
Rounds down to the next lower integer. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let floor1 = Float::with_val(53, f1.floor_ref()); assert_eq!(floor1, -24); let f2 = Float::with_val(53, 23.75); let floor2 = Float::with_val(53, f2.floor_ref()); assert_eq!(floor2, 23);
pub fn round(self) -> Self
[src]
pub fn round(self) -> Self
Rounds to the nearest integer, rounding half-way cases away from zero.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let round1 = f1.round(); assert_eq!(round1, -24); let f2 = Float::with_val(53, 23.75); let round2 = f2.round(); assert_eq!(round2, 24);
pub fn round_mut(&mut self)
[src]
pub fn round_mut(&mut self)
Rounds to the nearest integer, rounding half-way cases away from zero.
Examples
use rug::Float; let mut f1 = Float::with_val(53, -23.75); f1.round_mut(); assert_eq!(f1, -24); let mut f2 = Float::with_val(53, 23.75); f2.round_mut(); assert_eq!(f2, 24);
pub fn round_ref(&self) -> RoundIncomplete
[src]
pub fn round_ref(&self) -> RoundIncomplete
Rounds to the nearest integer, rounding half-way cases away from zero. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let round1 = Float::with_val(53, f1.round_ref()); assert_eq!(round1, -24); let f2 = Float::with_val(53, 23.75); let round2 = Float::with_val(53, f2.round_ref()); assert_eq!(round2, 24);
Double rounding may happen when assigning to a target with a precision less than the number of significant bits for the truncated integer.
use rug::Float; use rug::float::Round; use rug::ops::AssignRound; let f = Float::with_val(53, 6.5); // 6.5 (binary 110.1) is rounded to 7 (binary 111) let r = f.round_ref(); // use only 2 bits of precision in destination let mut dst = Float::new(2); // 7 (binary 111) is rounded to 8 (binary 1000) by // round-even rule in order to store in 2-bit Float, even // though 6 (binary 110) is closer to original 6.5). dst.assign_round(r, Round::Nearest); assert_eq!(dst, 8);
pub fn round_even(self) -> Self
[src]
pub fn round_even(self) -> Self
Rounds to the nearest integer, rounding half-way cases to even.
Examples
use rug::Float; let f1 = Float::with_val(53, 23.5); let round1 = f1.round_even(); assert_eq!(round1, 24); let f2 = Float::with_val(53, 24.5); let round2 = f2.round_even(); assert_eq!(round2, 24);
pub fn round_even_mut(&mut self)
[src]
pub fn round_even_mut(&mut self)
Rounds to the nearest integer, rounding half-way cases to even.
Examples
use rug::Float; let mut f1 = Float::with_val(53, 23.5); f1.round_even_mut(); assert_eq!(f1, 24); let mut f2 = Float::with_val(53, 24.5); f2.round_even_mut(); assert_eq!(f2, 24);
pub fn round_even_ref(&self) -> RoundEvenIncomplete
[src]
pub fn round_even_ref(&self) -> RoundEvenIncomplete
Rounds to the nearest integer, rounding half-way cases to even. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, 23.5); let round1 = Float::with_val(53, f1.round_even_ref()); assert_eq!(round1, 24); let f2 = Float::with_val(53, 24.5); let round2 = Float::with_val(53, f2.round_even_ref()); assert_eq!(round2, 24);
pub fn trunc(self) -> Self
[src]
pub fn trunc(self) -> Self
Rounds to the next integer towards zero.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let trunc1 = f1.trunc(); assert_eq!(trunc1, -23); let f2 = Float::with_val(53, 23.75); let trunc2 = f2.trunc(); assert_eq!(trunc2, 23);
pub fn trunc_mut(&mut self)
[src]
pub fn trunc_mut(&mut self)
Rounds to the next integer towards zero.
Examples
use rug::Float; let mut f1 = Float::with_val(53, -23.75); f1.trunc_mut(); assert_eq!(f1, -23); let mut f2 = Float::with_val(53, 23.75); f2.trunc_mut(); assert_eq!(f2, 23);
pub fn trunc_ref(&self) -> TruncIncomplete
[src]
pub fn trunc_ref(&self) -> TruncIncomplete
Rounds to the next integer towards zero. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let trunc1 = Float::with_val(53, f1.trunc_ref()); assert_eq!(trunc1, -23); let f2 = Float::with_val(53, 23.75); let trunc2 = Float::with_val(53, f2.trunc_ref()); assert_eq!(trunc2, 23);
pub fn fract(self) -> Self
[src]
pub fn fract(self) -> Self
Gets the fractional part of the number.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let fract1 = f1.fract(); assert_eq!(fract1, -0.75); let f2 = Float::with_val(53, 23.75); let fract2 = f2.fract(); assert_eq!(fract2, 0.75);
pub fn fract_mut(&mut self)
[src]
pub fn fract_mut(&mut self)
Gets the fractional part of the number.
Examples
use rug::Float; let mut f1 = Float::with_val(53, -23.75); f1.fract_mut(); assert_eq!(f1, -0.75); let mut f2 = Float::with_val(53, 23.75); f2.fract_mut(); assert_eq!(f2, 0.75);
pub fn fract_ref(&self) -> FractIncomplete
[src]
pub fn fract_ref(&self) -> FractIncomplete
Gets the fractional part of the number.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let fract1 = Float::with_val(53, f1.fract_ref()); assert_eq!(fract1, -0.75); let f2 = Float::with_val(53, 23.75); let fract2 = Float::with_val(53, f2.fract_ref()); assert_eq!(fract2, 0.75);
pub fn trunc_fract(self, fract: Self) -> (Self, Self)
[src]
pub fn trunc_fract(self, fract: Self) -> (Self, Self)
Gets the integer and fractional parts of the number, rounding to the nearest.
The integer part is stored in self
and keeps its
precision, while the fractional part is stored in fract
keeping its precision.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let (trunc1, fract1) = f1.trunc_fract(Float::new(53)); assert_eq!(trunc1, -23); assert_eq!(fract1, -0.75); let f2 = Float::with_val(53, 23.75); let (trunc2, fract2) = f2.trunc_fract(Float::new(53)); assert_eq!(trunc2, 23); assert_eq!(fract2, 0.75);
pub fn trunc_fract_mut(&mut self, fract: &mut Self)
[src]
pub fn trunc_fract_mut(&mut self, fract: &mut Self)
Gets the integer and fractional parts of the number, rounding to the nearest.
The integer part is stored in self
and keeps its
precision, while the fractional part is stored in fract
keeping its precision.
Examples
use rug::Float; let mut f1 = Float::with_val(53, -23.75); let mut fract1 = Float::new(53); f1.trunc_fract_mut(&mut fract1); assert_eq!(f1, -23); assert_eq!(fract1, -0.75); let mut f2 = Float::with_val(53, 23.75); let mut fract2 = Float::new(53); f2.trunc_fract_mut(&mut fract2); assert_eq!(f2, 23); assert_eq!(fract2, 0.75);
pub fn trunc_fract_round(
&mut self,
fract: &mut Self,
round: Round
) -> (Ordering, Ordering)
[src]
pub fn trunc_fract_round(
&mut self,
fract: &mut Self,
round: Round
) -> (Ordering, Ordering)
Gets the integer and fractional parts of the number, applying the specified rounding method.
The first element of the returned tuple of rounding
directions is always Ordering::Equal
, as truncating a
value in place will always be exact.
The integer part is stored in self
and keeps its
precision, while the fractional part is stored in fract
keeping its precision.
Examples
use rug::Float; use rug::float::Round; use std::cmp::Ordering; // 0.515625 in binary is 0.100001 let mut f1 = Float::with_val(53, -23.515625); let mut fract1 = Float::new(4); let dir1 = f1.trunc_fract_round(&mut fract1, Round::Nearest); assert_eq!(f1, -23); assert_eq!(fract1, -0.5); assert_eq!(dir1, (Ordering::Equal, Ordering::Greater)); let mut f2 = Float::with_val(53, 23.515625); let mut fract2 = Float::new(4); let dir2 = f2.trunc_fract_round(&mut fract2, Round::Nearest); assert_eq!(f2, 23); assert_eq!(fract2, 0.5); assert_eq!(dir2, (Ordering::Equal, Ordering::Less));
pub fn trunc_fract_ref(&self) -> TruncFractIncomplete
[src]
pub fn trunc_fract_ref(&self) -> TruncFractIncomplete
Gets the integer and fractional parts of the number.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Float}; let f1 = Float::with_val(53, -23.75); let r1 = f1.trunc_fract_ref(); let (mut trunc1, mut fract1) = (Float::new(53), Float::new(53)); (&mut trunc1, &mut fract1).assign(r1); assert_eq!(trunc1, -23); assert_eq!(fract1, -0.75); let f2 = Float::with_val(53, -23.75); let r2 = f2.trunc_fract_ref(); let (mut trunc2, mut fract2) = (Float::new(53), Float::new(53)); (&mut trunc2, &mut fract2).assign(r2); assert_eq!(trunc2, -23); assert_eq!(fract2, -0.75);
pub fn random_bits<'a, 'b>(
rng: &'a mut RandState<'b>
) -> RandomBitsIncomplete<'a, 'b> where
'b: 'a,
[src]
pub fn random_bits<'a, 'b>(
rng: &'a mut RandState<'b>
) -> RandomBitsIncomplete<'a, 'b> where
'b: 'a,
Generates a random number in the range 0 ≤ x < 1.
This is equivalent to generating a random integer in the range 0 ≤ x < 2p, where 2p is two raised to the power of the precision, and then dividing the integer by 2p. The smallest non-zero result will thus be 2−p, and will only have one bit set. In the smaller possible results, many bits will be zero, and not all the precision will be used.
There is a corner case where the generated random number is converted to NaN: if the precision is very large, the generated random number could have an exponent less than the allowed minimum exponent, and NaN is used to indicate this. For this to occur in practice, the minimum exponent has to be set to have a very small magnitude using the low-level MPFR interface, or the random number generator has to be designed specifically to trigger this case.
Assign<Src> for Float
is implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::rand::RandState; use rug::{Assign, Float}; let mut rand = RandState::new(); let mut f = Float::new(2); f.assign(Float::random_bits(&mut rand)); assert!(f == 0.0 || f == 0.25 || f == 0.5 || f == 0.75); println!("0.0 ≤ {} < 1.0", f);
pub fn random_cont<'a, 'b>(rng: &'a mut RandState<'b>) -> RandomCont<'a, 'b> where
'b: 'a,
[src]
pub fn random_cont<'a, 'b>(rng: &'a mut RandState<'b>) -> RandomCont<'a, 'b> where
'b: 'a,
Generates a random number in the continuous range 0 ≤ x < 1.
The result can be rounded up to be equal to one. Unlike the
random_bits
method which generates a discrete random
number at intervals depending on the precision, this method is
equivalent to generating a continuous random number with
infinite precision and then rounding the result. This means
that even the smaller numbers will be using all the available
precision bits, and rounding is performed in all cases, not in
some corner case.
Rounding directions for generated random numbers cannot be
Ordering::Equal
, as the random numbers generated can be
considered to have infinite precision before rounding.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
Examples
use rug::rand::RandState; use rug::Float; let mut rand = RandState::new(); let f = Float::with_val(2, Float::random_cont(&mut rand)); // The significand is either 0b10 or 0b11 assert!( f == 1.0 || f == 0.75 || f == 0.5 || f == 0.375 || f == 0.25 || f <= 0.1875 );
pub fn random_normal<'a, 'b>(rng: &'a mut RandState<'b>) -> RandomNormal<'a, 'b> where
'b: 'a,
[src]
pub fn random_normal<'a, 'b>(rng: &'a mut RandState<'b>) -> RandomNormal<'a, 'b> where
'b: 'a,
Generates a random number according to a standard normal Gaussian distribution, rounding to the nearest.
Rounding directions for generated random numbers cannot be
Ordering::Equal
, as the random numbers generated can be
considered to have infinite precision before rounding.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
Examples
use rug::rand::RandState; use rug::Float; let mut rand = RandState::new(); let f = Float::with_val(53, Float::random_normal(&mut rand)); println!("Normal random number: {}", f);
pub fn random_exp<'a, 'b>(rng: &'a mut RandState<'b>) -> RandomExp<'a, 'b> where
'b: 'a,
[src]
pub fn random_exp<'a, 'b>(rng: &'a mut RandState<'b>) -> RandomExp<'a, 'b> where
'b: 'a,
Generates a random number according to an exponential distribution with mean one, rounding to the nearest.
Rounding directions for generated random numbers cannot be
Ordering::Equal
, as the random numbers generated can be
considered to have infinite precision before rounding.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
Examples
use rug::rand::RandState; use rug::Float; let mut rand = RandState::new(); let f = Float::with_val(53, Float::random_exp(&mut rand)); println!("Exponential random number: {}", f);
Trait Implementations
impl Neg for Float
[src]
impl Neg for Float
type Output = Float
The resulting type after applying the -
operator.
fn neg(self) -> Float
[src]
fn neg(self) -> Float
Performs the unary -
operation.
impl NegAssign for Float
[src]
impl NegAssign for Float
fn neg_assign(&mut self)
[src]
fn neg_assign(&mut self)
Peforms the negation. Read more
impl<'a> Neg for &'a Float
[src]
impl<'a> Neg for &'a Float
type Output = NegIncomplete<'a>
The resulting type after applying the -
operator.
fn neg(self) -> NegIncomplete<'a>
[src]
fn neg(self) -> NegIncomplete<'a>
Performs the unary -
operation.
impl Add<Float> for Float
[src]
impl Add<Float> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for Float
[src]
impl<'a> Add<&'a Float> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> Float
[src]
fn add(self, rhs: &Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for &'a Float
[src]
impl<'a> Add<&'a Float> for &'a Float
type Output = AddIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddIncomplete
[src]
fn add(self, rhs: &'a Float) -> AddIncomplete
Performs the +
operation.
impl AddAssign<Float> for Float
[src]
impl AddAssign<Float> for Float
fn add_assign(&mut self, rhs: Float)
[src]
fn add_assign(&mut self, rhs: Float)
Performs the +=
operation.
impl<'a> AddAssign<&'a Float> for Float
[src]
impl<'a> AddAssign<&'a Float> for Float
fn add_assign(&mut self, rhs: &Float)
[src]
fn add_assign(&mut self, rhs: &Float)
Performs the +=
operation.
impl AddAssignRound<Float> for Float
[src]
impl AddAssignRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Float> for Float
[src]
impl<'a> AddAssignRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> Add<Float> for &'a Float
[src]
impl<'a> Add<Float> for &'a Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl AddFrom<Float> for Float
[src]
impl AddFrom<Float> for Float
impl<'a> AddFrom<&'a Float> for Float
[src]
impl<'a> AddFrom<&'a Float> for Float
impl<'a> AddFromRound<Float> for Float
[src]
impl<'a> AddFromRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: Float, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: Float, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddFromRound<&'a Float> for Float
[src]
impl<'a> AddFromRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<Float> for Float
[src]
impl Sub<Float> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for Float
[src]
impl<'a> Sub<&'a Float> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> Float
[src]
fn sub(self, rhs: &Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for &'a Float
[src]
impl<'a> Sub<&'a Float> for &'a Float
type Output = SubIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubIncomplete
[src]
fn sub(self, rhs: &'a Float) -> SubIncomplete
Performs the -
operation.
impl SubAssign<Float> for Float
[src]
impl SubAssign<Float> for Float
fn sub_assign(&mut self, rhs: Float)
[src]
fn sub_assign(&mut self, rhs: Float)
Performs the -=
operation.
impl<'a> SubAssign<&'a Float> for Float
[src]
impl<'a> SubAssign<&'a Float> for Float
fn sub_assign(&mut self, rhs: &Float)
[src]
fn sub_assign(&mut self, rhs: &Float)
Performs the -=
operation.
impl SubAssignRound<Float> for Float
[src]
impl SubAssignRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Float> for Float
[src]
impl<'a> SubAssignRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> Sub<Float> for &'a Float
[src]
impl<'a> Sub<Float> for &'a Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl SubFrom<Float> for Float
[src]
impl SubFrom<Float> for Float
impl<'a> SubFrom<&'a Float> for Float
[src]
impl<'a> SubFrom<&'a Float> for Float
impl<'a> SubFromRound<Float> for Float
[src]
impl<'a> SubFromRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: Float, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: Float, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Float> for Float
[src]
impl<'a> SubFromRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<Float> for Float
[src]
impl Mul<Float> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for Float
[src]
impl<'a> Mul<&'a Float> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> Float
[src]
fn mul(self, rhs: &Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for &'a Float
[src]
impl<'a> Mul<&'a Float> for &'a Float
type Output = MulIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulIncomplete
[src]
fn mul(self, rhs: &'a Float) -> MulIncomplete
Performs the *
operation.
impl MulAssign<Float> for Float
[src]
impl MulAssign<Float> for Float
fn mul_assign(&mut self, rhs: Float)
[src]
fn mul_assign(&mut self, rhs: Float)
Performs the *=
operation.
impl<'a> MulAssign<&'a Float> for Float
[src]
impl<'a> MulAssign<&'a Float> for Float
fn mul_assign(&mut self, rhs: &Float)
[src]
fn mul_assign(&mut self, rhs: &Float)
Performs the *=
operation.
impl MulAssignRound<Float> for Float
[src]
impl MulAssignRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Float> for Float
[src]
impl<'a> MulAssignRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> Mul<Float> for &'a Float
[src]
impl<'a> Mul<Float> for &'a Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl MulFrom<Float> for Float
[src]
impl MulFrom<Float> for Float
impl<'a> MulFrom<&'a Float> for Float
[src]
impl<'a> MulFrom<&'a Float> for Float
impl<'a> MulFromRound<Float> for Float
[src]
impl<'a> MulFromRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: Float, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: Float, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Float> for Float
[src]
impl<'a> MulFromRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<Float> for Float
[src]
impl Div<Float> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for Float
[src]
impl<'a> Div<&'a Float> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> Float
[src]
fn div(self, rhs: &Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for &'a Float
[src]
impl<'a> Div<&'a Float> for &'a Float
type Output = DivIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivIncomplete
[src]
fn div(self, rhs: &'a Float) -> DivIncomplete
Performs the /
operation.
impl DivAssign<Float> for Float
[src]
impl DivAssign<Float> for Float
fn div_assign(&mut self, rhs: Float)
[src]
fn div_assign(&mut self, rhs: Float)
Performs the /=
operation.
impl<'a> DivAssign<&'a Float> for Float
[src]
impl<'a> DivAssign<&'a Float> for Float
fn div_assign(&mut self, rhs: &Float)
[src]
fn div_assign(&mut self, rhs: &Float)
Performs the /=
operation.
impl DivAssignRound<Float> for Float
[src]
impl DivAssignRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivAssignRound<&'a Float> for Float
[src]
impl<'a> DivAssignRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
Performs the division. Read more
impl<'a> Div<Float> for &'a Float
[src]
impl<'a> Div<Float> for &'a Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl DivFrom<Float> for Float
[src]
impl DivFrom<Float> for Float
impl<'a> DivFrom<&'a Float> for Float
[src]
impl<'a> DivFrom<&'a Float> for Float
impl<'a> DivFromRound<Float> for Float
[src]
impl<'a> DivFromRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: Float, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: Float, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivFromRound<&'a Float> for Float
[src]
impl<'a> DivFromRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
Performs the division. Read more
impl Pow<Float> for Float
[src]
impl Pow<Float> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'a> Pow<&'a Float> for Float
[src]
impl<'a> Pow<&'a Float> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &Float) -> Float
[src]
fn pow(self, rhs: &Float) -> Float
Performs the power operation. Read more
impl<'a> Pow<&'a Float> for &'a Float
[src]
impl<'a> Pow<&'a Float> for &'a Float
type Output = PowIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Float) -> PowIncomplete
[src]
fn pow(self, rhs: &'a Float) -> PowIncomplete
Performs the power operation. Read more
impl PowAssign<Float> for Float
[src]
impl PowAssign<Float> for Float
fn pow_assign(&mut self, rhs: Float)
[src]
fn pow_assign(&mut self, rhs: Float)
Peforms the power operation. Read more
impl<'a> PowAssign<&'a Float> for Float
[src]
impl<'a> PowAssign<&'a Float> for Float
fn pow_assign(&mut self, rhs: &Float)
[src]
fn pow_assign(&mut self, rhs: &Float)
Peforms the power operation. Read more
impl PowAssignRound<Float> for Float
[src]
impl PowAssignRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: Float, round: Round) -> Ordering
Performs the power operation. Read more
impl<'a> PowAssignRound<&'a Float> for Float
[src]
impl<'a> PowAssignRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering
Performs the power operation. Read more
impl<'a> Pow<Float> for &'a Float
[src]
impl<'a> Pow<Float> for &'a Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl PowFrom<Float> for Float
[src]
impl PowFrom<Float> for Float
impl<'a> PowFrom<&'a Float> for Float
[src]
impl<'a> PowFrom<&'a Float> for Float
impl<'a> PowFromRound<Float> for Float
[src]
impl<'a> PowFromRound<Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: Float, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: Float, round: Round) -> Ordering
Performs the power operation. Read more
impl<'a> PowFromRound<&'a Float> for Float
[src]
impl<'a> PowFromRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: &Float, round: Round) -> Ordering
Performs the power operation. Read more
impl Add<Integer> for Float
[src]
impl Add<Integer> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Float
[src]
fn add(self, rhs: Integer) -> Float
Performs the +
operation.
impl<'a> Add<&'a Integer> for Float
[src]
impl<'a> Add<&'a Integer> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> Float
[src]
fn add(self, rhs: &Integer) -> Float
Performs the +
operation.
impl<'a> Add<&'a Integer> for &'a Float
[src]
impl<'a> Add<&'a Integer> for &'a Float
type Output = AddIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete
[src]
fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete
Performs the +
operation.
impl AddAssign<Integer> for Float
[src]
impl AddAssign<Integer> for Float
fn add_assign(&mut self, rhs: Integer)
[src]
fn add_assign(&mut self, rhs: Integer)
Performs the +=
operation.
impl<'a> AddAssign<&'a Integer> for Float
[src]
impl<'a> AddAssign<&'a Integer> for Float
fn add_assign(&mut self, rhs: &Integer)
[src]
fn add_assign(&mut self, rhs: &Integer)
Performs the +=
operation.
impl AddAssignRound<Integer> for Float
[src]
impl AddAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Integer> for Float
[src]
impl<'a> AddAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> Add<Integer> for &'a Float
[src]
impl<'a> Add<Integer> for &'a Float
type Output = AddOwnedIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>
[src]
fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>
Performs the +
operation.
impl Add<Float> for Integer
[src]
impl Add<Float> for Integer
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for Integer
[src]
impl<'a> Add<&'a Float> for Integer
type Output = AddOwnedIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddOwnedIntegerIncomplete
[src]
fn add(self, rhs: &Float) -> AddOwnedIntegerIncomplete
Performs the +
operation.
impl<'a> Add<Float> for &'a Integer
[src]
impl<'a> Add<Float> for &'a Integer
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for &'a Integer
[src]
impl<'a> Add<&'a Float> for &'a Integer
type Output = AddIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddIntegerIncomplete
[src]
fn add(self, rhs: &'a Float) -> AddIntegerIncomplete
Performs the +
operation.
impl AddFrom<Integer> for Float
[src]
impl AddFrom<Integer> for Float
impl<'a> AddFrom<&'a Integer> for Float
[src]
impl<'a> AddFrom<&'a Integer> for Float
impl AddFromRound<Integer> for Float
[src]
impl AddFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddFromRound<&'a Integer> for Float
[src]
impl<'a> AddFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<Integer> for Float
[src]
impl Sub<Integer> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Float
[src]
fn sub(self, rhs: Integer) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Integer> for Float
[src]
impl<'a> Sub<&'a Integer> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &Integer) -> Float
[src]
fn sub(self, rhs: &Integer) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Integer> for &'a Float
[src]
impl<'a> Sub<&'a Integer> for &'a Float
type Output = SubIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete
[src]
fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete
Performs the -
operation.
impl SubAssign<Integer> for Float
[src]
impl SubAssign<Integer> for Float
fn sub_assign(&mut self, rhs: Integer)
[src]
fn sub_assign(&mut self, rhs: Integer)
Performs the -=
operation.
impl<'a> SubAssign<&'a Integer> for Float
[src]
impl<'a> SubAssign<&'a Integer> for Float
fn sub_assign(&mut self, rhs: &Integer)
[src]
fn sub_assign(&mut self, rhs: &Integer)
Performs the -=
operation.
impl SubAssignRound<Integer> for Float
[src]
impl SubAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Integer> for Float
[src]
impl<'a> SubAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> Sub<Integer> for &'a Float
[src]
impl<'a> Sub<Integer> for &'a Float
type Output = SubFromIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a>
[src]
fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a>
Performs the -
operation.
impl Sub<Float> for Integer
[src]
impl Sub<Float> for Integer
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for Integer
[src]
impl<'a> Sub<&'a Float> for Integer
type Output = SubFromOwnedIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromOwnedIntegerIncomplete
[src]
fn sub(self, rhs: &Float) -> SubFromOwnedIntegerIncomplete
Performs the -
operation.
impl<'a> Sub<Float> for &'a Integer
[src]
impl<'a> Sub<Float> for &'a Integer
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for &'a Integer
[src]
impl<'a> Sub<&'a Float> for &'a Integer
type Output = SubOwnedIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubOwnedIntegerIncomplete
[src]
fn sub(self, rhs: &'a Float) -> SubOwnedIntegerIncomplete
Performs the -
operation.
impl SubFrom<Integer> for Float
[src]
impl SubFrom<Integer> for Float
impl<'a> SubFrom<&'a Integer> for Float
[src]
impl<'a> SubFrom<&'a Integer> for Float
impl SubFromRound<Integer> for Float
[src]
impl SubFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Integer> for Float
[src]
impl<'a> SubFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<Integer> for Float
[src]
impl Mul<Integer> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Float
[src]
fn mul(self, rhs: Integer) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Integer> for Float
[src]
impl<'a> Mul<&'a Integer> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> Float
[src]
fn mul(self, rhs: &Integer) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Integer> for &'a Float
[src]
impl<'a> Mul<&'a Integer> for &'a Float
type Output = MulIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete
[src]
fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete
Performs the *
operation.
impl MulAssign<Integer> for Float
[src]
impl MulAssign<Integer> for Float
fn mul_assign(&mut self, rhs: Integer)
[src]
fn mul_assign(&mut self, rhs: Integer)
Performs the *=
operation.
impl<'a> MulAssign<&'a Integer> for Float
[src]
impl<'a> MulAssign<&'a Integer> for Float
fn mul_assign(&mut self, rhs: &Integer)
[src]
fn mul_assign(&mut self, rhs: &Integer)
Performs the *=
operation.
impl MulAssignRound<Integer> for Float
[src]
impl MulAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Integer> for Float
[src]
impl<'a> MulAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> Mul<Integer> for &'a Float
[src]
impl<'a> Mul<Integer> for &'a Float
type Output = MulOwnedIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>
[src]
fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>
Performs the *
operation.
impl Mul<Float> for Integer
[src]
impl Mul<Float> for Integer
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for Integer
[src]
impl<'a> Mul<&'a Float> for Integer
type Output = MulOwnedIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulOwnedIntegerIncomplete
[src]
fn mul(self, rhs: &Float) -> MulOwnedIntegerIncomplete
Performs the *
operation.
impl<'a> Mul<Float> for &'a Integer
[src]
impl<'a> Mul<Float> for &'a Integer
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for &'a Integer
[src]
impl<'a> Mul<&'a Float> for &'a Integer
type Output = MulIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulIntegerIncomplete
[src]
fn mul(self, rhs: &'a Float) -> MulIntegerIncomplete
Performs the *
operation.
impl MulFrom<Integer> for Float
[src]
impl MulFrom<Integer> for Float
impl<'a> MulFrom<&'a Integer> for Float
[src]
impl<'a> MulFrom<&'a Integer> for Float
impl MulFromRound<Integer> for Float
[src]
impl MulFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Integer> for Float
[src]
impl<'a> MulFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<Integer> for Float
[src]
impl Div<Integer> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Float
[src]
fn div(self, rhs: Integer) -> Float
Performs the /
operation.
impl<'a> Div<&'a Integer> for Float
[src]
impl<'a> Div<&'a Integer> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &Integer) -> Float
[src]
fn div(self, rhs: &Integer) -> Float
Performs the /
operation.
impl<'a> Div<&'a Integer> for &'a Float
[src]
impl<'a> Div<&'a Integer> for &'a Float
type Output = DivIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete
[src]
fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete
Performs the /
operation.
impl DivAssign<Integer> for Float
[src]
impl DivAssign<Integer> for Float
fn div_assign(&mut self, rhs: Integer)
[src]
fn div_assign(&mut self, rhs: Integer)
Performs the /=
operation.
impl<'a> DivAssign<&'a Integer> for Float
[src]
impl<'a> DivAssign<&'a Integer> for Float
fn div_assign(&mut self, rhs: &Integer)
[src]
fn div_assign(&mut self, rhs: &Integer)
Performs the /=
operation.
impl DivAssignRound<Integer> for Float
[src]
impl DivAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivAssignRound<&'a Integer> for Float
[src]
impl<'a> DivAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
Performs the division. Read more
impl<'a> Div<Integer> for &'a Float
[src]
impl<'a> Div<Integer> for &'a Float
type Output = DivFromIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> DivFromIntegerIncomplete<'a>
[src]
fn div(self, rhs: Integer) -> DivFromIntegerIncomplete<'a>
Performs the /
operation.
impl Div<Float> for Integer
[src]
impl Div<Float> for Integer
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for Integer
[src]
impl<'a> Div<&'a Float> for Integer
type Output = DivFromOwnedIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromOwnedIntegerIncomplete
[src]
fn div(self, rhs: &Float) -> DivFromOwnedIntegerIncomplete
Performs the /
operation.
impl<'a> Div<Float> for &'a Integer
[src]
impl<'a> Div<Float> for &'a Integer
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for &'a Integer
[src]
impl<'a> Div<&'a Float> for &'a Integer
type Output = DivOwnedIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivOwnedIntegerIncomplete
[src]
fn div(self, rhs: &'a Float) -> DivOwnedIntegerIncomplete
Performs the /
operation.
impl DivFrom<Integer> for Float
[src]
impl DivFrom<Integer> for Float
impl<'a> DivFrom<&'a Integer> for Float
[src]
impl<'a> DivFrom<&'a Integer> for Float
impl DivFromRound<Integer> for Float
[src]
impl DivFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: Integer, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivFromRound<&'a Integer> for Float
[src]
impl<'a> DivFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering
Performs the division. Read more
impl Pow<Integer> for Float
[src]
impl Pow<Integer> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> Float
[src]
fn pow(self, rhs: Integer) -> Float
Performs the power operation. Read more
impl<'a> Pow<&'a Integer> for Float
[src]
impl<'a> Pow<&'a Integer> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &Integer) -> Float
[src]
fn pow(self, rhs: &Integer) -> Float
Performs the power operation. Read more
impl<'a> Pow<&'a Integer> for &'a Float
[src]
impl<'a> Pow<&'a Integer> for &'a Float
type Output = PowIntegerIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete
[src]
fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete
Performs the power operation. Read more
impl PowAssign<Integer> for Float
[src]
impl PowAssign<Integer> for Float
fn pow_assign(&mut self, rhs: Integer)
[src]
fn pow_assign(&mut self, rhs: Integer)
Peforms the power operation. Read more
impl<'a> PowAssign<&'a Integer> for Float
[src]
impl<'a> PowAssign<&'a Integer> for Float
fn pow_assign(&mut self, rhs: &Integer)
[src]
fn pow_assign(&mut self, rhs: &Integer)
Peforms the power operation. Read more
impl PowAssignRound<Integer> for Float
[src]
impl PowAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering
Performs the power operation. Read more
impl<'a> PowAssignRound<&'a Integer> for Float
[src]
impl<'a> PowAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering
Performs the power operation. Read more
impl<'a> Pow<Integer> for &'a Float
[src]
impl<'a> Pow<Integer> for &'a Float
type Output = PowOwnedIntegerIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>
[src]
fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>
Performs the power operation. Read more
impl Add<Rational> for Float
[src]
impl Add<Rational> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> Float
[src]
fn add(self, rhs: Rational) -> Float
Performs the +
operation.
impl<'a> Add<&'a Rational> for Float
[src]
impl<'a> Add<&'a Rational> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &Rational) -> Float
[src]
fn add(self, rhs: &Rational) -> Float
Performs the +
operation.
impl<'a> Add<&'a Rational> for &'a Float
[src]
impl<'a> Add<&'a Rational> for &'a Float
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Rational) -> AddRationalIncomplete
[src]
fn add(self, rhs: &'a Rational) -> AddRationalIncomplete
Performs the +
operation.
impl AddAssign<Rational> for Float
[src]
impl AddAssign<Rational> for Float
fn add_assign(&mut self, rhs: Rational)
[src]
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation.
impl<'a> AddAssign<&'a Rational> for Float
[src]
impl<'a> AddAssign<&'a Rational> for Float
fn add_assign(&mut self, rhs: &Rational)
[src]
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation.
impl AddAssignRound<Rational> for Float
[src]
impl AddAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Rational> for Float
[src]
impl<'a> AddAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> Add<Rational> for &'a Float
[src]
impl<'a> Add<Rational> for &'a Float
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>
[src]
fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>
Performs the +
operation.
impl Add<Float> for Rational
[src]
impl Add<Float> for Rational
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for Rational
[src]
impl<'a> Add<&'a Float> for Rational
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddOwnedRationalIncomplete
[src]
fn add(self, rhs: &Float) -> AddOwnedRationalIncomplete
Performs the +
operation.
impl<'a> Add<Float> for &'a Rational
[src]
impl<'a> Add<Float> for &'a Rational
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for &'a Rational
[src]
impl<'a> Add<&'a Float> for &'a Rational
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddRationalIncomplete
[src]
fn add(self, rhs: &'a Float) -> AddRationalIncomplete
Performs the +
operation.
impl AddFrom<Rational> for Float
[src]
impl AddFrom<Rational> for Float
impl<'a> AddFrom<&'a Rational> for Float
[src]
impl<'a> AddFrom<&'a Rational> for Float
impl AddFromRound<Rational> for Float
[src]
impl AddFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddFromRound<&'a Rational> for Float
[src]
impl<'a> AddFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<Rational> for Float
[src]
impl Sub<Rational> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> Float
[src]
fn sub(self, rhs: Rational) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Rational> for Float
[src]
impl<'a> Sub<&'a Rational> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &Rational) -> Float
[src]
fn sub(self, rhs: &Rational) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Rational> for &'a Float
[src]
impl<'a> Sub<&'a Rational> for &'a Float
type Output = SubRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete
[src]
fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete
Performs the -
operation.
impl SubAssign<Rational> for Float
[src]
impl SubAssign<Rational> for Float
fn sub_assign(&mut self, rhs: Rational)
[src]
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation.
impl<'a> SubAssign<&'a Rational> for Float
[src]
impl<'a> SubAssign<&'a Rational> for Float
fn sub_assign(&mut self, rhs: &Rational)
[src]
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation.
impl SubAssignRound<Rational> for Float
[src]
impl SubAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Rational> for Float
[src]
impl<'a> SubAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> Sub<Rational> for &'a Float
[src]
impl<'a> Sub<Rational> for &'a Float
type Output = SubFromRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>
[src]
fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>
Performs the -
operation.
impl Sub<Float> for Rational
[src]
impl Sub<Float> for Rational
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for Rational
[src]
impl<'a> Sub<&'a Float> for Rational
type Output = SubFromOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromOwnedRationalIncomplete
[src]
fn sub(self, rhs: &Float) -> SubFromOwnedRationalIncomplete
Performs the -
operation.
impl<'a> Sub<Float> for &'a Rational
[src]
impl<'a> Sub<Float> for &'a Rational
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for &'a Rational
[src]
impl<'a> Sub<&'a Float> for &'a Rational
type Output = SubOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubOwnedRationalIncomplete
[src]
fn sub(self, rhs: &'a Float) -> SubOwnedRationalIncomplete
Performs the -
operation.
impl SubFrom<Rational> for Float
[src]
impl SubFrom<Rational> for Float
impl<'a> SubFrom<&'a Rational> for Float
[src]
impl<'a> SubFrom<&'a Rational> for Float
impl SubFromRound<Rational> for Float
[src]
impl SubFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Rational> for Float
[src]
impl<'a> SubFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<Rational> for Float
[src]
impl Mul<Rational> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> Float
[src]
fn mul(self, rhs: Rational) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Rational> for Float
[src]
impl<'a> Mul<&'a Rational> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &Rational) -> Float
[src]
fn mul(self, rhs: &Rational) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Rational> for &'a Float
[src]
impl<'a> Mul<&'a Rational> for &'a Float
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete
[src]
fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete
Performs the *
operation.
impl MulAssign<Rational> for Float
[src]
impl MulAssign<Rational> for Float
fn mul_assign(&mut self, rhs: Rational)
[src]
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation.
impl<'a> MulAssign<&'a Rational> for Float
[src]
impl<'a> MulAssign<&'a Rational> for Float
fn mul_assign(&mut self, rhs: &Rational)
[src]
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation.
impl MulAssignRound<Rational> for Float
[src]
impl MulAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Rational> for Float
[src]
impl<'a> MulAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> Mul<Rational> for &'a Float
[src]
impl<'a> Mul<Rational> for &'a Float
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>
[src]
fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>
Performs the *
operation.
impl Mul<Float> for Rational
[src]
impl Mul<Float> for Rational
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for Rational
[src]
impl<'a> Mul<&'a Float> for Rational
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulOwnedRationalIncomplete
[src]
fn mul(self, rhs: &Float) -> MulOwnedRationalIncomplete
Performs the *
operation.
impl<'a> Mul<Float> for &'a Rational
[src]
impl<'a> Mul<Float> for &'a Rational
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for &'a Rational
[src]
impl<'a> Mul<&'a Float> for &'a Rational
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulRationalIncomplete
[src]
fn mul(self, rhs: &'a Float) -> MulRationalIncomplete
Performs the *
operation.
impl MulFrom<Rational> for Float
[src]
impl MulFrom<Rational> for Float
impl<'a> MulFrom<&'a Rational> for Float
[src]
impl<'a> MulFrom<&'a Rational> for Float
impl MulFromRound<Rational> for Float
[src]
impl MulFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Rational> for Float
[src]
impl<'a> MulFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<Rational> for Float
[src]
impl Div<Rational> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> Float
[src]
fn div(self, rhs: Rational) -> Float
Performs the /
operation.
impl<'a> Div<&'a Rational> for Float
[src]
impl<'a> Div<&'a Rational> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &Rational) -> Float
[src]
fn div(self, rhs: &Rational) -> Float
Performs the /
operation.
impl<'a> Div<&'a Rational> for &'a Float
[src]
impl<'a> Div<&'a Rational> for &'a Float
type Output = DivRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Rational) -> DivRationalIncomplete
[src]
fn div(self, rhs: &'a Rational) -> DivRationalIncomplete
Performs the /
operation.
impl DivAssign<Rational> for Float
[src]
impl DivAssign<Rational> for Float
fn div_assign(&mut self, rhs: Rational)
[src]
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation.
impl<'a> DivAssign<&'a Rational> for Float
[src]
impl<'a> DivAssign<&'a Rational> for Float
fn div_assign(&mut self, rhs: &Rational)
[src]
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation.
impl DivAssignRound<Rational> for Float
[src]
impl DivAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivAssignRound<&'a Rational> for Float
[src]
impl<'a> DivAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the division. Read more
impl<'a> Div<Rational> for &'a Float
[src]
impl<'a> Div<Rational> for &'a Float
type Output = DivFromRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> DivFromRationalIncomplete<'a>
[src]
fn div(self, rhs: Rational) -> DivFromRationalIncomplete<'a>
Performs the /
operation.
impl Div<Float> for Rational
[src]
impl Div<Float> for Rational
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for Rational
[src]
impl<'a> Div<&'a Float> for Rational
type Output = DivFromOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromOwnedRationalIncomplete
[src]
fn div(self, rhs: &Float) -> DivFromOwnedRationalIncomplete
Performs the /
operation.
impl<'a> Div<Float> for &'a Rational
[src]
impl<'a> Div<Float> for &'a Rational
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for &'a Rational
[src]
impl<'a> Div<&'a Float> for &'a Rational
type Output = DivOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivOwnedRationalIncomplete
[src]
fn div(self, rhs: &'a Float) -> DivOwnedRationalIncomplete
Performs the /
operation.
impl DivFrom<Rational> for Float
[src]
impl DivFrom<Rational> for Float
impl<'a> DivFrom<&'a Rational> for Float
[src]
impl<'a> DivFrom<&'a Rational> for Float
impl DivFromRound<Rational> for Float
[src]
impl DivFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivFromRound<&'a Rational> for Float
[src]
impl<'a> DivFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the division. Read more
impl Add<i32> for Float
[src]
impl Add<i32> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> Float
[src]
fn add(self, rhs: i32) -> Float
Performs the +
operation.
impl<'t> Add<&'t i32> for Float
[src]
impl<'t> Add<&'t i32> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &i32) -> Float
[src]
fn add(self, rhs: &i32) -> Float
Performs the +
operation.
impl<'b> Add<i32> for &'b Float
[src]
impl<'b> Add<i32> for &'b Float
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> AddI32Incomplete<'b>
[src]
fn add(self, rhs: i32) -> AddI32Incomplete<'b>
Performs the +
operation.
impl<'t, 'b> Add<&'t i32> for &'b Float
[src]
impl<'t, 'b> Add<&'t i32> for &'b Float
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &i32) -> AddI32Incomplete<'b>
[src]
fn add(self, rhs: &i32) -> AddI32Incomplete<'b>
Performs the +
operation.
impl AddAssign<i32> for Float
[src]
impl AddAssign<i32> for Float
fn add_assign(&mut self, rhs: i32)
[src]
fn add_assign(&mut self, rhs: i32)
Performs the +=
operation.
impl<'t> AddAssign<&'t i32> for Float
[src]
impl<'t> AddAssign<&'t i32> for Float
fn add_assign(&mut self, rhs: &i32)
[src]
fn add_assign(&mut self, rhs: &i32)
Performs the +=
operation.
impl AddAssignRound<i32> for Float
[src]
impl AddAssignRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddAssignRound<&'t i32> for Float
[src]
impl<'t> AddAssignRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
Performs the addition. Read more
impl Add<Float> for i32
[src]
impl Add<Float> for i32
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for i32
[src]
impl<'a> Add<&'a Float> for i32
type Output = AddI32Incomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddI32Incomplete
[src]
fn add(self, rhs: &Float) -> AddI32Incomplete
Performs the +
operation.
impl<'t> Add<Float> for &'t i32
[src]
impl<'t> Add<Float> for &'t i32
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'b, 't> Add<&'b Float> for &'t i32
[src]
impl<'b, 't> Add<&'b Float> for &'t i32
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Float) -> AddI32Incomplete<'b>
[src]
fn add(self, rhs: &'b Float) -> AddI32Incomplete<'b>
Performs the +
operation.
impl AddFrom<i32> for Float
[src]
impl AddFrom<i32> for Float
impl<'t> AddFrom<&'t i32> for Float
[src]
impl<'t> AddFrom<&'t i32> for Float
impl AddFromRound<i32> for Float
[src]
impl AddFromRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: i32, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: i32, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddFromRound<&'t i32> for Float
[src]
impl<'t> AddFromRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<i32> for Float
[src]
impl Sub<i32> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> Float
[src]
fn sub(self, rhs: i32) -> Float
Performs the -
operation.
impl<'t> Sub<&'t i32> for Float
[src]
impl<'t> Sub<&'t i32> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &i32) -> Float
[src]
fn sub(self, rhs: &i32) -> Float
Performs the -
operation.
impl<'b> Sub<i32> for &'b Float
[src]
impl<'b> Sub<i32> for &'b Float
type Output = SubI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> SubI32Incomplete<'b>
[src]
fn sub(self, rhs: i32) -> SubI32Incomplete<'b>
Performs the -
operation.
impl<'t, 'b> Sub<&'t i32> for &'b Float
[src]
impl<'t, 'b> Sub<&'t i32> for &'b Float
type Output = SubI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &i32) -> SubI32Incomplete<'b>
[src]
fn sub(self, rhs: &i32) -> SubI32Incomplete<'b>
Performs the -
operation.
impl SubAssign<i32> for Float
[src]
impl SubAssign<i32> for Float
fn sub_assign(&mut self, rhs: i32)
[src]
fn sub_assign(&mut self, rhs: i32)
Performs the -=
operation.
impl<'t> SubAssign<&'t i32> for Float
[src]
impl<'t> SubAssign<&'t i32> for Float
fn sub_assign(&mut self, rhs: &i32)
[src]
fn sub_assign(&mut self, rhs: &i32)
Performs the -=
operation.
impl SubAssignRound<i32> for Float
[src]
impl SubAssignRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubAssignRound<&'t i32> for Float
[src]
impl<'t> SubAssignRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
Performs the subtraction. Read more
impl Sub<Float> for i32
[src]
impl Sub<Float> for i32
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b> Sub<&'b Float> for i32
[src]
impl<'b> Sub<&'b Float> for i32
type Output = SubFromI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromI32Incomplete
[src]
fn sub(self, rhs: &Float) -> SubFromI32Incomplete
Performs the -
operation.
impl<'t> Sub<Float> for &'t i32
[src]
impl<'t> Sub<Float> for &'t i32
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b, 't> Sub<&'b Float> for &'t i32
[src]
impl<'b, 't> Sub<&'b Float> for &'t i32
type Output = SubFromI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Float) -> SubFromI32Incomplete<'b>
[src]
fn sub(self, rhs: &'b Float) -> SubFromI32Incomplete<'b>
Performs the -
operation.
impl SubFrom<i32> for Float
[src]
impl SubFrom<i32> for Float
impl<'t> SubFrom<&'t i32> for Float
[src]
impl<'t> SubFrom<&'t i32> for Float
impl SubFromRound<i32> for Float
[src]
impl SubFromRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: i32, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: i32, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubFromRound<&'t i32> for Float
[src]
impl<'t> SubFromRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<i32> for Float
[src]
impl Mul<i32> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> Float
[src]
fn mul(self, rhs: i32) -> Float
Performs the *
operation.
impl<'t> Mul<&'t i32> for Float
[src]
impl<'t> Mul<&'t i32> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &i32) -> Float
[src]
fn mul(self, rhs: &i32) -> Float
Performs the *
operation.
impl<'b> Mul<i32> for &'b Float
[src]
impl<'b> Mul<i32> for &'b Float
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> MulI32Incomplete<'b>
[src]
fn mul(self, rhs: i32) -> MulI32Incomplete<'b>
Performs the *
operation.
impl<'t, 'b> Mul<&'t i32> for &'b Float
[src]
impl<'t, 'b> Mul<&'t i32> for &'b Float
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &i32) -> MulI32Incomplete<'b>
[src]
fn mul(self, rhs: &i32) -> MulI32Incomplete<'b>
Performs the *
operation.
impl MulAssign<i32> for Float
[src]
impl MulAssign<i32> for Float
fn mul_assign(&mut self, rhs: i32)
[src]
fn mul_assign(&mut self, rhs: i32)
Performs the *=
operation.
impl<'t> MulAssign<&'t i32> for Float
[src]
impl<'t> MulAssign<&'t i32> for Float
fn mul_assign(&mut self, rhs: &i32)
[src]
fn mul_assign(&mut self, rhs: &i32)
Performs the *=
operation.
impl MulAssignRound<i32> for Float
[src]
impl MulAssignRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulAssignRound<&'t i32> for Float
[src]
impl<'t> MulAssignRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
Performs the multiplication. Read more
impl Mul<Float> for i32
[src]
impl Mul<Float> for i32
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for i32
[src]
impl<'a> Mul<&'a Float> for i32
type Output = MulI32Incomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulI32Incomplete
[src]
fn mul(self, rhs: &Float) -> MulI32Incomplete
Performs the *
operation.
impl<'t> Mul<Float> for &'t i32
[src]
impl<'t> Mul<Float> for &'t i32
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'b, 't> Mul<&'b Float> for &'t i32
[src]
impl<'b, 't> Mul<&'b Float> for &'t i32
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Float) -> MulI32Incomplete<'b>
[src]
fn mul(self, rhs: &'b Float) -> MulI32Incomplete<'b>
Performs the *
operation.
impl MulFrom<i32> for Float
[src]
impl MulFrom<i32> for Float
impl<'t> MulFrom<&'t i32> for Float
[src]
impl<'t> MulFrom<&'t i32> for Float
impl MulFromRound<i32> for Float
[src]
impl MulFromRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: i32, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: i32, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulFromRound<&'t i32> for Float
[src]
impl<'t> MulFromRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<i32> for Float
[src]
impl Div<i32> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> Float
[src]
fn div(self, rhs: i32) -> Float
Performs the /
operation.
impl<'t> Div<&'t i32> for Float
[src]
impl<'t> Div<&'t i32> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &i32) -> Float
[src]
fn div(self, rhs: &i32) -> Float
Performs the /
operation.
impl<'b> Div<i32> for &'b Float
[src]
impl<'b> Div<i32> for &'b Float
type Output = DivI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> DivI32Incomplete<'b>
[src]
fn div(self, rhs: i32) -> DivI32Incomplete<'b>
Performs the /
operation.
impl<'t, 'b> Div<&'t i32> for &'b Float
[src]
impl<'t, 'b> Div<&'t i32> for &'b Float
type Output = DivI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &i32) -> DivI32Incomplete<'b>
[src]
fn div(self, rhs: &i32) -> DivI32Incomplete<'b>
Performs the /
operation.
impl DivAssign<i32> for Float
[src]
impl DivAssign<i32> for Float
fn div_assign(&mut self, rhs: i32)
[src]
fn div_assign(&mut self, rhs: i32)
Performs the /=
operation.
impl<'t> DivAssign<&'t i32> for Float
[src]
impl<'t> DivAssign<&'t i32> for Float
fn div_assign(&mut self, rhs: &i32)
[src]
fn div_assign(&mut self, rhs: &i32)
Performs the /=
operation.
impl DivAssignRound<i32> for Float
[src]
impl DivAssignRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivAssignRound<&'t i32> for Float
[src]
impl<'t> DivAssignRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
Performs the division. Read more
impl Div<Float> for i32
[src]
impl Div<Float> for i32
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b> Div<&'b Float> for i32
[src]
impl<'b> Div<&'b Float> for i32
type Output = DivFromI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromI32Incomplete
[src]
fn div(self, rhs: &Float) -> DivFromI32Incomplete
Performs the /
operation.
impl<'t> Div<Float> for &'t i32
[src]
impl<'t> Div<Float> for &'t i32
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b, 't> Div<&'b Float> for &'t i32
[src]
impl<'b, 't> Div<&'b Float> for &'t i32
type Output = DivFromI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b Float) -> DivFromI32Incomplete<'b>
[src]
fn div(self, rhs: &'b Float) -> DivFromI32Incomplete<'b>
Performs the /
operation.
impl DivFrom<i32> for Float
[src]
impl DivFrom<i32> for Float
impl<'t> DivFrom<&'t i32> for Float
[src]
impl<'t> DivFrom<&'t i32> for Float
impl DivFromRound<i32> for Float
[src]
impl DivFromRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: i32, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: i32, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivFromRound<&'t i32> for Float
[src]
impl<'t> DivFromRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
Performs the division. Read more
impl Add<u32> for Float
[src]
impl Add<u32> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> Float
[src]
fn add(self, rhs: u32) -> Float
Performs the +
operation.
impl<'t> Add<&'t u32> for Float
[src]
impl<'t> Add<&'t u32> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &u32) -> Float
[src]
fn add(self, rhs: &u32) -> Float
Performs the +
operation.
impl<'b> Add<u32> for &'b Float
[src]
impl<'b> Add<u32> for &'b Float
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> AddU32Incomplete<'b>
[src]
fn add(self, rhs: u32) -> AddU32Incomplete<'b>
Performs the +
operation.
impl<'t, 'b> Add<&'t u32> for &'b Float
[src]
impl<'t, 'b> Add<&'t u32> for &'b Float
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &u32) -> AddU32Incomplete<'b>
[src]
fn add(self, rhs: &u32) -> AddU32Incomplete<'b>
Performs the +
operation.
impl AddAssign<u32> for Float
[src]
impl AddAssign<u32> for Float
fn add_assign(&mut self, rhs: u32)
[src]
fn add_assign(&mut self, rhs: u32)
Performs the +=
operation.
impl<'t> AddAssign<&'t u32> for Float
[src]
impl<'t> AddAssign<&'t u32> for Float
fn add_assign(&mut self, rhs: &u32)
[src]
fn add_assign(&mut self, rhs: &u32)
Performs the +=
operation.
impl AddAssignRound<u32> for Float
[src]
impl AddAssignRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddAssignRound<&'t u32> for Float
[src]
impl<'t> AddAssignRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
Performs the addition. Read more
impl Add<Float> for u32
[src]
impl Add<Float> for u32
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for u32
[src]
impl<'a> Add<&'a Float> for u32
type Output = AddU32Incomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddU32Incomplete
[src]
fn add(self, rhs: &Float) -> AddU32Incomplete
Performs the +
operation.
impl<'t> Add<Float> for &'t u32
[src]
impl<'t> Add<Float> for &'t u32
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'b, 't> Add<&'b Float> for &'t u32
[src]
impl<'b, 't> Add<&'b Float> for &'t u32
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Float) -> AddU32Incomplete<'b>
[src]
fn add(self, rhs: &'b Float) -> AddU32Incomplete<'b>
Performs the +
operation.
impl AddFrom<u32> for Float
[src]
impl AddFrom<u32> for Float
impl<'t> AddFrom<&'t u32> for Float
[src]
impl<'t> AddFrom<&'t u32> for Float
impl AddFromRound<u32> for Float
[src]
impl AddFromRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: u32, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: u32, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddFromRound<&'t u32> for Float
[src]
impl<'t> AddFromRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<u32> for Float
[src]
impl Sub<u32> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> Float
[src]
fn sub(self, rhs: u32) -> Float
Performs the -
operation.
impl<'t> Sub<&'t u32> for Float
[src]
impl<'t> Sub<&'t u32> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &u32) -> Float
[src]
fn sub(self, rhs: &u32) -> Float
Performs the -
operation.
impl<'b> Sub<u32> for &'b Float
[src]
impl<'b> Sub<u32> for &'b Float
type Output = SubU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> SubU32Incomplete<'b>
[src]
fn sub(self, rhs: u32) -> SubU32Incomplete<'b>
Performs the -
operation.
impl<'t, 'b> Sub<&'t u32> for &'b Float
[src]
impl<'t, 'b> Sub<&'t u32> for &'b Float
type Output = SubU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &u32) -> SubU32Incomplete<'b>
[src]
fn sub(self, rhs: &u32) -> SubU32Incomplete<'b>
Performs the -
operation.
impl SubAssign<u32> for Float
[src]
impl SubAssign<u32> for Float
fn sub_assign(&mut self, rhs: u32)
[src]
fn sub_assign(&mut self, rhs: u32)
Performs the -=
operation.
impl<'t> SubAssign<&'t u32> for Float
[src]
impl<'t> SubAssign<&'t u32> for Float
fn sub_assign(&mut self, rhs: &u32)
[src]
fn sub_assign(&mut self, rhs: &u32)
Performs the -=
operation.
impl SubAssignRound<u32> for Float
[src]
impl SubAssignRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubAssignRound<&'t u32> for Float
[src]
impl<'t> SubAssignRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
Performs the subtraction. Read more
impl Sub<Float> for u32
[src]
impl Sub<Float> for u32
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b> Sub<&'b Float> for u32
[src]
impl<'b> Sub<&'b Float> for u32
type Output = SubFromU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromU32Incomplete
[src]
fn sub(self, rhs: &Float) -> SubFromU32Incomplete
Performs the -
operation.
impl<'t> Sub<Float> for &'t u32
[src]
impl<'t> Sub<Float> for &'t u32
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b, 't> Sub<&'b Float> for &'t u32
[src]
impl<'b, 't> Sub<&'b Float> for &'t u32
type Output = SubFromU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Float) -> SubFromU32Incomplete<'b>
[src]
fn sub(self, rhs: &'b Float) -> SubFromU32Incomplete<'b>
Performs the -
operation.
impl SubFrom<u32> for Float
[src]
impl SubFrom<u32> for Float
impl<'t> SubFrom<&'t u32> for Float
[src]
impl<'t> SubFrom<&'t u32> for Float
impl SubFromRound<u32> for Float
[src]
impl SubFromRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: u32, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: u32, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubFromRound<&'t u32> for Float
[src]
impl<'t> SubFromRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<u32> for Float
[src]
impl Mul<u32> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> Float
[src]
fn mul(self, rhs: u32) -> Float
Performs the *
operation.
impl<'t> Mul<&'t u32> for Float
[src]
impl<'t> Mul<&'t u32> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &u32) -> Float
[src]
fn mul(self, rhs: &u32) -> Float
Performs the *
operation.
impl<'b> Mul<u32> for &'b Float
[src]
impl<'b> Mul<u32> for &'b Float
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> MulU32Incomplete<'b>
[src]
fn mul(self, rhs: u32) -> MulU32Incomplete<'b>
Performs the *
operation.
impl<'t, 'b> Mul<&'t u32> for &'b Float
[src]
impl<'t, 'b> Mul<&'t u32> for &'b Float
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &u32) -> MulU32Incomplete<'b>
[src]
fn mul(self, rhs: &u32) -> MulU32Incomplete<'b>
Performs the *
operation.
impl MulAssign<u32> for Float
[src]
impl MulAssign<u32> for Float
fn mul_assign(&mut self, rhs: u32)
[src]
fn mul_assign(&mut self, rhs: u32)
Performs the *=
operation.
impl<'t> MulAssign<&'t u32> for Float
[src]
impl<'t> MulAssign<&'t u32> for Float
fn mul_assign(&mut self, rhs: &u32)
[src]
fn mul_assign(&mut self, rhs: &u32)
Performs the *=
operation.
impl MulAssignRound<u32> for Float
[src]
impl MulAssignRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulAssignRound<&'t u32> for Float
[src]
impl<'t> MulAssignRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
Performs the multiplication. Read more
impl Mul<Float> for u32
[src]
impl Mul<Float> for u32
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for u32
[src]
impl<'a> Mul<&'a Float> for u32
type Output = MulU32Incomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulU32Incomplete
[src]
fn mul(self, rhs: &Float) -> MulU32Incomplete
Performs the *
operation.
impl<'t> Mul<Float> for &'t u32
[src]
impl<'t> Mul<Float> for &'t u32
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'b, 't> Mul<&'b Float> for &'t u32
[src]
impl<'b, 't> Mul<&'b Float> for &'t u32
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Float) -> MulU32Incomplete<'b>
[src]
fn mul(self, rhs: &'b Float) -> MulU32Incomplete<'b>
Performs the *
operation.
impl MulFrom<u32> for Float
[src]
impl MulFrom<u32> for Float
impl<'t> MulFrom<&'t u32> for Float
[src]
impl<'t> MulFrom<&'t u32> for Float
impl MulFromRound<u32> for Float
[src]
impl MulFromRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: u32, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: u32, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulFromRound<&'t u32> for Float
[src]
impl<'t> MulFromRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<u32> for Float
[src]
impl Div<u32> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> Float
[src]
fn div(self, rhs: u32) -> Float
Performs the /
operation.
impl<'t> Div<&'t u32> for Float
[src]
impl<'t> Div<&'t u32> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &u32) -> Float
[src]
fn div(self, rhs: &u32) -> Float
Performs the /
operation.
impl<'b> Div<u32> for &'b Float
[src]
impl<'b> Div<u32> for &'b Float
type Output = DivU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> DivU32Incomplete<'b>
[src]
fn div(self, rhs: u32) -> DivU32Incomplete<'b>
Performs the /
operation.
impl<'t, 'b> Div<&'t u32> for &'b Float
[src]
impl<'t, 'b> Div<&'t u32> for &'b Float
type Output = DivU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &u32) -> DivU32Incomplete<'b>
[src]
fn div(self, rhs: &u32) -> DivU32Incomplete<'b>
Performs the /
operation.
impl DivAssign<u32> for Float
[src]
impl DivAssign<u32> for Float
fn div_assign(&mut self, rhs: u32)
[src]
fn div_assign(&mut self, rhs: u32)
Performs the /=
operation.
impl<'t> DivAssign<&'t u32> for Float
[src]
impl<'t> DivAssign<&'t u32> for Float
fn div_assign(&mut self, rhs: &u32)
[src]
fn div_assign(&mut self, rhs: &u32)
Performs the /=
operation.
impl DivAssignRound<u32> for Float
[src]
impl DivAssignRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivAssignRound<&'t u32> for Float
[src]
impl<'t> DivAssignRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
Performs the division. Read more
impl Div<Float> for u32
[src]
impl Div<Float> for u32
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b> Div<&'b Float> for u32
[src]
impl<'b> Div<&'b Float> for u32
type Output = DivFromU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromU32Incomplete
[src]
fn div(self, rhs: &Float) -> DivFromU32Incomplete
Performs the /
operation.
impl<'t> Div<Float> for &'t u32
[src]
impl<'t> Div<Float> for &'t u32
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b, 't> Div<&'b Float> for &'t u32
[src]
impl<'b, 't> Div<&'b Float> for &'t u32
type Output = DivFromU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b Float) -> DivFromU32Incomplete<'b>
[src]
fn div(self, rhs: &'b Float) -> DivFromU32Incomplete<'b>
Performs the /
operation.
impl DivFrom<u32> for Float
[src]
impl DivFrom<u32> for Float
impl<'t> DivFrom<&'t u32> for Float
[src]
impl<'t> DivFrom<&'t u32> for Float
impl DivFromRound<u32> for Float
[src]
impl DivFromRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: u32, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: u32, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivFromRound<&'t u32> for Float
[src]
impl<'t> DivFromRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
Performs the division. Read more
impl Add<f32> for Float
[src]
impl Add<f32> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: f32) -> Float
[src]
fn add(self, rhs: f32) -> Float
Performs the +
operation.
impl<'t> Add<&'t f32> for Float
[src]
impl<'t> Add<&'t f32> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &f32) -> Float
[src]
fn add(self, rhs: &f32) -> Float
Performs the +
operation.
impl<'b> Add<f32> for &'b Float
[src]
impl<'b> Add<f32> for &'b Float
type Output = AddF32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: f32) -> AddF32Incomplete<'b>
[src]
fn add(self, rhs: f32) -> AddF32Incomplete<'b>
Performs the +
operation.
impl<'t, 'b> Add<&'t f32> for &'b Float
[src]
impl<'t, 'b> Add<&'t f32> for &'b Float
type Output = AddF32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &f32) -> AddF32Incomplete<'b>
[src]
fn add(self, rhs: &f32) -> AddF32Incomplete<'b>
Performs the +
operation.
impl AddAssign<f32> for Float
[src]
impl AddAssign<f32> for Float
fn add_assign(&mut self, rhs: f32)
[src]
fn add_assign(&mut self, rhs: f32)
Performs the +=
operation.
impl<'t> AddAssign<&'t f32> for Float
[src]
impl<'t> AddAssign<&'t f32> for Float
fn add_assign(&mut self, rhs: &f32)
[src]
fn add_assign(&mut self, rhs: &f32)
Performs the +=
operation.
impl AddAssignRound<f32> for Float
[src]
impl AddAssignRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddAssignRound<&'t f32> for Float
[src]
impl<'t> AddAssignRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
Performs the addition. Read more
impl Add<Float> for f32
[src]
impl Add<Float> for f32
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for f32
[src]
impl<'a> Add<&'a Float> for f32
type Output = AddF32Incomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddF32Incomplete
[src]
fn add(self, rhs: &Float) -> AddF32Incomplete
Performs the +
operation.
impl<'t> Add<Float> for &'t f32
[src]
impl<'t> Add<Float> for &'t f32
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'b, 't> Add<&'b Float> for &'t f32
[src]
impl<'b, 't> Add<&'b Float> for &'t f32
type Output = AddF32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Float) -> AddF32Incomplete<'b>
[src]
fn add(self, rhs: &'b Float) -> AddF32Incomplete<'b>
Performs the +
operation.
impl AddFrom<f32> for Float
[src]
impl AddFrom<f32> for Float
impl<'t> AddFrom<&'t f32> for Float
[src]
impl<'t> AddFrom<&'t f32> for Float
impl AddFromRound<f32> for Float
[src]
impl AddFromRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: f32, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: f32, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddFromRound<&'t f32> for Float
[src]
impl<'t> AddFromRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<f32> for Float
[src]
impl Sub<f32> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: f32) -> Float
[src]
fn sub(self, rhs: f32) -> Float
Performs the -
operation.
impl<'t> Sub<&'t f32> for Float
[src]
impl<'t> Sub<&'t f32> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &f32) -> Float
[src]
fn sub(self, rhs: &f32) -> Float
Performs the -
operation.
impl<'b> Sub<f32> for &'b Float
[src]
impl<'b> Sub<f32> for &'b Float
type Output = SubF32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: f32) -> SubF32Incomplete<'b>
[src]
fn sub(self, rhs: f32) -> SubF32Incomplete<'b>
Performs the -
operation.
impl<'t, 'b> Sub<&'t f32> for &'b Float
[src]
impl<'t, 'b> Sub<&'t f32> for &'b Float
type Output = SubF32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &f32) -> SubF32Incomplete<'b>
[src]
fn sub(self, rhs: &f32) -> SubF32Incomplete<'b>
Performs the -
operation.
impl SubAssign<f32> for Float
[src]
impl SubAssign<f32> for Float
fn sub_assign(&mut self, rhs: f32)
[src]
fn sub_assign(&mut self, rhs: f32)
Performs the -=
operation.
impl<'t> SubAssign<&'t f32> for Float
[src]
impl<'t> SubAssign<&'t f32> for Float
fn sub_assign(&mut self, rhs: &f32)
[src]
fn sub_assign(&mut self, rhs: &f32)
Performs the -=
operation.
impl SubAssignRound<f32> for Float
[src]
impl SubAssignRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubAssignRound<&'t f32> for Float
[src]
impl<'t> SubAssignRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
Performs the subtraction. Read more
impl Sub<Float> for f32
[src]
impl Sub<Float> for f32
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b> Sub<&'b Float> for f32
[src]
impl<'b> Sub<&'b Float> for f32
type Output = SubFromF32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromF32Incomplete
[src]
fn sub(self, rhs: &Float) -> SubFromF32Incomplete
Performs the -
operation.
impl<'t> Sub<Float> for &'t f32
[src]
impl<'t> Sub<Float> for &'t f32
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b, 't> Sub<&'b Float> for &'t f32
[src]
impl<'b, 't> Sub<&'b Float> for &'t f32
type Output = SubFromF32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Float) -> SubFromF32Incomplete<'b>
[src]
fn sub(self, rhs: &'b Float) -> SubFromF32Incomplete<'b>
Performs the -
operation.
impl SubFrom<f32> for Float
[src]
impl SubFrom<f32> for Float
impl<'t> SubFrom<&'t f32> for Float
[src]
impl<'t> SubFrom<&'t f32> for Float
impl SubFromRound<f32> for Float
[src]
impl SubFromRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: f32, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: f32, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubFromRound<&'t f32> for Float
[src]
impl<'t> SubFromRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<f32> for Float
[src]
impl Mul<f32> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: f32) -> Float
[src]
fn mul(self, rhs: f32) -> Float
Performs the *
operation.
impl<'t> Mul<&'t f32> for Float
[src]
impl<'t> Mul<&'t f32> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &f32) -> Float
[src]
fn mul(self, rhs: &f32) -> Float
Performs the *
operation.
impl<'b> Mul<f32> for &'b Float
[src]
impl<'b> Mul<f32> for &'b Float
type Output = MulF32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: f32) -> MulF32Incomplete<'b>
[src]
fn mul(self, rhs: f32) -> MulF32Incomplete<'b>
Performs the *
operation.
impl<'t, 'b> Mul<&'t f32> for &'b Float
[src]
impl<'t, 'b> Mul<&'t f32> for &'b Float
type Output = MulF32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &f32) -> MulF32Incomplete<'b>
[src]
fn mul(self, rhs: &f32) -> MulF32Incomplete<'b>
Performs the *
operation.
impl MulAssign<f32> for Float
[src]
impl MulAssign<f32> for Float
fn mul_assign(&mut self, rhs: f32)
[src]
fn mul_assign(&mut self, rhs: f32)
Performs the *=
operation.
impl<'t> MulAssign<&'t f32> for Float
[src]
impl<'t> MulAssign<&'t f32> for Float
fn mul_assign(&mut self, rhs: &f32)
[src]
fn mul_assign(&mut self, rhs: &f32)
Performs the *=
operation.
impl MulAssignRound<f32> for Float
[src]
impl MulAssignRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulAssignRound<&'t f32> for Float
[src]
impl<'t> MulAssignRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
Performs the multiplication. Read more
impl Mul<Float> for f32
[src]
impl Mul<Float> for f32
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for f32
[src]
impl<'a> Mul<&'a Float> for f32
type Output = MulF32Incomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulF32Incomplete
[src]
fn mul(self, rhs: &Float) -> MulF32Incomplete
Performs the *
operation.
impl<'t> Mul<Float> for &'t f32
[src]
impl<'t> Mul<Float> for &'t f32
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'b, 't> Mul<&'b Float> for &'t f32
[src]
impl<'b, 't> Mul<&'b Float> for &'t f32
type Output = MulF32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Float) -> MulF32Incomplete<'b>
[src]
fn mul(self, rhs: &'b Float) -> MulF32Incomplete<'b>
Performs the *
operation.
impl MulFrom<f32> for Float
[src]
impl MulFrom<f32> for Float
impl<'t> MulFrom<&'t f32> for Float
[src]
impl<'t> MulFrom<&'t f32> for Float
impl MulFromRound<f32> for Float
[src]
impl MulFromRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: f32, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: f32, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulFromRound<&'t f32> for Float
[src]
impl<'t> MulFromRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<f32> for Float
[src]
impl Div<f32> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: f32) -> Float
[src]
fn div(self, rhs: f32) -> Float
Performs the /
operation.
impl<'t> Div<&'t f32> for Float
[src]
impl<'t> Div<&'t f32> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &f32) -> Float
[src]
fn div(self, rhs: &f32) -> Float
Performs the /
operation.
impl<'b> Div<f32> for &'b Float
[src]
impl<'b> Div<f32> for &'b Float
type Output = DivF32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: f32) -> DivF32Incomplete<'b>
[src]
fn div(self, rhs: f32) -> DivF32Incomplete<'b>
Performs the /
operation.
impl<'t, 'b> Div<&'t f32> for &'b Float
[src]
impl<'t, 'b> Div<&'t f32> for &'b Float
type Output = DivF32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &f32) -> DivF32Incomplete<'b>
[src]
fn div(self, rhs: &f32) -> DivF32Incomplete<'b>
Performs the /
operation.
impl DivAssign<f32> for Float
[src]
impl DivAssign<f32> for Float
fn div_assign(&mut self, rhs: f32)
[src]
fn div_assign(&mut self, rhs: f32)
Performs the /=
operation.
impl<'t> DivAssign<&'t f32> for Float
[src]
impl<'t> DivAssign<&'t f32> for Float
fn div_assign(&mut self, rhs: &f32)
[src]
fn div_assign(&mut self, rhs: &f32)
Performs the /=
operation.
impl DivAssignRound<f32> for Float
[src]
impl DivAssignRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivAssignRound<&'t f32> for Float
[src]
impl<'t> DivAssignRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
Performs the division. Read more
impl Div<Float> for f32
[src]
impl Div<Float> for f32
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b> Div<&'b Float> for f32
[src]
impl<'b> Div<&'b Float> for f32
type Output = DivFromF32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromF32Incomplete
[src]
fn div(self, rhs: &Float) -> DivFromF32Incomplete
Performs the /
operation.
impl<'t> Div<Float> for &'t f32
[src]
impl<'t> Div<Float> for &'t f32
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b, 't> Div<&'b Float> for &'t f32
[src]
impl<'b, 't> Div<&'b Float> for &'t f32
type Output = DivFromF32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b Float) -> DivFromF32Incomplete<'b>
[src]
fn div(self, rhs: &'b Float) -> DivFromF32Incomplete<'b>
Performs the /
operation.
impl DivFrom<f32> for Float
[src]
impl DivFrom<f32> for Float
impl<'t> DivFrom<&'t f32> for Float
[src]
impl<'t> DivFrom<&'t f32> for Float
impl DivFromRound<f32> for Float
[src]
impl DivFromRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: f32, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: f32, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivFromRound<&'t f32> for Float
[src]
impl<'t> DivFromRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
Performs the division. Read more
impl Add<f64> for Float
[src]
impl Add<f64> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: f64) -> Float
[src]
fn add(self, rhs: f64) -> Float
Performs the +
operation.
impl<'t> Add<&'t f64> for Float
[src]
impl<'t> Add<&'t f64> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &f64) -> Float
[src]
fn add(self, rhs: &f64) -> Float
Performs the +
operation.
impl<'b> Add<f64> for &'b Float
[src]
impl<'b> Add<f64> for &'b Float
type Output = AddF64Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: f64) -> AddF64Incomplete<'b>
[src]
fn add(self, rhs: f64) -> AddF64Incomplete<'b>
Performs the +
operation.
impl<'t, 'b> Add<&'t f64> for &'b Float
[src]
impl<'t, 'b> Add<&'t f64> for &'b Float
type Output = AddF64Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &f64) -> AddF64Incomplete<'b>
[src]
fn add(self, rhs: &f64) -> AddF64Incomplete<'b>
Performs the +
operation.
impl AddAssign<f64> for Float
[src]
impl AddAssign<f64> for Float
fn add_assign(&mut self, rhs: f64)
[src]
fn add_assign(&mut self, rhs: f64)
Performs the +=
operation.
impl<'t> AddAssign<&'t f64> for Float
[src]
impl<'t> AddAssign<&'t f64> for Float
fn add_assign(&mut self, rhs: &f64)
[src]
fn add_assign(&mut self, rhs: &f64)
Performs the +=
operation.
impl AddAssignRound<f64> for Float
[src]
impl AddAssignRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddAssignRound<&'t f64> for Float
[src]
impl<'t> AddAssignRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
Performs the addition. Read more
impl Add<Float> for f64
[src]
impl Add<Float> for f64
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for f64
[src]
impl<'a> Add<&'a Float> for f64
type Output = AddF64Incomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddF64Incomplete
[src]
fn add(self, rhs: &Float) -> AddF64Incomplete
Performs the +
operation.
impl<'t> Add<Float> for &'t f64
[src]
impl<'t> Add<Float> for &'t f64
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'b, 't> Add<&'b Float> for &'t f64
[src]
impl<'b, 't> Add<&'b Float> for &'t f64
type Output = AddF64Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Float) -> AddF64Incomplete<'b>
[src]
fn add(self, rhs: &'b Float) -> AddF64Incomplete<'b>
Performs the +
operation.
impl AddFrom<f64> for Float
[src]
impl AddFrom<f64> for Float
impl<'t> AddFrom<&'t f64> for Float
[src]
impl<'t> AddFrom<&'t f64> for Float
impl AddFromRound<f64> for Float
[src]
impl AddFromRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: f64, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: f64, round: Round) -> Ordering
Performs the addition. Read more
impl<'t> AddFromRound<&'t f64> for Float
[src]
impl<'t> AddFromRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<f64> for Float
[src]
impl Sub<f64> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: f64) -> Float
[src]
fn sub(self, rhs: f64) -> Float
Performs the -
operation.
impl<'t> Sub<&'t f64> for Float
[src]
impl<'t> Sub<&'t f64> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &f64) -> Float
[src]
fn sub(self, rhs: &f64) -> Float
Performs the -
operation.
impl<'b> Sub<f64> for &'b Float
[src]
impl<'b> Sub<f64> for &'b Float
type Output = SubF64Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: f64) -> SubF64Incomplete<'b>
[src]
fn sub(self, rhs: f64) -> SubF64Incomplete<'b>
Performs the -
operation.
impl<'t, 'b> Sub<&'t f64> for &'b Float
[src]
impl<'t, 'b> Sub<&'t f64> for &'b Float
type Output = SubF64Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &f64) -> SubF64Incomplete<'b>
[src]
fn sub(self, rhs: &f64) -> SubF64Incomplete<'b>
Performs the -
operation.
impl SubAssign<f64> for Float
[src]
impl SubAssign<f64> for Float
fn sub_assign(&mut self, rhs: f64)
[src]
fn sub_assign(&mut self, rhs: f64)
Performs the -=
operation.
impl<'t> SubAssign<&'t f64> for Float
[src]
impl<'t> SubAssign<&'t f64> for Float
fn sub_assign(&mut self, rhs: &f64)
[src]
fn sub_assign(&mut self, rhs: &f64)
Performs the -=
operation.
impl SubAssignRound<f64> for Float
[src]
impl SubAssignRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubAssignRound<&'t f64> for Float
[src]
impl<'t> SubAssignRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
Performs the subtraction. Read more
impl Sub<Float> for f64
[src]
impl Sub<Float> for f64
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b> Sub<&'b Float> for f64
[src]
impl<'b> Sub<&'b Float> for f64
type Output = SubFromF64Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromF64Incomplete
[src]
fn sub(self, rhs: &Float) -> SubFromF64Incomplete
Performs the -
operation.
impl<'t> Sub<Float> for &'t f64
[src]
impl<'t> Sub<Float> for &'t f64
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'b, 't> Sub<&'b Float> for &'t f64
[src]
impl<'b, 't> Sub<&'b Float> for &'t f64
type Output = SubFromF64Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Float) -> SubFromF64Incomplete<'b>
[src]
fn sub(self, rhs: &'b Float) -> SubFromF64Incomplete<'b>
Performs the -
operation.
impl SubFrom<f64> for Float
[src]
impl SubFrom<f64> for Float
impl<'t> SubFrom<&'t f64> for Float
[src]
impl<'t> SubFrom<&'t f64> for Float
impl SubFromRound<f64> for Float
[src]
impl SubFromRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: f64, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: f64, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'t> SubFromRound<&'t f64> for Float
[src]
impl<'t> SubFromRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<f64> for Float
[src]
impl Mul<f64> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: f64) -> Float
[src]
fn mul(self, rhs: f64) -> Float
Performs the *
operation.
impl<'t> Mul<&'t f64> for Float
[src]
impl<'t> Mul<&'t f64> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &f64) -> Float
[src]
fn mul(self, rhs: &f64) -> Float
Performs the *
operation.
impl<'b> Mul<f64> for &'b Float
[src]
impl<'b> Mul<f64> for &'b Float
type Output = MulF64Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: f64) -> MulF64Incomplete<'b>
[src]
fn mul(self, rhs: f64) -> MulF64Incomplete<'b>
Performs the *
operation.
impl<'t, 'b> Mul<&'t f64> for &'b Float
[src]
impl<'t, 'b> Mul<&'t f64> for &'b Float
type Output = MulF64Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &f64) -> MulF64Incomplete<'b>
[src]
fn mul(self, rhs: &f64) -> MulF64Incomplete<'b>
Performs the *
operation.
impl MulAssign<f64> for Float
[src]
impl MulAssign<f64> for Float
fn mul_assign(&mut self, rhs: f64)
[src]
fn mul_assign(&mut self, rhs: f64)
Performs the *=
operation.
impl<'t> MulAssign<&'t f64> for Float
[src]
impl<'t> MulAssign<&'t f64> for Float
fn mul_assign(&mut self, rhs: &f64)
[src]
fn mul_assign(&mut self, rhs: &f64)
Performs the *=
operation.
impl MulAssignRound<f64> for Float
[src]
impl MulAssignRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulAssignRound<&'t f64> for Float
[src]
impl<'t> MulAssignRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
Performs the multiplication. Read more
impl Mul<Float> for f64
[src]
impl Mul<Float> for f64
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for f64
[src]
impl<'a> Mul<&'a Float> for f64
type Output = MulF64Incomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulF64Incomplete
[src]
fn mul(self, rhs: &Float) -> MulF64Incomplete
Performs the *
operation.
impl<'t> Mul<Float> for &'t f64
[src]
impl<'t> Mul<Float> for &'t f64
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'b, 't> Mul<&'b Float> for &'t f64
[src]
impl<'b, 't> Mul<&'b Float> for &'t f64
type Output = MulF64Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Float) -> MulF64Incomplete<'b>
[src]
fn mul(self, rhs: &'b Float) -> MulF64Incomplete<'b>
Performs the *
operation.
impl MulFrom<f64> for Float
[src]
impl MulFrom<f64> for Float
impl<'t> MulFrom<&'t f64> for Float
[src]
impl<'t> MulFrom<&'t f64> for Float
impl MulFromRound<f64> for Float
[src]
impl MulFromRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: f64, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: f64, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'t> MulFromRound<&'t f64> for Float
[src]
impl<'t> MulFromRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<f64> for Float
[src]
impl Div<f64> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: f64) -> Float
[src]
fn div(self, rhs: f64) -> Float
Performs the /
operation.
impl<'t> Div<&'t f64> for Float
[src]
impl<'t> Div<&'t f64> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &f64) -> Float
[src]
fn div(self, rhs: &f64) -> Float
Performs the /
operation.
impl<'b> Div<f64> for &'b Float
[src]
impl<'b> Div<f64> for &'b Float
type Output = DivF64Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: f64) -> DivF64Incomplete<'b>
[src]
fn div(self, rhs: f64) -> DivF64Incomplete<'b>
Performs the /
operation.
impl<'t, 'b> Div<&'t f64> for &'b Float
[src]
impl<'t, 'b> Div<&'t f64> for &'b Float
type Output = DivF64Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &f64) -> DivF64Incomplete<'b>
[src]
fn div(self, rhs: &f64) -> DivF64Incomplete<'b>
Performs the /
operation.
impl DivAssign<f64> for Float
[src]
impl DivAssign<f64> for Float
fn div_assign(&mut self, rhs: f64)
[src]
fn div_assign(&mut self, rhs: f64)
Performs the /=
operation.
impl<'t> DivAssign<&'t f64> for Float
[src]
impl<'t> DivAssign<&'t f64> for Float
fn div_assign(&mut self, rhs: &f64)
[src]
fn div_assign(&mut self, rhs: &f64)
Performs the /=
operation.
impl DivAssignRound<f64> for Float
[src]
impl DivAssignRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivAssignRound<&'t f64> for Float
[src]
impl<'t> DivAssignRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
Performs the division. Read more
impl Div<Float> for f64
[src]
impl Div<Float> for f64
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b> Div<&'b Float> for f64
[src]
impl<'b> Div<&'b Float> for f64
type Output = DivFromF64Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromF64Incomplete
[src]
fn div(self, rhs: &Float) -> DivFromF64Incomplete
Performs the /
operation.
impl<'t> Div<Float> for &'t f64
[src]
impl<'t> Div<Float> for &'t f64
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'b, 't> Div<&'b Float> for &'t f64
[src]
impl<'b, 't> Div<&'b Float> for &'t f64
type Output = DivFromF64Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b Float) -> DivFromF64Incomplete<'b>
[src]
fn div(self, rhs: &'b Float) -> DivFromF64Incomplete<'b>
Performs the /
operation.
impl DivFrom<f64> for Float
[src]
impl DivFrom<f64> for Float
impl<'t> DivFrom<&'t f64> for Float
[src]
impl<'t> DivFrom<&'t f64> for Float
impl DivFromRound<f64> for Float
[src]
impl DivFromRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: f64, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: f64, round: Round) -> Ordering
Performs the division. Read more
impl<'t> DivFromRound<&'t f64> for Float
[src]
impl<'t> DivFromRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
Performs the division. Read more
impl Shl<u32> for Float
[src]
impl Shl<u32> for Float
type Output = Float
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> Float
[src]
fn shl(self, rhs: u32) -> Float
Performs the <<
operation.
impl<'t> Shl<&'t u32> for Float
[src]
impl<'t> Shl<&'t u32> for Float
type Output = Float
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> Float
[src]
fn shl(self, rhs: &u32) -> Float
Performs the <<
operation.
impl<'b> Shl<u32> for &'b Float
[src]
impl<'b> Shl<u32> for &'b Float
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>
[src]
fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>
Performs the <<
operation.
impl<'t, 'b> Shl<&'t u32> for &'b Float
[src]
impl<'t, 'b> Shl<&'t u32> for &'b Float
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b>
[src]
fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b>
Performs the <<
operation.
impl ShlAssign<u32> for Float
[src]
impl ShlAssign<u32> for Float
fn shl_assign(&mut self, rhs: u32)
[src]
fn shl_assign(&mut self, rhs: u32)
Performs the <<=
operation.
impl<'t> ShlAssign<&'t u32> for Float
[src]
impl<'t> ShlAssign<&'t u32> for Float
fn shl_assign(&mut self, rhs: &u32)
[src]
fn shl_assign(&mut self, rhs: &u32)
Performs the <<=
operation.
impl Shr<u32> for Float
[src]
impl Shr<u32> for Float
type Output = Float
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> Float
[src]
fn shr(self, rhs: u32) -> Float
Performs the >>
operation.
impl<'t> Shr<&'t u32> for Float
[src]
impl<'t> Shr<&'t u32> for Float
type Output = Float
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> Float
[src]
fn shr(self, rhs: &u32) -> Float
Performs the >>
operation.
impl<'b> Shr<u32> for &'b Float
[src]
impl<'b> Shr<u32> for &'b Float
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>
[src]
fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>
Performs the >>
operation.
impl<'t, 'b> Shr<&'t u32> for &'b Float
[src]
impl<'t, 'b> Shr<&'t u32> for &'b Float
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b>
[src]
fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b>
Performs the >>
operation.
impl ShrAssign<u32> for Float
[src]
impl ShrAssign<u32> for Float
fn shr_assign(&mut self, rhs: u32)
[src]
fn shr_assign(&mut self, rhs: u32)
Performs the >>=
operation.
impl<'t> ShrAssign<&'t u32> for Float
[src]
impl<'t> ShrAssign<&'t u32> for Float
fn shr_assign(&mut self, rhs: &u32)
[src]
fn shr_assign(&mut self, rhs: &u32)
Performs the >>=
operation.
impl Pow<u32> for Float
[src]
impl Pow<u32> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: u32) -> Float
[src]
fn pow(self, rhs: u32) -> Float
Performs the power operation. Read more
impl<'t> Pow<&'t u32> for Float
[src]
impl<'t> Pow<&'t u32> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &u32) -> Float
[src]
fn pow(self, rhs: &u32) -> Float
Performs the power operation. Read more
impl<'b> Pow<u32> for &'b Float
[src]
impl<'b> Pow<u32> for &'b Float
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: u32) -> PowU32Incomplete<'b>
[src]
fn pow(self, rhs: u32) -> PowU32Incomplete<'b>
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t u32> for &'b Float
[src]
impl<'t, 'b> Pow<&'t u32> for &'b Float
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>
[src]
fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>
Performs the power operation. Read more
impl PowAssign<u32> for Float
[src]
impl PowAssign<u32> for Float
fn pow_assign(&mut self, rhs: u32)
[src]
fn pow_assign(&mut self, rhs: u32)
Peforms the power operation. Read more
impl<'t> PowAssign<&'t u32> for Float
[src]
impl<'t> PowAssign<&'t u32> for Float
fn pow_assign(&mut self, rhs: &u32)
[src]
fn pow_assign(&mut self, rhs: &u32)
Peforms the power operation. Read more
impl PowAssignRound<u32> for Float
[src]
impl PowAssignRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: u32, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowAssignRound<&'t u32> for Float
[src]
impl<'t> PowAssignRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering
Performs the power operation. Read more
impl Pow<Float> for u32
[src]
impl Pow<Float> for u32
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b> Pow<&'b Float> for u32
[src]
impl<'b> Pow<&'b Float> for u32
type Output = PowFromU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &Float) -> PowFromU32Incomplete
[src]
fn pow(self, rhs: &Float) -> PowFromU32Incomplete
Performs the power operation. Read more
impl<'t> Pow<Float> for &'t u32
[src]
impl<'t> Pow<Float> for &'t u32
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b, 't> Pow<&'b Float> for &'t u32
[src]
impl<'b, 't> Pow<&'b Float> for &'t u32
type Output = PowFromU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &'b Float) -> PowFromU32Incomplete<'b>
[src]
fn pow(self, rhs: &'b Float) -> PowFromU32Incomplete<'b>
Performs the power operation. Read more
impl PowFrom<u32> for Float
[src]
impl PowFrom<u32> for Float
impl<'t> PowFrom<&'t u32> for Float
[src]
impl<'t> PowFrom<&'t u32> for Float
impl PowFromRound<u32> for Float
[src]
impl PowFromRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: u32, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: u32, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowFromRound<&'t u32> for Float
[src]
impl<'t> PowFromRound<&'t u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: &u32, round: Round) -> Ordering
Performs the power operation. Read more
impl Shl<i32> for Float
[src]
impl Shl<i32> for Float
type Output = Float
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> Float
[src]
fn shl(self, rhs: i32) -> Float
Performs the <<
operation.
impl<'t> Shl<&'t i32> for Float
[src]
impl<'t> Shl<&'t i32> for Float
type Output = Float
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> Float
[src]
fn shl(self, rhs: &i32) -> Float
Performs the <<
operation.
impl<'b> Shl<i32> for &'b Float
[src]
impl<'b> Shl<i32> for &'b Float
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>
[src]
fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>
Performs the <<
operation.
impl<'t, 'b> Shl<&'t i32> for &'b Float
[src]
impl<'t, 'b> Shl<&'t i32> for &'b Float
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b>
[src]
fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b>
Performs the <<
operation.
impl ShlAssign<i32> for Float
[src]
impl ShlAssign<i32> for Float
fn shl_assign(&mut self, rhs: i32)
[src]
fn shl_assign(&mut self, rhs: i32)
Performs the <<=
operation.
impl<'t> ShlAssign<&'t i32> for Float
[src]
impl<'t> ShlAssign<&'t i32> for Float
fn shl_assign(&mut self, rhs: &i32)
[src]
fn shl_assign(&mut self, rhs: &i32)
Performs the <<=
operation.
impl Shr<i32> for Float
[src]
impl Shr<i32> for Float
type Output = Float
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> Float
[src]
fn shr(self, rhs: i32) -> Float
Performs the >>
operation.
impl<'t> Shr<&'t i32> for Float
[src]
impl<'t> Shr<&'t i32> for Float
type Output = Float
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> Float
[src]
fn shr(self, rhs: &i32) -> Float
Performs the >>
operation.
impl<'b> Shr<i32> for &'b Float
[src]
impl<'b> Shr<i32> for &'b Float
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>
[src]
fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>
Performs the >>
operation.
impl<'t, 'b> Shr<&'t i32> for &'b Float
[src]
impl<'t, 'b> Shr<&'t i32> for &'b Float
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b>
[src]
fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b>
Performs the >>
operation.
impl ShrAssign<i32> for Float
[src]
impl ShrAssign<i32> for Float
fn shr_assign(&mut self, rhs: i32)
[src]
fn shr_assign(&mut self, rhs: i32)
Performs the >>=
operation.
impl<'t> ShrAssign<&'t i32> for Float
[src]
impl<'t> ShrAssign<&'t i32> for Float
fn shr_assign(&mut self, rhs: &i32)
[src]
fn shr_assign(&mut self, rhs: &i32)
Performs the >>=
operation.
impl Pow<i32> for Float
[src]
impl Pow<i32> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: i32) -> Float
[src]
fn pow(self, rhs: i32) -> Float
Performs the power operation. Read more
impl<'t> Pow<&'t i32> for Float
[src]
impl<'t> Pow<&'t i32> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &i32) -> Float
[src]
fn pow(self, rhs: &i32) -> Float
Performs the power operation. Read more
impl<'b> Pow<i32> for &'b Float
[src]
impl<'b> Pow<i32> for &'b Float
type Output = PowI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: i32) -> PowI32Incomplete<'b>
[src]
fn pow(self, rhs: i32) -> PowI32Incomplete<'b>
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t i32> for &'b Float
[src]
impl<'t, 'b> Pow<&'t i32> for &'b Float
type Output = PowI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>
[src]
fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>
Performs the power operation. Read more
impl PowAssign<i32> for Float
[src]
impl PowAssign<i32> for Float
fn pow_assign(&mut self, rhs: i32)
[src]
fn pow_assign(&mut self, rhs: i32)
Peforms the power operation. Read more
impl<'t> PowAssign<&'t i32> for Float
[src]
impl<'t> PowAssign<&'t i32> for Float
fn pow_assign(&mut self, rhs: &i32)
[src]
fn pow_assign(&mut self, rhs: &i32)
Peforms the power operation. Read more
impl PowAssignRound<i32> for Float
[src]
impl PowAssignRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: i32, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowAssignRound<&'t i32> for Float
[src]
impl<'t> PowAssignRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering
Performs the power operation. Read more
impl Pow<Float> for i32
[src]
impl Pow<Float> for i32
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b> Pow<&'b Float> for i32
[src]
impl<'b> Pow<&'b Float> for i32
type Output = PowFromI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &Float) -> PowFromI32Incomplete
[src]
fn pow(self, rhs: &Float) -> PowFromI32Incomplete
Performs the power operation. Read more
impl<'t> Pow<Float> for &'t i32
[src]
impl<'t> Pow<Float> for &'t i32
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b, 't> Pow<&'b Float> for &'t i32
[src]
impl<'b, 't> Pow<&'b Float> for &'t i32
type Output = PowFromI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &'b Float) -> PowFromI32Incomplete<'b>
[src]
fn pow(self, rhs: &'b Float) -> PowFromI32Incomplete<'b>
Performs the power operation. Read more
impl PowFrom<i32> for Float
[src]
impl PowFrom<i32> for Float
impl<'t> PowFrom<&'t i32> for Float
[src]
impl<'t> PowFrom<&'t i32> for Float
impl PowFromRound<i32> for Float
[src]
impl PowFromRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: i32, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: i32, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowFromRound<&'t i32> for Float
[src]
impl<'t> PowFromRound<&'t i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: &i32, round: Round) -> Ordering
Performs the power operation. Read more
impl Pow<f64> for Float
[src]
impl Pow<f64> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: f64) -> Float
[src]
fn pow(self, rhs: f64) -> Float
Performs the power operation. Read more
impl<'t> Pow<&'t f64> for Float
[src]
impl<'t> Pow<&'t f64> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &f64) -> Float
[src]
fn pow(self, rhs: &f64) -> Float
Performs the power operation. Read more
impl<'b> Pow<f64> for &'b Float
[src]
impl<'b> Pow<f64> for &'b Float
type Output = PowF64Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: f64) -> PowF64Incomplete<'b>
[src]
fn pow(self, rhs: f64) -> PowF64Incomplete<'b>
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t f64> for &'b Float
[src]
impl<'t, 'b> Pow<&'t f64> for &'b Float
type Output = PowF64Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &f64) -> PowF64Incomplete<'b>
[src]
fn pow(self, rhs: &f64) -> PowF64Incomplete<'b>
Performs the power operation. Read more
impl PowAssign<f64> for Float
[src]
impl PowAssign<f64> for Float
fn pow_assign(&mut self, rhs: f64)
[src]
fn pow_assign(&mut self, rhs: f64)
Peforms the power operation. Read more
impl<'t> PowAssign<&'t f64> for Float
[src]
impl<'t> PowAssign<&'t f64> for Float
fn pow_assign(&mut self, rhs: &f64)
[src]
fn pow_assign(&mut self, rhs: &f64)
Peforms the power operation. Read more
impl PowAssignRound<f64> for Float
[src]
impl PowAssignRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: f64, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowAssignRound<&'t f64> for Float
[src]
impl<'t> PowAssignRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering
Performs the power operation. Read more
impl Pow<Float> for f64
[src]
impl Pow<Float> for f64
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b> Pow<&'b Float> for f64
[src]
impl<'b> Pow<&'b Float> for f64
type Output = PowFromF64Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &Float) -> PowFromF64Incomplete
[src]
fn pow(self, rhs: &Float) -> PowFromF64Incomplete
Performs the power operation. Read more
impl<'t> Pow<Float> for &'t f64
[src]
impl<'t> Pow<Float> for &'t f64
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b, 't> Pow<&'b Float> for &'t f64
[src]
impl<'b, 't> Pow<&'b Float> for &'t f64
type Output = PowFromF64Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &'b Float) -> PowFromF64Incomplete<'b>
[src]
fn pow(self, rhs: &'b Float) -> PowFromF64Incomplete<'b>
Performs the power operation. Read more
impl PowFrom<f64> for Float
[src]
impl PowFrom<f64> for Float
impl<'t> PowFrom<&'t f64> for Float
[src]
impl<'t> PowFrom<&'t f64> for Float
impl PowFromRound<f64> for Float
[src]
impl PowFromRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: f64, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: f64, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowFromRound<&'t f64> for Float
[src]
impl<'t> PowFromRound<&'t f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: &f64, round: Round) -> Ordering
Performs the power operation. Read more
impl Pow<f32> for Float
[src]
impl Pow<f32> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: f32) -> Float
[src]
fn pow(self, rhs: f32) -> Float
Performs the power operation. Read more
impl<'t> Pow<&'t f32> for Float
[src]
impl<'t> Pow<&'t f32> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &f32) -> Float
[src]
fn pow(self, rhs: &f32) -> Float
Performs the power operation. Read more
impl<'b> Pow<f32> for &'b Float
[src]
impl<'b> Pow<f32> for &'b Float
type Output = PowF32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: f32) -> PowF32Incomplete<'b>
[src]
fn pow(self, rhs: f32) -> PowF32Incomplete<'b>
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t f32> for &'b Float
[src]
impl<'t, 'b> Pow<&'t f32> for &'b Float
type Output = PowF32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &f32) -> PowF32Incomplete<'b>
[src]
fn pow(self, rhs: &f32) -> PowF32Incomplete<'b>
Performs the power operation. Read more
impl PowAssign<f32> for Float
[src]
impl PowAssign<f32> for Float
fn pow_assign(&mut self, rhs: f32)
[src]
fn pow_assign(&mut self, rhs: f32)
Peforms the power operation. Read more
impl<'t> PowAssign<&'t f32> for Float
[src]
impl<'t> PowAssign<&'t f32> for Float
fn pow_assign(&mut self, rhs: &f32)
[src]
fn pow_assign(&mut self, rhs: &f32)
Peforms the power operation. Read more
impl PowAssignRound<f32> for Float
[src]
impl PowAssignRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: f32, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowAssignRound<&'t f32> for Float
[src]
impl<'t> PowAssignRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
[src]
fn pow_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering
Performs the power operation. Read more
impl Pow<Float> for f32
[src]
impl Pow<Float> for f32
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b> Pow<&'b Float> for f32
[src]
impl<'b> Pow<&'b Float> for f32
type Output = PowFromF32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &Float) -> PowFromF32Incomplete
[src]
fn pow(self, rhs: &Float) -> PowFromF32Incomplete
Performs the power operation. Read more
impl<'t> Pow<Float> for &'t f32
[src]
impl<'t> Pow<Float> for &'t f32
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Float
[src]
fn pow(self, rhs: Float) -> Float
Performs the power operation. Read more
impl<'b, 't> Pow<&'b Float> for &'t f32
[src]
impl<'b, 't> Pow<&'b Float> for &'t f32
type Output = PowFromF32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &'b Float) -> PowFromF32Incomplete<'b>
[src]
fn pow(self, rhs: &'b Float) -> PowFromF32Incomplete<'b>
Performs the power operation. Read more
impl PowFrom<f32> for Float
[src]
impl PowFrom<f32> for Float
impl<'t> PowFrom<&'t f32> for Float
[src]
impl<'t> PowFrom<&'t f32> for Float
impl PowFromRound<f32> for Float
[src]
impl PowFromRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: f32, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: f32, round: Round) -> Ordering
Performs the power operation. Read more
impl<'t> PowFromRound<&'t f32> for Float
[src]
impl<'t> PowFromRound<&'t f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
[src]
fn pow_from_round(&mut self, lhs: &f32, round: Round) -> Ordering
Performs the power operation. Read more
impl PartialEq for Float
[src]
impl PartialEq for Float
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd for Float
[src]
impl PartialOrd for Float
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Float) -> bool
[src]
fn lt(&self, other: &Float) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Float) -> bool
[src]
fn le(&self, other: &Float) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Float) -> bool
[src]
fn gt(&self, other: &Float) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Float) -> bool
[src]
fn ge(&self, other: &Float) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Integer> for Float
[src]
impl PartialEq<Integer> for Float
fn eq(&self, other: &Integer) -> bool
[src]
fn eq(&self, other: &Integer) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for Integer
[src]
impl PartialEq<Float> for Integer
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for Integer
[src]
impl PartialOrd<Float> for Integer
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<Integer> for Float
[src]
impl PartialOrd<Integer> for Float
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for Float
[src]
impl PartialEq<Rational> for Float
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for Rational
[src]
impl PartialEq<Float> for Rational
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for Rational
[src]
impl PartialOrd<Float> for Rational
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<Rational> for Float
[src]
impl PartialOrd<Rational> for Float
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i8> for Float
[src]
impl PartialEq<i8> for Float
fn eq(&self, other: &i8) -> bool
[src]
fn eq(&self, other: &i8) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for i8
[src]
impl PartialEq<Float> for i8
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for i8
[src]
impl PartialOrd<Float> for i8
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<i8> for Float
[src]
impl PartialOrd<i8> for Float
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i16> for Float
[src]
impl PartialEq<i16> for Float
fn eq(&self, other: &i16) -> bool
[src]
fn eq(&self, other: &i16) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for i16
[src]
impl PartialEq<Float> for i16
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for i16
[src]
impl PartialOrd<Float> for i16
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<i16> for Float
[src]
impl PartialOrd<i16> for Float
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i32> for Float
[src]
impl PartialEq<i32> for Float
fn eq(&self, other: &i32) -> bool
[src]
fn eq(&self, other: &i32) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for i32
[src]
impl PartialEq<Float> for i32
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for i32
[src]
impl PartialOrd<Float> for i32
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<i32> for Float
[src]
impl PartialOrd<i32> for Float
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i64> for Float
[src]
impl PartialEq<i64> for Float
fn eq(&self, other: &i64) -> bool
[src]
fn eq(&self, other: &i64) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for i64
[src]
impl PartialEq<Float> for i64
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for i64
[src]
impl PartialOrd<Float> for i64
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<i64> for Float
[src]
impl PartialOrd<i64> for Float
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i128> for Float
[src]
impl PartialEq<i128> for Float
fn eq(&self, other: &i128) -> bool
[src]
fn eq(&self, other: &i128) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for i128
[src]
impl PartialEq<Float> for i128
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for i128
[src]
impl PartialOrd<Float> for i128
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<i128> for Float
[src]
impl PartialOrd<i128> for Float
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<isize> for Float
[src]
impl PartialEq<isize> for Float
fn eq(&self, other: &isize) -> bool
[src]
fn eq(&self, other: &isize) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for isize
[src]
impl PartialEq<Float> for isize
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for isize
[src]
impl PartialOrd<Float> for isize
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<isize> for Float
[src]
impl PartialOrd<isize> for Float
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u8> for Float
[src]
impl PartialEq<u8> for Float
fn eq(&self, other: &u8) -> bool
[src]
fn eq(&self, other: &u8) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for u8
[src]
impl PartialEq<Float> for u8
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for u8
[src]
impl PartialOrd<Float> for u8
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<u8> for Float
[src]
impl PartialOrd<u8> for Float
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u16> for Float
[src]
impl PartialEq<u16> for Float
fn eq(&self, other: &u16) -> bool
[src]
fn eq(&self, other: &u16) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for u16
[src]
impl PartialEq<Float> for u16
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for u16
[src]
impl PartialOrd<Float> for u16
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<u16> for Float
[src]
impl PartialOrd<u16> for Float
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u32> for Float
[src]
impl PartialEq<u32> for Float
fn eq(&self, other: &u32) -> bool
[src]
fn eq(&self, other: &u32) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for u32
[src]
impl PartialEq<Float> for u32
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for u32
[src]
impl PartialOrd<Float> for u32
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<u32> for Float
[src]
impl PartialOrd<u32> for Float
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u64> for Float
[src]
impl PartialEq<u64> for Float
fn eq(&self, other: &u64) -> bool
[src]
fn eq(&self, other: &u64) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for u64
[src]
impl PartialEq<Float> for u64
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for u64
[src]
impl PartialOrd<Float> for u64
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<u64> for Float
[src]
impl PartialOrd<u64> for Float
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u128> for Float
[src]
impl PartialEq<u128> for Float
fn eq(&self, other: &u128) -> bool
[src]
fn eq(&self, other: &u128) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for u128
[src]
impl PartialEq<Float> for u128
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for u128
[src]
impl PartialOrd<Float> for u128
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<u128> for Float
[src]
impl PartialOrd<u128> for Float
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<usize> for Float
[src]
impl PartialEq<usize> for Float
fn eq(&self, other: &usize) -> bool
[src]
fn eq(&self, other: &usize) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for usize
[src]
impl PartialEq<Float> for usize
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for usize
[src]
impl PartialOrd<Float> for usize
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<usize> for Float
[src]
impl PartialOrd<usize> for Float
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<f32> for Float
[src]
impl PartialEq<f32> for Float
fn eq(&self, other: &f32) -> bool
[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: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for f32
[src]
impl PartialEq<Float> for f32
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for f32
[src]
impl PartialOrd<Float> for f32
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<f32> for Float
[src]
impl PartialOrd<f32> for Float
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
[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: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<f64> for Float
[src]
impl PartialEq<f64> for Float
fn eq(&self, other: &f64) -> bool
[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: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for f64
[src]
impl PartialEq<Float> for f64
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for f64
[src]
impl PartialOrd<Float> for f64
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<f64> for Float
[src]
impl PartialOrd<f64> for Float
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
[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: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Special> for Float
[src]
impl PartialEq<Special> for Float
fn eq(&self, other: &Special) -> bool
[src]
fn eq(&self, other: &Special) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for Special
[src]
impl PartialEq<Float> for Special
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for Special
[src]
impl PartialOrd<Float> for Special
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<Special> for Float
[src]
impl PartialOrd<Special> for Float
fn partial_cmp(&self, other: &Special) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Special) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl From<Float> for OrdFloat
[src]
impl From<Float> for OrdFloat
impl From<OrdFloat> for Float
[src]
impl From<OrdFloat> for Float
impl Serialize for Float
[src]
impl Serialize for Float
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<'de> Deserialize<'de> for Float
[src]
impl<'de> Deserialize<'de> for Float
fn deserialize<D>(deserializer: D) -> Result<Float, D::Error> where
D: Deserializer<'de>,
[src]
fn deserialize<D>(deserializer: D) -> Result<Float, D::Error> where
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
fn deserialize_in_place<D>(
deserializer: D,
place: &mut Float
) -> Result<(), D::Error> where
D: Deserializer<'de>,
[src]
fn deserialize_in_place<D>(
deserializer: D,
place: &mut Float
) -> Result<(), D::Error> where
D: Deserializer<'de>,
impl Clone for Float
[src]
impl Clone for Float
fn clone(&self) -> Float
[src]
fn clone(&self) -> Float
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Float)
[src]
fn clone_from(&mut self, source: &Float)
Performs copy-assignment from source
. Read more
impl Drop for Float
[src]
impl Drop for Float
impl Display for Float
[src]
impl Display for Float
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl Debug for Float
[src]
impl Debug for Float
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl LowerExp for Float
[src]
impl LowerExp for Float
impl UpperExp for Float
[src]
impl UpperExp for Float
impl Binary for Float
[src]
impl Binary for Float
impl Octal for Float
[src]
impl Octal for Float
impl LowerHex for Float
[src]
impl LowerHex for Float
impl UpperHex for Float
[src]
impl UpperHex for Float
impl<T> Assign<T> for Float where
Self: AssignRound<T, Round = Round, Ordering = Ordering>,
[src]
impl<T> Assign<T> for Float where
Self: AssignRound<T, Round = Round, Ordering = Ordering>,
impl AssignRound<Constant> for Float
[src]
impl AssignRound<Constant> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Constant, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: Constant, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Constant> for Float
[src]
impl<'a> AssignRound<&'a Constant> for Float
type Round = <Float as AssignRound<Constant>>::Round
The rounding method.
type Ordering = <Float as AssignRound<Constant>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Constant, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &Constant, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<Special> for Float
[src]
impl AssignRound<Special> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Special, _round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: Special, _round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Special> for Float
[src]
impl<'a> AssignRound<&'a Special> for Float
type Round = <Float as AssignRound<Special>>::Round
The rounding method.
type Ordering = <Float as AssignRound<Special>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Special, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &Special, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound for Float
[src]
impl AssignRound for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Float, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: Float, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Float> for Float
[src]
impl<'a> AssignRound<&'a Float> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Float, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: &Float, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Integer> for Float
[src]
impl<'a> AssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Integer, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: &Integer, round: Round) -> Ordering
Peforms the assignment. Read more
impl AssignRound<Integer> for Float
[src]
impl AssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Integer, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: Integer, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Rational> for Float
[src]
impl<'a> AssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Rational, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: &Rational, round: Round) -> Ordering
Peforms the assignment. Read more
impl AssignRound<Rational> for Float
[src]
impl AssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Rational, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: Rational, round: Round) -> Ordering
Peforms the assignment. Read more
impl AssignRound<i8> for Float
[src]
impl AssignRound<i8> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: i8, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: i8, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a i8> for Float
[src]
impl<'a> AssignRound<&'a i8> for Float
type Round = <Float as AssignRound<i8>>::Round
The rounding method.
type Ordering = <Float as AssignRound<i8>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &i8, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &i8, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<i16> for Float
[src]
impl AssignRound<i16> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: i16, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: i16, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a i16> for Float
[src]
impl<'a> AssignRound<&'a i16> for Float
type Round = <Float as AssignRound<i16>>::Round
The rounding method.
type Ordering = <Float as AssignRound<i16>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &i16, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &i16, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<i32> for Float
[src]
impl AssignRound<i32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: i32, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: i32, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a i32> for Float
[src]
impl<'a> AssignRound<&'a i32> for Float
type Round = <Float as AssignRound<i32>>::Round
The rounding method.
type Ordering = <Float as AssignRound<i32>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &i32, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &i32, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<i64> for Float
[src]
impl AssignRound<i64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: i64, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: i64, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a i64> for Float
[src]
impl<'a> AssignRound<&'a i64> for Float
type Round = <Float as AssignRound<i64>>::Round
The rounding method.
type Ordering = <Float as AssignRound<i64>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &i64, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &i64, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<i128> for Float
[src]
impl AssignRound<i128> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: i128, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: i128, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a i128> for Float
[src]
impl<'a> AssignRound<&'a i128> for Float
type Round = <Float as AssignRound<i128>>::Round
The rounding method.
type Ordering = <Float as AssignRound<i128>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &i128, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &i128, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<isize> for Float
[src]
impl AssignRound<isize> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: isize, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: isize, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a isize> for Float
[src]
impl<'a> AssignRound<&'a isize> for Float
type Round = <Float as AssignRound<isize>>::Round
The rounding method.
type Ordering = <Float as AssignRound<isize>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &isize, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &isize, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<u8> for Float
[src]
impl AssignRound<u8> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: u8, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: u8, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a u8> for Float
[src]
impl<'a> AssignRound<&'a u8> for Float
type Round = <Float as AssignRound<u8>>::Round
The rounding method.
type Ordering = <Float as AssignRound<u8>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &u8, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &u8, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<u16> for Float
[src]
impl AssignRound<u16> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: u16, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: u16, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a u16> for Float
[src]
impl<'a> AssignRound<&'a u16> for Float
type Round = <Float as AssignRound<u16>>::Round
The rounding method.
type Ordering = <Float as AssignRound<u16>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &u16, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &u16, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<u32> for Float
[src]
impl AssignRound<u32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: u32, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: u32, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a u32> for Float
[src]
impl<'a> AssignRound<&'a u32> for Float
type Round = <Float as AssignRound<u32>>::Round
The rounding method.
type Ordering = <Float as AssignRound<u32>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &u32, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &u32, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<u64> for Float
[src]
impl AssignRound<u64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: u64, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: u64, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a u64> for Float
[src]
impl<'a> AssignRound<&'a u64> for Float
type Round = <Float as AssignRound<u64>>::Round
The rounding method.
type Ordering = <Float as AssignRound<u64>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &u64, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &u64, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<u128> for Float
[src]
impl AssignRound<u128> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: u128, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: u128, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a u128> for Float
[src]
impl<'a> AssignRound<&'a u128> for Float
type Round = <Float as AssignRound<u128>>::Round
The rounding method.
type Ordering = <Float as AssignRound<u128>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &u128, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &u128, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<usize> for Float
[src]
impl AssignRound<usize> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: usize, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: usize, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a usize> for Float
[src]
impl<'a> AssignRound<&'a usize> for Float
type Round = <Float as AssignRound<usize>>::Round
The rounding method.
type Ordering = <Float as AssignRound<usize>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &usize, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &usize, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<f32> for Float
[src]
impl AssignRound<f32> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: f32, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: f32, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a f32> for Float
[src]
impl<'a> AssignRound<&'a f32> for Float
type Round = <Float as AssignRound<f32>>::Round
The rounding method.
type Ordering = <Float as AssignRound<f32>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &f32, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &f32, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl AssignRound<f64> for Float
[src]
impl AssignRound<f64> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: f64, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: f64, round: Round) -> Ordering
Peforms the assignment. Read more
impl<'a> AssignRound<&'a f64> for Float
[src]
impl<'a> AssignRound<&'a f64> for Float
type Round = <Float as AssignRound<f64>>::Round
The rounding method.
type Ordering = <Float as AssignRound<f64>>::Ordering
The direction from rounding.
fn assign_round(&mut self, src: &f64, round: Self::Round) -> Self::Ordering
[src]
fn assign_round(&mut self, src: &f64, round: Self::Round) -> Self::Ordering
Peforms the assignment. Read more
impl TryFrom<Float> for Rational
[src]
impl TryFrom<Float> for Rational
type Error = TryFromFloatError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Float) -> Result<Self, TryFromFloatError>
[src]
fn try_from(value: Float) -> Result<Self, TryFromFloatError>
try_from
)Performs the conversion.
impl<'a> TryFrom<&'a Float> for Rational
[src]
impl<'a> TryFrom<&'a Float> for Rational
type Error = TryFromFloatError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Float) -> Result<Self, TryFromFloatError>
[src]
fn try_from(value: &Float) -> Result<Self, TryFromFloatError>
try_from
)Performs the conversion.
impl Send for Float
[src]
impl Send for Float
impl Sync for Float
[src]
impl Sync for Float
impl Add<Float> for Complex
[src]
impl Add<Float> for Complex
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Complex
[src]
fn add(self, rhs: Float) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Float> for Complex
[src]
impl<'a> Add<&'a Float> for Complex
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> Complex
[src]
fn add(self, rhs: &Float) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Float> for &'a Complex
[src]
impl<'a> Add<&'a Float> for &'a Complex
type Output = AddFloatIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddFloatIncomplete
[src]
fn add(self, rhs: &'a Float) -> AddFloatIncomplete
Performs the +
operation.
impl AddAssign<Float> for Complex
[src]
impl AddAssign<Float> for Complex
fn add_assign(&mut self, rhs: Float)
[src]
fn add_assign(&mut self, rhs: Float)
Performs the +=
operation.
impl<'a> AddAssign<&'a Float> for Complex
[src]
impl<'a> AddAssign<&'a Float> for Complex
fn add_assign(&mut self, rhs: &Float)
[src]
fn add_assign(&mut self, rhs: &Float)
Performs the +=
operation.
impl AddAssignRound<Float> for Complex
[src]
impl AddAssignRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Float> for Complex
[src]
impl<'a> AddAssignRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> Add<Float> for &'a Complex
[src]
impl<'a> Add<Float> for &'a Complex
type Output = AddOwnedFloatIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> AddOwnedFloatIncomplete<'a>
[src]
fn add(self, rhs: Float) -> AddOwnedFloatIncomplete<'a>
Performs the +
operation.
impl Add<Complex> for Float
[src]
impl Add<Complex> for Float
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
fn add(self, rhs: Complex) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Complex> for Float
[src]
impl<'a> Add<&'a Complex> for Float
type Output = AddOwnedFloatIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Complex) -> AddOwnedFloatIncomplete
[src]
fn add(self, rhs: &Complex) -> AddOwnedFloatIncomplete
Performs the +
operation.
impl<'a> Add<Complex> for &'a Float
[src]
impl<'a> Add<Complex> for &'a Float
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
fn add(self, rhs: Complex) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Complex> for &'a Float
[src]
impl<'a> Add<&'a Complex> for &'a Float
type Output = AddFloatIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> AddFloatIncomplete
[src]
fn add(self, rhs: &'a Complex) -> AddFloatIncomplete
Performs the +
operation.
impl AddFrom<Float> for Complex
[src]
impl AddFrom<Float> for Complex
impl<'a> AddFrom<&'a Float> for Complex
[src]
impl<'a> AddFrom<&'a Float> for Complex
impl AddFromRound<Float> for Complex
[src]
impl AddFromRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddFromRound<&'a Float> for Complex
[src]
impl<'a> AddFromRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl Sub<Float> for Complex
[src]
impl Sub<Float> for Complex
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Complex
[src]
fn sub(self, rhs: Float) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Float> for Complex
[src]
impl<'a> Sub<&'a Float> for Complex
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> Complex
[src]
fn sub(self, rhs: &Float) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Float> for &'a Complex
[src]
impl<'a> Sub<&'a Float> for &'a Complex
type Output = SubFloatIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubFloatIncomplete
[src]
fn sub(self, rhs: &'a Float) -> SubFloatIncomplete
Performs the -
operation.
impl SubAssign<Float> for Complex
[src]
impl SubAssign<Float> for Complex
fn sub_assign(&mut self, rhs: Float)
[src]
fn sub_assign(&mut self, rhs: Float)
Performs the -=
operation.
impl<'a> SubAssign<&'a Float> for Complex
[src]
impl<'a> SubAssign<&'a Float> for Complex
fn sub_assign(&mut self, rhs: &Float)
[src]
fn sub_assign(&mut self, rhs: &Float)
Performs the -=
operation.
impl SubAssignRound<Float> for Complex
[src]
impl SubAssignRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Float> for Complex
[src]
impl<'a> SubAssignRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> Sub<Float> for &'a Complex
[src]
impl<'a> Sub<Float> for &'a Complex
type Output = SubFromFloatIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> SubFromFloatIncomplete<'a>
[src]
fn sub(self, rhs: Float) -> SubFromFloatIncomplete<'a>
Performs the -
operation.
impl Sub<Complex> for Float
[src]
impl Sub<Complex> for Float
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
fn sub(self, rhs: Complex) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Complex> for Float
[src]
impl<'a> Sub<&'a Complex> for Float
type Output = SubFromOwnedFloatIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Complex) -> SubFromOwnedFloatIncomplete
[src]
fn sub(self, rhs: &Complex) -> SubFromOwnedFloatIncomplete
Performs the -
operation.
impl<'a> Sub<Complex> for &'a Float
[src]
impl<'a> Sub<Complex> for &'a Float
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
fn sub(self, rhs: Complex) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Complex> for &'a Float
[src]
impl<'a> Sub<&'a Complex> for &'a Float
type Output = SubOwnedFloatIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> SubOwnedFloatIncomplete
[src]
fn sub(self, rhs: &'a Complex) -> SubOwnedFloatIncomplete
Performs the -
operation.
impl SubFrom<Float> for Complex
[src]
impl SubFrom<Float> for Complex
impl<'a> SubFrom<&'a Float> for Complex
[src]
impl<'a> SubFrom<&'a Float> for Complex
impl SubFromRound<Float> for Complex
[src]
impl SubFromRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Float> for Complex
[src]
impl<'a> SubFromRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl Mul<Float> for Complex
[src]
impl Mul<Float> for Complex
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Complex
[src]
fn mul(self, rhs: Float) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Float> for Complex
[src]
impl<'a> Mul<&'a Float> for Complex
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> Complex
[src]
fn mul(self, rhs: &Float) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Float> for &'a Complex
[src]
impl<'a> Mul<&'a Float> for &'a Complex
type Output = MulFloatIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulFloatIncomplete
[src]
fn mul(self, rhs: &'a Float) -> MulFloatIncomplete
Performs the *
operation.
impl MulAssign<Float> for Complex
[src]
impl MulAssign<Float> for Complex
fn mul_assign(&mut self, rhs: Float)
[src]
fn mul_assign(&mut self, rhs: Float)
Performs the *=
operation.
impl<'a> MulAssign<&'a Float> for Complex
[src]
impl<'a> MulAssign<&'a Float> for Complex
fn mul_assign(&mut self, rhs: &Float)
[src]
fn mul_assign(&mut self, rhs: &Float)
Performs the *=
operation.
impl MulAssignRound<Float> for Complex
[src]
impl MulAssignRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Float> for Complex
[src]
impl<'a> MulAssignRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> Mul<Float> for &'a Complex
[src]
impl<'a> Mul<Float> for &'a Complex
type Output = MulOwnedFloatIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> MulOwnedFloatIncomplete<'a>
[src]
fn mul(self, rhs: Float) -> MulOwnedFloatIncomplete<'a>
Performs the *
operation.
impl Mul<Complex> for Float
[src]
impl Mul<Complex> for Float
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
fn mul(self, rhs: Complex) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Complex> for Float
[src]
impl<'a> Mul<&'a Complex> for Float
type Output = MulOwnedFloatIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Complex) -> MulOwnedFloatIncomplete
[src]
fn mul(self, rhs: &Complex) -> MulOwnedFloatIncomplete
Performs the *
operation.
impl<'a> Mul<Complex> for &'a Float
[src]
impl<'a> Mul<Complex> for &'a Float
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
fn mul(self, rhs: Complex) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Complex> for &'a Float
[src]
impl<'a> Mul<&'a Complex> for &'a Float
type Output = MulFloatIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> MulFloatIncomplete
[src]
fn mul(self, rhs: &'a Complex) -> MulFloatIncomplete
Performs the *
operation.
impl MulFrom<Float> for Complex
[src]
impl MulFrom<Float> for Complex
impl<'a> MulFrom<&'a Float> for Complex
[src]
impl<'a> MulFrom<&'a Float> for Complex
impl MulFromRound<Float> for Complex
[src]
impl MulFromRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Float> for Complex
[src]
impl<'a> MulFromRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl Div<Float> for Complex
[src]
impl Div<Float> for Complex
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Complex
[src]
fn div(self, rhs: Float) -> Complex
Performs the /
operation.
impl<'a> Div<&'a Float> for Complex
[src]
impl<'a> Div<&'a Float> for Complex
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> Complex
[src]
fn div(self, rhs: &Float) -> Complex
Performs the /
operation.
impl<'a> Div<&'a Float> for &'a Complex
[src]
impl<'a> Div<&'a Float> for &'a Complex
type Output = DivFloatIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivFloatIncomplete
[src]
fn div(self, rhs: &'a Float) -> DivFloatIncomplete
Performs the /
operation.
impl DivAssign<Float> for Complex
[src]
impl DivAssign<Float> for Complex
fn div_assign(&mut self, rhs: Float)
[src]
fn div_assign(&mut self, rhs: Float)
Performs the /=
operation.
impl<'a> DivAssign<&'a Float> for Complex
[src]
impl<'a> DivAssign<&'a Float> for Complex
fn div_assign(&mut self, rhs: &Float)
[src]
fn div_assign(&mut self, rhs: &Float)
Performs the /=
operation.
impl DivAssignRound<Float> for Complex
[src]
impl DivAssignRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn div_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivAssignRound<&'a Float> for Complex
[src]
impl<'a> DivAssignRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn div_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> Div<Float> for &'a Complex
[src]
impl<'a> Div<Float> for &'a Complex
type Output = DivFromFloatIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> DivFromFloatIncomplete<'a>
[src]
fn div(self, rhs: Float) -> DivFromFloatIncomplete<'a>
Performs the /
operation.
impl Div<Complex> for Float
[src]
impl Div<Complex> for Float
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Complex) -> Complex
[src]
fn div(self, rhs: Complex) -> Complex
Performs the /
operation.
impl<'a> Div<&'a Complex> for Float
[src]
impl<'a> Div<&'a Complex> for Float
type Output = DivFromOwnedFloatIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &Complex) -> DivFromOwnedFloatIncomplete
[src]
fn div(self, rhs: &Complex) -> DivFromOwnedFloatIncomplete
Performs the /
operation.
impl<'a> Div<Complex> for &'a Float
[src]
impl<'a> Div<Complex> for &'a Float
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Complex) -> Complex
[src]
fn div(self, rhs: Complex) -> Complex
Performs the /
operation.
impl<'a> Div<&'a Complex> for &'a Float
[src]
impl<'a> Div<&'a Complex> for &'a Float
type Output = DivOwnedFloatIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Complex) -> DivOwnedFloatIncomplete
[src]
fn div(self, rhs: &'a Complex) -> DivOwnedFloatIncomplete
Performs the /
operation.
impl DivFrom<Float> for Complex
[src]
impl DivFrom<Float> for Complex
impl<'a> DivFrom<&'a Float> for Complex
[src]
impl<'a> DivFrom<&'a Float> for Complex
impl DivFromRound<Float> for Complex
[src]
impl DivFromRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn div_from_round(
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivFromRound<&'a Float> for Complex
[src]
impl<'a> DivFromRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn div_from_round(
&mut self,
lhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl Pow<Float> for Complex
[src]
impl Pow<Float> for Complex
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Complex
[src]
fn pow(self, rhs: Float) -> Complex
Performs the power operation. Read more
impl<'a> Pow<&'a Float> for Complex
[src]
impl<'a> Pow<&'a Float> for Complex
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: &Float) -> Complex
[src]
fn pow(self, rhs: &Float) -> Complex
Performs the power operation. Read more
impl<'a> Pow<&'a Float> for &'a Complex
[src]
impl<'a> Pow<&'a Float> for &'a Complex
type Output = PowFloatIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Float) -> PowFloatIncomplete
[src]
fn pow(self, rhs: &'a Float) -> PowFloatIncomplete
Performs the power operation. Read more
impl PowAssign<Float> for Complex
[src]
impl PowAssign<Float> for Complex
fn pow_assign(&mut self, rhs: Float)
[src]
fn pow_assign(&mut self, rhs: Float)
Peforms the power operation. Read more
impl<'a> PowAssign<&'a Float> for Complex
[src]
impl<'a> PowAssign<&'a Float> for Complex
fn pow_assign(&mut self, rhs: &Float)
[src]
fn pow_assign(&mut self, rhs: &Float)
Peforms the power operation. Read more
impl PowAssignRound<Float> for Complex
[src]
impl PowAssignRound<Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn pow_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn pow_assign_round(
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> PowAssignRound<&'a Float> for Complex
[src]
impl<'a> PowAssignRound<&'a Float> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn pow_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn pow_assign_round(
&mut self,
rhs: &Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> Pow<Float> for &'a Complex
[src]
impl<'a> Pow<Float> for &'a Complex
type Output = PowOwnedFloatIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: Float) -> PowOwnedFloatIncomplete<'a>
[src]
fn pow(self, rhs: Float) -> PowOwnedFloatIncomplete<'a>
Performs the power operation. Read more
impl PartialEq<Float> for Complex
[src]
impl PartialEq<Float> for Complex
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Complex> for Float
[src]
impl PartialEq<Complex> for Float