Struct rug::Float

#[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 core::cmp::Ordering;
use rug::{float::Round, ops::DivAssignRound, Float};
// 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:

1. The first method consumes the operand and rounds the returned Float to the nearest representable value.
2. The second method has a “_mut” suffix, mutates the operand and rounds it the nearest representable value.
3. 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.
4. The fourth method has a “_ref” suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to a Float; the rounding method is selected during the assignment.

use core::cmp::Ordering;
use rug::{float::Round, Float};
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

use rug::{
    float::{self, FreeCache, Round},
    ops::{AddAssignRound, AssignRound, MulAssignRound},
    Float,
};

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..=100_u32 {
    // multiply t by i in place, round towards +∞
    t.mul_assign_round(i, Round::Up);
    // set u to 1/t, round towards −∞
    u.assign_round(t.recip_ref(), Round::Down);
    // increase s by u in place, round towards −∞
    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);

float::free_cache(FreeCache::All);

Implementations

impl Float

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>, 

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>, 

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 core::cmp::Ordering;
use rug::{float::Round, Float};
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

Returns the precision.

Examples

use rug::Float;
let f = Float::new(53);
assert_eq!(f.prec(), 53);

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

Sets the precision, applying the specified rounding method.

Panics

Panics if prec is out of the allowed range.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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

Creates a Float from an initialized MPFR floating-point number.

Safety

• The value must be initialized.
• The 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

use core::mem::MaybeUninit;
use gmp_mpfr_sys::mpfr::{self, rnd_t};
use rug::Float;
let f = unsafe {
    let mut m = MaybeUninit::uninit();
    mpfr::init2(m.as_mut_ptr(), 53);
    let mut m = m.assume_init();
    mpfr::set_d(&mut m, -14.5, 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

Converts a Float into an MPFR floating-point number.

The returned object should be freed to avoid memory leaks.

Examples

use gmp_mpfr_sys::mpfr::{self, rnd_t};
use rug::Float;
let f = Float::with_val(53, -14.5);
let mut m = f.into_raw();
unsafe {
    let d = mpfr::get_d(&m, 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

Returns a pointer to the inner MPFR floating-point number.

The returned pointer will be valid for as long as self is valid.

Examples

use gmp_mpfr_sys::mpfr::{self, rnd_t};
use rug::Float;
let f = Float::with_val(53, -14.5);
let m_ptr = f.as_raw();
unsafe {
    let d = mpfr::get_d(m_ptr, 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

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

use gmp_mpfr_sys::mpfr::{self, rnd_t};
use rug::Float;
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, rnd_t::RNDN);
}
assert_eq!(f, -4.5);

pub fn parse<S: AsRef<[u8]>>(src: S) -> Result<ParseIncomplete, ParseFloatError>

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: AsRef<[u8]>>(
    src: S,
    radix: i32
) -> Result<ParseIncomplete, ParseFloatError>

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>

If the value is a finite number, converts it to an Integer rounding to the nearest.

This conversion can also be performed using

• (&float).checked_as::<Integer>()
• float.borrow().checked_as::<Integer>()

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)>

If the value is a finite number, converts it to an Integer applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
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)>

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, 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_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 core::{i32, u32};
use rug::{Assign, Float};
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>

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, 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>

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 core::u32;
use rug::{Assign, Float};
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>

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, 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

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 core::f32;
use rug::{Assign, Float};
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

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 core::f32;
use rug::{float::Round, Float};
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

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 core::f64;
use rug::{Assign, Float};
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

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 core::f64;
use rug::{float::Round, Float};
// (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)

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)

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, 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)

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)

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, 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

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, 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), "23.00");
assert_eq!(twentythree.to_string_radix(16, None), "17.0");
assert_eq!(twentythree.to_string_radix(10, Some(2)), "23");
assert_eq!(twentythree.to_string_radix(16, Some(4)), "17.00");
// 2 raised to the power of 80 in hex is 1 followed by 20 zeros
let two_to_80 = Float::with_val(53, 80f64.exp2());
assert_eq!(two_to_80.to_string_radix(10, Some(3)), "1.21e24");
assert_eq!(two_to_80.to_string_radix(16, Some(3)), "1.00@20");

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. 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::Round, Float};
let twentythree = Float::with_val(8, 23.3);
let down = twentythree.to_string_radix_round(10, Some(2), Round::Down);
assert_eq!(down, "23");
let up = twentythree.to_string_radix_round(10, Some(2), Round::Up);
assert_eq!(up, "24");

pub fn to_sign_string_exp(
    &self,
    radix: i32,
    num_digits: Option<usize>
) -> (bool, String, Option<i32>)

Returns a string representation of self together with a sign and an exponent for the specified radix, rounding to the nearest.

The returned exponent is None if the Float is zero, infinite or NaN, that is if the value is not normal.

For normal values, the returned string has an implicit radix point before the first digit. 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, Float};
let inf = Float::with_val(53, Special::Infinity);
let (sign, s, exp) = inf.to_sign_string_exp(10, None);
assert_eq!((sign, &*s, exp), (false, "inf", None));
let (sign, s, exp) = (-inf).to_sign_string_exp(16, None);
assert_eq!((sign, &*s, exp), (true, "@inf@", None));

let (sign, s, exp) = Float::with_val(8, -0.0625).to_sign_string_exp(10, None);
assert_eq!((sign, &*s, exp), (true, "6250", Some(-1)));
let (sign, s, exp) = Float::with_val(8, -0.625).to_sign_string_exp(10, None);
assert_eq!((sign, &*s, exp), (true, "6250", Some(0)));
let (sign, s, exp) = Float::with_val(8, -6.25).to_sign_string_exp(10, None);
assert_eq!((sign, &*s, exp), (true, "6250", Some(1)));
// −4.8e4 = 48_000, which is rounded to 48_128 using 8 bits of precision
let (sign, s, exp) = Float::with_val(8, -4.8e4).to_sign_string_exp(10, None);
assert_eq!((sign, &*s, exp), (true, "4813", Some(5)));

pub fn to_sign_string_exp_round(
    &self,
    radix: i32,
    num_digits: Option<usize>,
    round: Round
) -> (bool, String, Option<i32>)

Returns a string representation of self together with a sign and an exponent for the specified radix, applying the specified rounding method.

The returned exponent is None if the Float is zero, infinite or NaN, that is if the value is not normal.

For normal values, the returned string has an implicit radix point before the first digit. 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::Round, Float};
let val = Float::with_val(53, -0.0625);
// rounding −0.0625 to two significant digits towards −∞ gives −0.063
let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Down);
assert_eq!((sign, &*s, exp), (true, "63", Some(-1)));
// rounding −0.0625 to two significant digits towards +∞ gives −0.062
let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Up);
assert_eq!((sign, &*s, exp), (true, "62", Some(-1)));

let val = Float::with_val(53, 6.25e4);
// rounding 6.25e4 to two significant digits towards −∞ gives 6.2e4
let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Down);
assert_eq!((sign, &*s, exp), (false, "62", Some(5)));
// rounding 6.25e4 to two significant digits towards +∞ gives 6.3e4
let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Up);
assert_eq!((sign, &*s, exp), (false, "63", Some(5)));

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<'_>

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

Borrows the Float as an ordered floating-point number of type OrdFloat.

The same result can be obtained using the implementation of AsRef<OrdFloat> which is provided for Float.

Examples

use core::cmp::Ordering;
use rug::{float::Special, Float};

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

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

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

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

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

Returns true if self is plus or minus zero.

Examples

use rug::{float::Special, 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

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, 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

Returns the floating-point category of the number. Note that Float cannot be subnormal.

Examples

use core::num::FpCategory;
use rug::{float::Special, Float};
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>

Returns the same result as self.partial_cmp(&0), but is faster.

Examples

use core::cmp::Ordering;
use rug::{float::Special, Assign, Float};
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>

Compares the absolute values of self and other.

Examples

use core::cmp::Ordering;
use rug::Float;
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>

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 clamp_exp(
    &mut self,
    dir: Ordering,
    round: Round,
    exp_min: i32,
    exp_max: i32
) -> Option<Ordering>

Clamps the exponent of a Float within a specified range if the range is valid.

This method returns None if the specified exponent range is outside the allowed exponent range obtained using exp_min and exp_max.

This method assumes that self is the correctly rounded value of some exact result exact, rounded according to round in the direction dir. If necessary, this function then modifies self to be within the specified exponent range. If the exponent of self is outside the specified range, an underflow or overflow occurs, and the value of the input parameter dir is used to avoid double rounding.

Unlike most methods functions, the direction is obtained by comparing the output self to the unknown result exact, not to the input value of self.

Examples

use core::cmp::Ordering;
use rug::{float::Round, ops::DivAssignRound, Float};
// use precision 4 for sake of example
let mut f = Float::with_val(4, 1.0);
// 1/115_000 is 8.696e-6, rounded down to 0.5625 >> 16 = 8.583e-6
let dir = f.div_assign_round(115_000, Round::Nearest);
assert_eq!(f, 0.5625 / 16f32.exp2());
assert_eq!(dir, Ordering::Less);
// Limiting exponent range to [-16, 16] leaves f unchanged
let dir = f.clamp_exp(dir, Round::Nearest, -16, 16).unwrap();
assert_eq!(f, 0.5625 / 16f32.exp2());
assert_eq!(dir, Ordering::Less);
// Limiting exponent range to [-15, 15] pushes f up to 0.5 >> 15
let dir = f.clamp_exp(dir, Round::Nearest, -15, 15).unwrap();
assert_eq!(f, 0.5 / 15f32.exp2());
assert_eq!(dir, Ordering::Greater);

The dir parameter can be required to avoid double rounding. In the following example, f is 1/16, which is a tie between 0 and 1/8. With ties rounding to even, this would be double rounded to 0, but the exact result was actually > 1/16 as indicated by dir saying that f is less than its exact value. f can thus be rounded correctly to 1/8.

use core::cmp::Ordering;
use rug::{float::Round, ops::DivAssignRound, Float};
let mut f = Float::with_val(4, 1.0);
// 1/15.999 is > 1/16, rounded down to 0.5 >> 3 = 1/16
let dir = f.div_assign_round(15.999, Round::Nearest);
assert_eq!(f, 0.5 / 3f32.exp2());
assert_eq!(dir, Ordering::Less);
// Limiting exponent range to [-2, 2] pushes f correctly away from zero.
let dir = f.clamp_exp(dir, Round::Nearest, -2, 2).unwrap();
assert_eq!(f, 0.5 / 2f32.exp2());
assert_eq!(dir, Ordering::Greater);

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

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

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)

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)

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)

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

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 × log₂ k) + 13 bits.

This method has no effect if the value is not in the subnormal range.

Examples

use core::f32;
use rug::Float;
// 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

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 × log₂ k) + 13 bits.

This method simply propagates prev_rounding if the value is not in the subnormal range.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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

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;
// 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

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 core::cmp::Ordering;
use rug::{float::Round, Float};
// 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>, 

Adds a list of Float values with correct rounding.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float
• AddAssign<Src> for Float
• AddAssignRound<Src> for Float
• Add<Src> for Float

Examples

use core::cmp::Ordering;
use rug::{float::Round, ops::AddAssignRound, Float};

// 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)>, 

Finds the dot product of a list of Float value pairs with correct rounding.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float
• AddAssign<Src> for Float
• AddAssignRound<Src> for Float
• Add<Src> for Float

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);
let r = Float::dot(b.iter().zip(a.iter()));
let twice = dot + r;
assert_eq!(twice, expected * 2.0);

pub fn remainder(self, divisor: &Self) -> Self

Computes the remainder, rounding to the nearest.

The remainder is the value of self − n × divisor, where n is the integer quotient of self / divisor rounded to the nearest integer (ties rounded to even). This is different from the remainder obtained using the % operator or the Rem trait, where n is truncated instead of rounded to the nearest.

Examples

use rug::Float;
let num = Float::with_val(53, 589.4);
let den = Float::with_val(53, 100);
let remainder = num.remainder(&den);
let expected = -10.6_f64;
assert!((remainder - expected).abs() < 0.0001);

// compare to % operator
let num = Float::with_val(53, 589.4);
let den = Float::with_val(53, 100);
let rem_op = num % &den;
let expected = 89.4_f64;
assert!((rem_op - expected).abs() < 0.0001);

pub fn remainder_mut(&mut self, divisor: &Self)

Computes the remainder, rounding to the nearest.

The remainder is the value of self − n × divisor, where n is the integer quotient of self / divisor rounded to the nearest integer (ties rounded to even). This is different from the remainder obtained using the %= operator or the RemAssign trait, where n is truncated instead of rounded to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 589.4);
let g = Float::with_val(53, 100);
f.remainder_mut(&g);
let expected = -10.6_f64;
assert!((f - expected).abs() < 0.0001);

// compare to %= operator
let mut f = Float::with_val(53, 589.4);
let g = Float::with_val(53, 100);
f %= &g;
let expected = 89.4_f64;
assert!((f - expected).abs() < 0.0001);

pub fn remainder_round(&mut self, divisor: &Self, round: Round) -> Ordering

Computes the remainder, applying the specified rounding method.

The remainder is the value of self − n × divisor, where n is the integer quotient of self / divisor rounded to the nearest integer (ties rounded to even). This is different from the remainder obtained using the RemAssignRound trait, where n is truncated instead of rounded to the nearest.

Examples

use core::cmp::Ordering;
use rug::{float::Round, ops::RemAssignRound, Float};
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 128);
let g = Float::with_val(6, 49);
// remainder of 128 / 49 is 128 − 3 × 49 = −19
// using 4 significant bits: −20
let dir = f.remainder_round(&g, Round::Nearest);
assert_eq!(f, -20.0);
assert_eq!(dir, Ordering::Less);

// compare to RemAssignRound::rem_assign_round
let mut f = Float::with_val(4, 128);
let g = Float::with_val(6, 49);
// with RemAssignRound, remainder of 128 / 49 is 128 − 2 × 49 = 30
// using 4 significant bits: 30
let dir = f.rem_assign_round(&g, Round::Nearest);
assert_eq!(f, 30.0);
assert_eq!(dir, Ordering::Equal);

pub fn remainder_from(&mut self, dividend: &Self)

Computes the remainder, rounding to the nearest.

The remainder is the value of dividend − n × self, where n is the integer quotient of dividend / self rounded to the nearest integer (ties rounded to even). This is different from the remainder obtained using the RemFrom trait, where n is truncated instead of rounded to the nearest.

Examples

use rug::{ops::RemFrom, Float};
let f = Float::with_val(53, 589.4);
let mut g = Float::with_val(53, 100);
g.remainder_from(&f);
let expected = -10.6_f64;
assert!((g - expected).abs() < 0.0001);

// compare to RemFrom::rem_from
let f = Float::with_val(53, 589.4);
let mut g = Float::with_val(53, 100);
g.rem_from(&f);
let expected = 89.4_f64;
assert!((g - expected).abs() < 0.0001);

pub fn remainder_from_round(
    &mut self,
    dividend: &Self,
    round: Round
) -> Ordering

Computes the remainder, applying the specified rounding method.

The remainder is the value of dividend − n × self, where n is the integer quotient of dividend / self rounded to the nearest integer (ties rounded to even). This is different from the remainder obtained using the RemFromRound trait, where n is truncated instead of rounded to the nearest.

Examples

use core::cmp::Ordering;
use rug::{float::Round, ops::RemFromRound, Float};
// Use only 4 bits of precision to show rounding.
let f = Float::with_val(8, 171);
let mut g = Float::with_val(4, 64);
// remainder of 171 / 64 is 171 − 3 × 64 = −21
// using 4 significant bits: −20
let dir = g.remainder_from_round(&f, Round::Nearest);
assert_eq!(g, -20.0);
assert_eq!(dir, Ordering::Greater);

// compare to RemFromRound::rem_from_round
let f = Float::with_val(8, 171);
let mut g = Float::with_val(4, 64);
// with RemFromRound, remainder of 171 / 64 is 171 − 2 × 64 = 43
// using 4 significant bits: 44
let dir = g.rem_from_round(&f, Round::Nearest);
assert_eq!(g, 44.0);
assert_eq!(dir, Ordering::Greater);

pub fn remainder_ref<'a>(&'a self, divisor: &'a Self) -> RemainderIncomplete<'_>

Computes the remainder.

The remainder is the value of self − n × divisor, where n is the integer quotient of self / divisor rounded to the nearest integer (ties rounded to even). This is different from the remainder obtained using the % operator or the Rem trait, where n is truncated instead of rounded to the nearest.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

Examples

use rug::Float;
let f = Float::with_val(53, 589.4);
let g = Float::with_val(53, 100);
let remainder = Float::with_val(53, f.remainder_ref(&g));
let expected = -10.6_f64;
assert!((remainder - expected).abs() < 0.0001);

// compare to % operator
let f = Float::with_val(53, 589.4);
let g = Float::with_val(53, 100);
let rem_op = Float::with_val(53, &f % &g);
let expected = 89.4_f64;
assert!((rem_op - expected).abs() < 0.0001);

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)

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

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 core::cmp::Ordering;
use rug::{float::Round, 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
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>

Multiplies and adds in one fused operation.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

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 core::cmp::Ordering;
use rug::{float::Round, 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.
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>

Multiplies and subtracts in one fused operation.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

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 core::cmp::Ordering;
use rug::{float::Round, 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
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>

Multiplies two products and adds them in one fused operation.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

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 core::cmp::Ordering;
use rug::{float::Round, 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
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>

Multiplies two products and subtracts them in one fused operation.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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_exp(u: u32, exp: i32) -> UExpIncomplete

Multiplies u by 2^exp.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

You can also compare the returned value to a Float; the following are also implemented with the returned incomplete-computation value as Src:

• PartialEq<Src> for Float
• PartialEq<Float> for Src
• PartialOrd<Src> for Float
• PartialOrd<Float> for Src

Examples

use rug::Float;
let v = Float::u_exp(120, -100);
let f = Float::with_val(53, v);
assert_eq!(f, 120.0 * (-100f64).exp2());
let same = Float::u_exp(120 << 2, -100 - 2);
assert_eq!(f, same);

pub fn i_exp(i: i32, exp: i32) -> IExpIncomplete

Multiplies i by 2^exp.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

You can also compare the returned value to a Float; the following are also implemented with the returned incomplete-computation value as Src:

• PartialEq<Src> for Float
• PartialEq<Float> for Src
• PartialOrd<Src> for Float
• PartialOrd<Float> for Src

Examples

use rug::Float;
let v = Float::i_exp(-120, -100);
let f = Float::with_val(53, v);
assert_eq!(f, -120.0 * (-100f64).exp2());
let same = Float::i_exp(-120 << 2, -100 - 2);
assert_eq!(f, same);

pub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete

Raises base to the power of exponent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

Raises base to the power of exponent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the square, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the square.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the square root, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the square root.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

Computes the square root of u.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the reciprocal square root, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 5 in binary is 101
let mut f = Float::with_val(4, 5.0);
// 1 / √5 in binary is 0.01110010...
// 1 / √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<'_>

Computes the reciprocal square root.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the cube root, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the cube root.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the kth root, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the kth root.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

Computes the absolute value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

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

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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 copysign(self, y: &Self) -> Self

Returns a number with the magnitude of self and the sign of y.

Examples

use rug::Float;
let x = Float::with_val(53, 23.0);
let y = Float::with_val(53, -1.0);
let copysign = x.copysign(&y);
assert_eq!(copysign, -23.0);

pub fn copysign_mut(&mut self, y: &Self)

Retains the magnitude of self and copies the sign of y.

Examples

use rug::Float;
let mut x = Float::with_val(53, 23.0);
let y = Float::with_val(53, -1.0);
x.copysign_mut(&y);
assert_eq!(x, -23.0);

pub fn copysign_ref<'a>(&'a self, y: &'a Self) -> CopysignIncomplete<'_>

Computes a number with the magnitude of self and the sign of y.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

Examples

use rug::Float;
let x = Float::with_val(53, 23.0);
let y = Float::with_val(53, -1.0);
let r = x.copysign_ref(&y);
let copysign = Float::with_val(53, r);
assert_eq!(copysign, -23.0);

pub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Self where
    Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a 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<Min, Max>(&mut self, min: &Min, max: &Max) where
    Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a 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<Min, Max>(
    &mut self,
    min: &Min,
    max: &Max,
    round: Round
) -> Ordering where
    Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a 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 core::cmp::Ordering;
use rug::{float::Round, Float};
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<'min, 'max, Min, Max>(
    &self,
    min: &'min Min,
    max: &'max Max
) -> ClampIncomplete<'_, 'min, 'max, Min, Max> where
    Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a Max, Round = Round, Ordering = Ordering>, 

Clamps the value within the specified bounds.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the reciprocal, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the reciprocal.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Finds the minimum, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
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<'_>

Finds the minimum.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Finds the maximum, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
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<'_>

Finds the maximum.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

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 core::cmp::Ordering;
use rug::{float::Round, Float};
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<'_>

Computes the positive difference.

The positive difference is self − other if self > other, zero if self ≤ other, or NaN if any operand is NaN.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the natural logarithm, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the natural logarithm.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

Computes the natural logarithm of u.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the logarithm to base 2, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the logarithm to base 2.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the logarithm to base 10, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the logarithm to base 10.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the exponential, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the exponential.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes 2 to the power of self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes 2 to the power of the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes 10 to the power of self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes 10 to the power of the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the sine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the sine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the cosine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the cosine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the tangent, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the tangent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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)

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.

The initial value of cos is ignored.

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)

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.

The initial value of cos is ignored.

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)

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.

The initial value of cos is ignored.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the sine and cosine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Float, Float)
• Assign<Src> for (&mut Float, &mut Float)
• AssignRound<Src> for (Float, Float)
• AssignRound<Src> for (&mut Float, &mut Float)

Examples

use core::cmp::Ordering;
use rug::{float::Round, ops::AssignRound, Assign, Float};
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

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)

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

Computes the secant, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the secant.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the cosecant, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the cosecant.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the cotangent, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the cotangent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the arc-sine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the arc-sine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the arc-cosine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the arc-cosine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the arc-tangent, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the arc-tangent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

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 core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the arc-tangent.

This is similar to the arc-tangent of self / x, but has an output range of 2π rather than π.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the hyperbolic sine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic sine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the hyperbolic cosine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic cosine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the hyperbolic tangent, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic tangent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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)

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.

The initial value of cos is ignored.

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)

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.

The initial value of cos is ignored.

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)

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.

The initial value of cos is ignored.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic sine and cosine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Float, Float)
• Assign<Src> for (&mut Float, &mut Float)
• AssignRound<Src> for (Float, Float)
• AssignRound<Src> for (&mut Float, &mut Float)

Examples

use core::cmp::Ordering;
use rug::{float::Round, ops::AssignRound, Assign, Float};
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

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)

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

Computes the hyperbolic secant, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic secant.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the hyperbolic cosecant, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic cosecant.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the hyperbolic cotangent, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the hyperbolic cotangent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the inverse hyperbolic sine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the inverse hyperbolic sine.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the inverse hyperbolic cosine, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the inverse hyperbolic cosine

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the inverse hyperbolic tangent, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the inverse hyperbolic tangent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

Computes the factorial of n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the natural logarithm of one plus self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
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<'_>

Computes the natural logorithm of one plus the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Subtracts one from the exponential of self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
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<'_>

Computes one less than the exponential of the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the exponential integral, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the exponential integral.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the real part of the dilogarithm of self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the real part of the dilogarithm of the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the gamma function on self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the gamma function on the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the upper incomplete gamma function on self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the upper incomplete gamma function on the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the logarithm of the gamma function on self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the logarithm of the gamma function on the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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)

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 core::cmp::Ordering;
use rug::{float::Constant, Float};

// gamma of 1/2 is √π
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 core::cmp::Ordering;
use rug::{float::Constant, Float};

// gamma of −1/2 is −2√π
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

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 core::cmp::Ordering;
use rug::{float::Constant, Float};

// gamma of −1/2 is −2√π
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)

Computes the logarithm of the absolute value of the gamma function on self, applying the specified rounding method.

The returned tuple contains:

1. The logarithm of the absolute value of the gamma function.
2. The rounding direction.

Examples

use core::cmp::Ordering;
use rug::{
    float::{Constant, Round},
    Float,
};

// gamma of −1/2 is −2√π
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<'_>

Computes the logarithm of the absolute value of the gamma function on val.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Float, Ordering)
• Assign<Src> for (&mut Float, &mut Ordering)
• AssignRound<Src> for (Float, Ordering)
• AssignRound<Src> for (&mut Float, &mut Ordering)

Examples

use core::cmp::Ordering;
use rug::{float::Constant, Assign, Float};

let neg1_2 = Float::with_val(53, -0.5);
// gamma of −1/2 is −2√π
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

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)

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

Computes the value of the Digamma function on self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the Digamma function on the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the Riemann Zeta function on self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the Riemann Zeta function on the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

Computes the Riemann Zeta function on u.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the error function, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the error function.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the complementary error function, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the complementary error function.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the first kind Bessel function of order 0, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the first kind Bessel function of order 0.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the first kind Bessel function of order 1, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the first kind Bessel function of order 1.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the first kind Bessel function of order n, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the first kind Bessel function of order n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the second kind Bessel function of order 0, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the second kind Bessel function of order 0.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the second kind Bessel function of order 1, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the second kind Bessel function of order 1.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the second kind Bessel function of order n, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the second kind Bessel function of order n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the arithmetic-geometric mean of self and other, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the arithmetic-geometric mean.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the Euclidean norm of self and other, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the Euclidean norm.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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

Computes the value of the Airy function Ai on self, applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Computes the Airy function Ai on the value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

Rounds up to the next higher integer. The result may be rounded again when assigned to the target.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

Rounds down to the next lower integer. The result may be rounded again when assigned to the target.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

Rounds to the nearest integer, rounding half-way cases away from zero. The result may be rounded again when assigned to the target.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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::Round, Float};
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

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)

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<'_>

Rounds to the nearest integer, rounding half-way cases to even. The result may be rounded again when assigned to the target.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

Rounds to the next integer towards zero. The result may be rounded again when assigned to the target.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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

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)

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<'_>

Gets the fractional part of the number.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

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)

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.

The initial value of fract is ignored.

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)

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.

The initial value of fract is ignored.

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)

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.

The initial value of fract is ignored.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
// 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<'_>

Gets the integer and fractional parts of the number.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Float, Float)
• Assign<Src> for (&mut Float, &mut Float)
• AssignRound<Src> for (Float, Float)
• AssignRound<Src> for (&mut Float, &mut Float)

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(rng: &mut dyn MutRandState) -> RandomBitsIncomplete<'_>

Generates a random number in the range 0 ≤ x < 1.

This is equivalent to generating a random integer in the range 0 ≤ x < 2^p, where 2^p is two raised to the power of the precision, and then dividing the integer by 2^p. 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, 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(rng: &mut dyn MutRandState) -> RandomContIncomplete<'_>

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.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

Examples

use rug::{rand::RandState, 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(rng: &mut dyn MutRandState) -> RandomNormalIncomplete<'_>

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.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

Examples

use rug::{rand::RandState, 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(rng: &mut dyn MutRandState) -> RandomExpIncomplete<'_>

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.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Float
• AssignRound<Src> for Float

Examples

use rug::{rand::RandState, 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 Add<&'_ Float> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &Float) -> Float

Performs the + operation.

impl Add<&'_ Integer> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> Float

Performs the + operation.

impl Add<&'_ f32> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<&'_ f64> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<&'_ i128> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> Float

Performs the + operation.

impl<'b> Add<&'_ i128> for &'b Float

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> AddI128Incomplete<'b>

Performs the + operation.

impl Add<&'_ i16> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Float

Performs the + operation.

impl<'b> Add<&'_ i16> for &'b Float

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> AddI16Incomplete<'b>

Performs the + operation.

impl Add<&'_ i32> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<&'_ i64> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Float

Performs the + operation.

impl<'b> Add<&'_ i64> for &'b Float

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> AddI64Incomplete<'b>

Performs the + operation.

impl Add<&'_ i8> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> Float

Performs the + operation.

impl<'b> Add<&'_ i8> for &'b Float

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> AddI8Incomplete<'b>

Performs the + operation.

impl Add<&'_ u128> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> Float

Performs the + operation.

impl<'b> Add<&'_ u128> for &'b Float

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> AddU128Incomplete<'b>

Performs the + operation.

impl Add<&'_ u16> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Float

Performs the + operation.

impl<'b> Add<&'_ u16> for &'b Float

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> AddU16Incomplete<'b>

Performs the + operation.

impl Add<&'_ u32> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<&'_ u64> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Float

Performs the + operation.

impl<'b> Add<&'_ u64> for &'b Float

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> AddU64Incomplete<'b>

Performs the + operation.

impl Add<&'_ u8> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> Float

Performs the + operation.

impl<'b> Add<&'_ u8> for &'b Float

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> AddU8Incomplete<'b>

Performs the + operation.

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<'_>

Performs the + operation.

impl<'a> Add<&'a Float> for Integer

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &Float) -> AddOwnedIntegerIncomplete<'_>

Performs the + operation.

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<'_>

Performs the + operation.

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<'_>

Performs the + operation.

impl Add<Float> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> Float

Performs the + operation.

impl Add<Float> for &Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> Float

Performs the + operation.

impl Add<Float> for Integer

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> Float

Performs the + operation.

impl Add<Float> for &Integer

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> Float

Performs the + operation.

impl Add<Integer> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<f32> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<f64> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<i128> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> Float

Performs the + operation.

impl<'b> Add<i128> for &'b Float

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> AddI128Incomplete<'b>

Performs the + operation.

impl Add<i16> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Float

Performs the + operation.

impl<'b> Add<i16> for &'b Float

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> AddI16Incomplete<'b>

Performs the + operation.

impl Add<i32> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<i64> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Float

Performs the + operation.

impl<'b> Add<i64> for &'b Float

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> AddI64Incomplete<'b>

Performs the + operation.

impl Add<i8> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Float

Performs the + operation.

impl<'b> Add<i8> for &'b Float

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> AddI8Incomplete<'b>

Performs the + operation.

impl Add<u128> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Float

Performs the + operation.

impl<'b> Add<u128> for &'b Float

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> AddU128Incomplete<'b>

Performs the + operation.

impl Add<u16> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Float

Performs the + operation.

impl<'b> Add<u16> for &'b Float

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> AddU16Incomplete<'b>

Performs the + operation.

impl Add<u32> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Float

Performs the + operation.

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>

Performs the + operation.

impl Add<u64> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Float

Performs the + operation.

impl<'b> Add<u64> for &'b Float

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> AddU64Incomplete<'b>

Performs the + operation.

impl Add<u8> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Float

Performs the + operation.

impl<'b> Add<u8> for &'b Float

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> AddU8Incomplete<'b>

Performs the + operation.

impl AddAssign<&'_ Float> for Float

fn add_assign(&mut self, rhs: &Float)

Performs the += operation.

impl AddAssign<&'_ Integer> for Float

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddAssign<&'_ f32> for Float

fn add_assign(&mut self, rhs: &f32)

Performs the += operation.

impl AddAssign<&'_ f64> for Float

fn add_assign(&mut self, rhs: &f64)

Performs the += operation.

impl AddAssign<&'_ i128> for Float

fn add_assign(&mut self, rhs: &i128)

Performs the += operation.

impl AddAssign<&'_ i16> for Float

fn add_assign(&mut self, rhs: &i16)

Performs the += operation.

impl AddAssign<&'_ i32> for Float

fn add_assign(&mut self, rhs: &i32)

Performs the += operation.

impl AddAssign<&'_ i64> for Float

fn add_assign(&mut self, rhs: &i64)

Performs the += operation.

impl AddAssign<&'_ i8> for Float

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl AddAssign<&'_ u128> for Float

fn add_assign(&mut self, rhs: &u128)

Performs the += operation.

impl AddAssign<&'_ u16> for Float

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl AddAssign<&'_ u32> for Float

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl AddAssign<&'_ u64> for Float

fn add_assign(&mut self, rhs: &u64)

Performs the += operation.

impl AddAssign<&'_ u8> for Float

fn add_assign(&mut self, rhs: &u8)

Performs the += operation.

impl AddAssign<Float> for Float

fn add_assign(&mut self, rhs: Float)

Performs the += operation.

impl AddAssign<Integer> for Float

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssign<f32> for Float

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl AddAssign<f64> for Float

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl AddAssign<i128> for Float

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl AddAssign<i16> for Float

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for Float

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for Float

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for Float

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<u128> for Float

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for Float

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for Float

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for Float

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for Float

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

impl AddAssignRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &i128, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &i16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddAssignRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &i64, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &i8, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &u128, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &u16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddAssignRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &u64, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &u8, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

impl AddAssignRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: i128, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: i16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddAssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: i64, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: i8, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: u128, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: u16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddAssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: u64, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: u8, round: Round) -> Ordering

Performs the addition.

impl AddFrom<&'_ Float> for Float

fn add_from(&mut self, lhs: &Float)

Peforms the addition.

impl AddFrom<&'_ Integer> for Float

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

impl AddFrom<&'_ f32> for Float

fn add_from(&mut self, lhs: &f32)

Peforms the addition.

impl AddFrom<&'_ f64> for Float

fn add_from(&mut self, lhs: &f64)

Peforms the addition.

impl AddFrom<&'_ i128> for Float

fn add_from(&mut self, lhs: &i128)

Peforms the addition.

impl AddFrom<&'_ i16> for Float

fn add_from(&mut self, lhs: &i16)

Peforms the addition.

impl AddFrom<&'_ i32> for Float

fn add_from(&mut self, lhs: &i32)

Peforms the addition.

impl AddFrom<&'_ i64> for Float

fn add_from(&mut self, lhs: &i64)

Peforms the addition.

impl AddFrom<&'_ i8> for Float

fn add_from(&mut self, lhs: &i8)

Peforms the addition.

impl AddFrom<&'_ u128> for Float

fn add_from(&mut self, lhs: &u128)

Peforms the addition.

impl AddFrom<&'_ u16> for Float

fn add_from(&mut self, lhs: &u16)

Peforms the addition.

impl AddFrom<&'_ u32> for Float

fn add_from(&mut self, lhs: &u32)

Peforms the addition.

impl AddFrom<&'_ u64> for Float

fn add_from(&mut self, lhs: &u64)

Peforms the addition.

impl AddFrom<&'_ u8> for Float

fn add_from(&mut self, lhs: &u8)

Peforms the addition.

impl AddFrom<Float> for Float

fn add_from(&mut self, lhs: Float)

Peforms the addition.

impl AddFrom<Integer> for Float

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl AddFrom<f32> for Float

fn add_from(&mut self, lhs: f32)

Peforms the addition.

impl AddFrom<f64> for Float

fn add_from(&mut self, lhs: f64)

Peforms the addition.

impl AddFrom<i128> for Float

fn add_from(&mut self, lhs: i128)

Peforms the addition.

impl AddFrom<i16> for Float

fn add_from(&mut self, lhs: i16)

Peforms the addition.

impl AddFrom<i32> for Float

fn add_from(&mut self, lhs: i32)

Peforms the addition.

impl AddFrom<i64> for Float

fn add_from(&mut self, lhs: i64)

Peforms the addition.

impl AddFrom<i8> for Float

fn add_from(&mut self, lhs: i8)

Peforms the addition.

impl AddFrom<u128> for Float

fn add_from(&mut self, lhs: u128)

Peforms the addition.

impl AddFrom<u16> for Float

fn add_from(&mut self, lhs: u16)

Peforms the addition.

impl AddFrom<u32> for Float

fn add_from(&mut self, lhs: u32)

Peforms the addition.

impl AddFrom<u64> for Float

fn add_from(&mut self, lhs: u64)

Peforms the addition.

impl AddFrom<u8> for Float

fn add_from(&mut self, lhs: u8)

Peforms the addition.

impl 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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

impl AddFromRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &i128, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &i16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddFromRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &i64, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &i8, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &u128, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &u16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddFromRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &u64, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &u8, round: Round) -> Ordering

Performs the addition.

impl 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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

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

Performs the addition.

impl AddFromRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: i128, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: i16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddFromRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: i64, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: i8, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: u128, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: u16, round: Round) -> Ordering

Performs the addition.

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

Performs the addition.

impl AddFromRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: u64, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: u8, round: Round) -> Ordering

Performs the addition.

impl AsMut<Float> for OrdFloat

fn as_mut(&mut self) -> &mut Float

Performs the conversion.

impl AsRef<Float> for OrdFloat

fn as_ref(&self) -> &Float

Performs the conversion.

impl AsRef<OrdFloat> for Float

fn as_ref(&self) -> &OrdFloat

Performs the conversion.

impl<T> Assign<T> for Float where
    Self: AssignRound<T, Round = Round, Ordering = Ordering>, 

fn assign(&mut self, src: T)

Peforms the assignement.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

impl AssignRound<&'_ 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

Peforms the assignment.

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

Peforms the assignment.

impl AssignRound<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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

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

Peforms the assignment.

impl Binary for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Cast<Integer> for Float

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for &Float

fn cast(self) -> Integer

Casts the value.

impl Cast<f32> for Float

fn cast(self) -> f32

Casts the value.

impl Cast<f32> for &Float

fn cast(self) -> f32

Casts the value.

impl Cast<f64> for Float

fn cast(self) -> f64

Casts the value.

impl Cast<f64> for &Float

fn cast(self) -> f64

Casts the value.

impl CheckedCast<Integer> for Float

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<Integer> for &Float

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl Clone for Float

fn clone(&self) -> Float

Returns a copy of the value.

fn clone_from(&mut self, source: &Float)

Performs copy-assignment from source.

impl Debug for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Display for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Div<&'_ Float> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &Float) -> Float

Performs the / operation.

impl Div<&'_ Integer> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> Float

Performs the / operation.

impl Div<&'_ f32> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<&'_ f64> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<&'_ i128> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> Float

Performs the / operation.

impl<'b> Div<&'_ i128> for &'b Float

type Output = DivI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> DivI128Incomplete<'b>

Performs the / operation.

impl Div<&'_ i16> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Float

Performs the / operation.

impl<'b> Div<&'_ i16> for &'b Float

type Output = DivI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> DivI16Incomplete<'b>

Performs the / operation.

impl Div<&'_ i32> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<&'_ i64> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Float

Performs the / operation.

impl<'b> Div<&'_ i64> for &'b Float

type Output = DivI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> DivI64Incomplete<'b>

Performs the / operation.

impl Div<&'_ i8> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Float

Performs the / operation.

impl<'b> Div<&'_ i8> for &'b Float

type Output = DivI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> DivI8Incomplete<'b>

Performs the / operation.

impl Div<&'_ u128> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> Float

Performs the / operation.

impl<'b> Div<&'_ u128> for &'b Float

type Output = DivU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> DivU128Incomplete<'b>

Performs the / operation.

impl Div<&'_ u16> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Float

Performs the / operation.

impl<'b> Div<&'_ u16> for &'b Float

type Output = DivU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> DivU16Incomplete<'b>

Performs the / operation.

impl Div<&'_ u32> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<&'_ u64> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Float

Performs the / operation.

impl<'b> Div<&'_ u64> for &'b Float

type Output = DivU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> DivU64Incomplete<'b>

Performs the / operation.

impl Div<&'_ u8> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> Float

Performs the / operation.

impl<'b> Div<&'_ u8> for &'b Float

type Output = DivU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> DivU8Incomplete<'b>

Performs the / operation.

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<'_>

Performs the / operation.

impl<'a> Div<&'a Float> for Integer

type Output = DivFromOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &Float) -> DivFromOwnedIntegerIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Float> for &'a Integer

type Output = DivFromIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivFromIntegerIncomplete<'_>

Performs the / operation.

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<'_>

Performs the / operation.

impl Div<Float> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

impl Div<Float> for &Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

impl Div<Float> for Integer

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

impl Div<Float> for &Integer

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

impl Div<Integer> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> Float

Performs the / operation.

impl<'a> Div<Integer> for &'a Float

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a>

Performs the / operation.

impl Div<f32> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<f64> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<i128> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> Float

Performs the / operation.

impl<'b> Div<i128> for &'b Float

type Output = DivI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> DivI128Incomplete<'b>

Performs the / operation.

impl Div<i16> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Float

Performs the / operation.

impl<'b> Div<i16> for &'b Float

type Output = DivI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> DivI16Incomplete<'b>

Performs the / operation.

impl Div<i32> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<i64> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Float

Performs the / operation.

impl<'b> Div<i64> for &'b Float

type Output = DivI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DivI64Incomplete<'b>

Performs the / operation.

impl Div<i8> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Float

Performs the / operation.

impl<'b> Div<i8> for &'b Float

type Output = DivI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> DivI8Incomplete<'b>

Performs the / operation.

impl Div<u128> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Float

Performs the / operation.

impl<'b> Div<u128> for &'b Float

type Output = DivU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> DivU128Incomplete<'b>

Performs the / operation.

impl Div<u16> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Float

Performs the / operation.

impl<'b> Div<u16> for &'b Float

type Output = DivU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> DivU16Incomplete<'b>

Performs the / operation.

impl Div<u32> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Float

Performs the / operation.

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>

Performs the / operation.

impl Div<u64> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Float

Performs the / operation.

impl<'b> Div<u64> for &'b Float

type Output = DivU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DivU64Incomplete<'b>

Performs the / operation.

impl Div<u8> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Float

Performs the / operation.

impl<'b> Div<u8> for &'b Float

type Output = DivU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> DivU8Incomplete<'b>

Performs the / operation.

impl DivAssign<&'_ Float> for Float

fn div_assign(&mut self, rhs: &Float)

Performs the /= operation.

impl DivAssign<&'_ Integer> for Float

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivAssign<&'_ f32> for Float

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl DivAssign<&'_ f64> for Float

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation.

impl DivAssign<&'_ i128> for Float

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl DivAssign<&'_ i16> for Float

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl DivAssign<&'_ i32> for Float

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl DivAssign<&'_ i64> for Float

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl DivAssign<&'_ i8> for Float

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl DivAssign<&'_ u128> for Float

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl DivAssign<&'_ u16> for Float

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl DivAssign<&'_ u32> for Float

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl DivAssign<&'_ u64> for Float

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl DivAssign<&'_ u8> for Float

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl DivAssign<Float> for Float

fn div_assign(&mut self, rhs: Float)

Performs the /= operation.

impl DivAssign<Integer> for Float

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssign<f32> for Float

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign<f64> for Float

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl DivAssign<i128> for Float

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl DivAssign<i16> for Float

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for Float

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for Float

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for Float

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<u128> for Float

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for Float

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for Float

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for Float

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for Float

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

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

Performs the division.

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

Performs the division.

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

Performs the division.

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

Performs the division.

impl DivAssignRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &i128, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &i16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivAssignRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &i64, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &i8, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &u128, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &u16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivAssignRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &u64, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &u8, round: Round) -> Ordering

Performs the division.

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

Performs the division.

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

Performs the division.

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

Performs the division.

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

Performs the division.

impl DivAssignRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: i128, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: i16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivAssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: i64, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: i8, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: u128, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: u16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivAssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: u64, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: u8, round: Round) -> Ordering

Performs the division.

impl DivFrom<&'_ Float> for Float

fn div_from(&mut self, lhs: &Float)

Peforms the division.

impl DivFrom<&'_ Integer> for Float

fn div_from(&mut self, lhs: &Integer)

Peforms the division.

impl DivFrom<&'_ f32> for Float

fn div_from(&mut self, lhs: &f32)

Peforms the division.

impl DivFrom<&'_ f64> for Float

fn div_from(&mut self, lhs: &f64)

Peforms the division.

impl DivFrom<&'_ i128> for Float

fn div_from(&mut self, lhs: &i128)

Peforms the division.

impl DivFrom<&'_ i16> for Float

fn div_from(&mut self, lhs: &i16)

Peforms the division.

impl DivFrom<&'_ i32> for Float

fn div_from(&mut self, lhs: &i32)

Peforms the division.

impl DivFrom<&'_ i64> for Float

fn div_from(&mut self, lhs: &i64)

Peforms the division.

impl DivFrom<&'_ i8> for Float

fn div_from(&mut self, lhs: &i8)

Peforms the division.

impl DivFrom<&'_ u128> for Float

fn div_from(&mut self, lhs: &u128)

Peforms the division.

impl DivFrom<&'_ u16> for Float

fn div_from(&mut self, lhs: &u16)

Peforms the division.

impl DivFrom<&'_ u32> for Float

fn div_from(&mut self, lhs: &u32)

Peforms the division.

impl DivFrom<&'_ u64> for Float

fn div_from(&mut self, lhs: &u64)

Peforms the division.

impl DivFrom<&'_ u8> for Float

fn div_from(&mut self, lhs: &u8)

Peforms the division.

impl DivFrom<Float> for Float

fn div_from(&mut self, lhs: Float)

Peforms the division.

impl DivFrom<Integer> for Float

fn div_from(&mut self, lhs: Integer)

Peforms the division.

impl DivFrom<f32> for Float

fn div_from(&mut self, lhs: f32)

Peforms the division.

impl DivFrom<f64> for Float

fn div_from(&mut self, lhs: f64)

Peforms the division.

impl DivFrom<i128> for Float

fn div_from(&mut self, lhs: i128)

Peforms the division.

impl DivFrom<i16> for Float

fn div_from(&mut self, lhs: i16)

Peforms the division.

impl DivFrom<i32> for Float

fn div_from(&mut self, lhs: i32)

Peforms the division.

impl DivFrom<i64> for Float

fn div_from(&mut self, lhs: i64)

Peforms the division.

impl DivFrom<i8> for Float

fn div_from(&mut self, lhs: i8)

Peforms the division.

impl DivFrom<u128> for Float

fn div_from(&mut self, lhs: u128)

Peforms the division.

impl DivFrom<u16> for Float

fn div_from(&mut self, lhs: u16)

Peforms the division.

impl DivFrom<u32> for Float

fn div_from(&mut self, lhs: u32)

Peforms the division.

impl DivFrom<u64> for Float

fn div_from(&mut self, lhs: u64)

Peforms the division.

impl DivFrom<u8> for Float

fn div_from(&mut self, lhs: u8)

Peforms the division.

impl 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

Performs the division.

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

Performs the division.

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

Performs the division.

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

Performs the division.

impl DivFromRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &i128, round: Round) -> Ordering

Performs the division.

impl DivFromRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &i16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivFromRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &i64, round: Round) -> Ordering

Performs the division.

impl DivFromRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &i8, round: Round) -> Ordering

Performs the division.

impl DivFromRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &u128, round: Round) -> Ordering

Performs the division.

impl DivFromRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &u16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivFromRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &u64, round: Round) -> Ordering

Performs the division.

impl DivFromRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &u8, round: Round) -> Ordering

Performs the division.

impl 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

Performs the division.

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

Performs the division.

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

Performs the division.

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

Performs the division.

impl DivFromRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: i128, round: Round) -> Ordering

Performs the division.

impl DivFromRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: i16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivFromRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: i64, round: Round) -> Ordering

Performs the division.

impl DivFromRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: i8, round: Round) -> Ordering

Performs the division.

impl DivFromRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: u128, round: Round) -> Ordering

Performs the division.

impl DivFromRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: u16, round: Round) -> Ordering

Performs the division.

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

Performs the division.

impl DivFromRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: u64, round: Round) -> Ordering

Performs the division.

impl DivFromRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: u8, round: Round) -> Ordering

Performs the division.

impl Drop for Float

fn drop(&mut self)

Executes the destructor for this type.

impl From<Float> for OrdFloat

fn from(src: Float) -> Self

Performs the conversion.

impl From<OrdFloat> for Float

fn from(src: OrdFloat) -> Self

Performs the conversion.

impl LowerExp for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl LowerHex for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Mul<&'_ Float> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &Float) -> Float

Performs the * operation.

impl Mul<&'_ Integer> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> Float

Performs the * operation.

impl Mul<&'_ f32> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<&'_ f64> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<&'_ i128> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> Float

Performs the * operation.

impl<'b> Mul<&'_ i128> for &'b Float

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> MulI128Incomplete<'b>

Performs the * operation.

impl Mul<&'_ i16> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Float

Performs the * operation.

impl<'b> Mul<&'_ i16> for &'b Float

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> MulI16Incomplete<'b>

Performs the * operation.

impl Mul<&'_ i32> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<&'_ i64> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Float

Performs the * operation.

impl<'b> Mul<&'_ i64> for &'b Float

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> MulI64Incomplete<'b>

Performs the * operation.

impl Mul<&'_ i8> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Float

Performs the * operation.

impl<'b> Mul<&'_ i8> for &'b Float

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> MulI8Incomplete<'b>

Performs the * operation.

impl Mul<&'_ u128> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> Float

Performs the * operation.

impl<'b> Mul<&'_ u128> for &'b Float

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> MulU128Incomplete<'b>

Performs the * operation.

impl Mul<&'_ u16> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Float

Performs the * operation.

impl<'b> Mul<&'_ u16> for &'b Float

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> MulU16Incomplete<'b>

Performs the * operation.

impl Mul<&'_ u32> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<&'_ u64> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Float

Performs the * operation.

impl<'b> Mul<&'_ u64> for &'b Float

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> MulU64Incomplete<'b>

Performs the * operation.

impl Mul<&'_ u8> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> Float

Performs the * operation.

impl<'b> Mul<&'_ u8> for &'b Float

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> MulU8Incomplete<'b>

Performs the * operation.

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<'_>

Performs the * operation.

impl<'a> Mul<&'a Float> for Integer

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &Float) -> MulOwnedIntegerIncomplete<'_>

Performs the * operation.

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<'_>

Performs the * operation.

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<'_>

Performs the * operation.

impl Mul<Float> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

Performs the * operation.

impl Mul<Float> for &Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

Performs the * operation.

impl Mul<Float> for Integer

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

Performs the * operation.

impl Mul<Float> for &Integer

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

Performs the * operation.

impl Mul<Integer> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<f32> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<f64> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<i128> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Float

Performs the * operation.

impl<'b> Mul<i128> for &'b Float

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> MulI128Incomplete<'b>

Performs the * operation.

impl Mul<i16> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Float

Performs the * operation.

impl<'b> Mul<i16> for &'b Float

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> MulI16Incomplete<'b>

Performs the * operation.

impl Mul<i32> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<i64> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Float

Performs the * operation.

impl<'b> Mul<i64> for &'b Float

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> MulI64Incomplete<'b>

Performs the * operation.

impl Mul<i8> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Float

Performs the * operation.

impl<'b> Mul<i8> for &'b Float

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> MulI8Incomplete<'b>

Performs the * operation.

impl Mul<u128> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Float

Performs the * operation.

impl<'b> Mul<u128> for &'b Float

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> MulU128Incomplete<'b>

Performs the * operation.

impl Mul<u16> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Float

Performs the * operation.

impl<'b> Mul<u16> for &'b Float

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> MulU16Incomplete<'b>

Performs the * operation.

impl Mul<u32> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Float

Performs the * operation.

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>

Performs the * operation.

impl Mul<u64> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Float

Performs the * operation.

impl<'b> Mul<u64> for &'b Float

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> MulU64Incomplete<'b>

Performs the * operation.

impl Mul<u8> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Float

Performs the * operation.

impl<'b> Mul<u8> for &'b Float

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> MulU8Incomplete<'b>

Performs the * operation.

impl MulAssign<&'_ Float> for Float

fn mul_assign(&mut self, rhs: &Float)

Performs the *= operation.

impl MulAssign<&'_ Integer> for Float

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&'_ f32> for Float

fn mul_assign(&mut self, rhs: &f32)

Performs the *= operation.

impl MulAssign<&'_ f64> for Float

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation.

impl MulAssign<&'_ i128> for Float

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl MulAssign<&'_ i16> for Float

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl MulAssign<&'_ i32> for Float

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl MulAssign<&'_ i64> for Float

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl MulAssign<&'_ i8> for Float

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl MulAssign<&'_ u128> for Float

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl MulAssign<&'_ u16> for Float

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl MulAssign<&'_ u32> for Float

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl MulAssign<&'_ u64> for Float

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl MulAssign<&'_ u8> for Float

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl MulAssign<Float> for Float

fn mul_assign(&mut self, rhs: Float)

Performs the *= operation.

impl MulAssign<Integer> for Float

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssign<f32> for Float

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<f64> for Float

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl MulAssign<i128> for Float

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl MulAssign<i16> for Float

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for Float

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for Float

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for Float

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<u128> for Float

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for Float

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for Float

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for Float

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for Float

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

impl MulAssignRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &i128, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &i16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulAssignRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &i64, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &i8, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &u128, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &u16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulAssignRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &u64, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &u8, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

impl MulAssignRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: i128, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: i16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulAssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: i64, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: i8, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: u128, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: u16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulAssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: u64, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: u8, round: Round) -> Ordering

Performs the multiplication.

impl MulFrom<&'_ Float> for Float

fn mul_from(&mut self, lhs: &Float)

Peforms the multiplication.

impl MulFrom<&'_ Integer> for Float

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

impl MulFrom<&'_ f32> for Float

fn mul_from(&mut self, lhs: &f32)

Peforms the multiplication.

impl MulFrom<&'_ f64> for Float

fn mul_from(&mut self, lhs: &f64)

Peforms the multiplication.

impl MulFrom<&'_ i128> for Float

fn mul_from(&mut self, lhs: &i128)

Peforms the multiplication.

impl MulFrom<&'_ i16> for Float

fn mul_from(&mut self, lhs: &i16)

Peforms the multiplication.

impl MulFrom<&'_ i32> for Float

fn mul_from(&mut self, lhs: &i32)

Peforms the multiplication.

impl MulFrom<&'_ i64> for Float

fn mul_from(&mut self, lhs: &i64)

Peforms the multiplication.

impl MulFrom<&'_ i8> for Float

fn mul_from(&mut self, lhs: &i8)

Peforms the multiplication.

impl MulFrom<&'_ u128> for Float

fn mul_from(&mut self, lhs: &u128)

Peforms the multiplication.

impl MulFrom<&'_ u16> for Float

fn mul_from(&mut self, lhs: &u16)

Peforms the multiplication.

impl MulFrom<&'_ u32> for Float

fn mul_from(&mut self, lhs: &u32)

Peforms the multiplication.

impl MulFrom<&'_ u64> for Float

fn mul_from(&mut self, lhs: &u64)

Peforms the multiplication.

impl MulFrom<&'_ u8> for Float

fn mul_from(&mut self, lhs: &u8)

Peforms the multiplication.

impl MulFrom<Float> for Float

fn mul_from(&mut self, lhs: Float)

Peforms the multiplication.

impl MulFrom<Integer> for Float

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl MulFrom<f32> for Float

fn mul_from(&mut self, lhs: f32)

Peforms the multiplication.

impl MulFrom<f64> for Float

fn mul_from(&mut self, lhs: f64)

Peforms the multiplication.

impl MulFrom<i128> for Float

fn mul_from(&mut self, lhs: i128)

Peforms the multiplication.

impl MulFrom<i16> for Float

fn mul_from(&mut self, lhs: i16)

Peforms the multiplication.

impl MulFrom<i32> for Float

fn mul_from(&mut self, lhs: i32)

Peforms the multiplication.

impl MulFrom<i64> for Float

fn mul_from(&mut self, lhs: i64)

Peforms the multiplication.

impl MulFrom<i8> for Float

fn mul_from(&mut self, lhs: i8)

Peforms the multiplication.

impl MulFrom<u128> for Float

fn mul_from(&mut self, lhs: u128)

Peforms the multiplication.

impl MulFrom<u16> for Float

fn mul_from(&mut self, lhs: u16)

Peforms the multiplication.

impl MulFrom<u32> for Float

fn mul_from(&mut self, lhs: u32)

Peforms the multiplication.

impl MulFrom<u64> for Float

fn mul_from(&mut self, lhs: u64)

Peforms the multiplication.

impl MulFrom<u8> for Float

fn mul_from(&mut self, lhs: u8)

Peforms the multiplication.

impl 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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

impl MulFromRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &i128, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &i16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulFromRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &i64, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &i8, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &u128, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &u16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulFromRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &u64, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &u8, round: Round) -> Ordering

Performs the multiplication.

impl 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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

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

Performs the multiplication.

impl MulFromRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: i128, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: i16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulFromRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: i64, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: i8, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: u128, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: u16, round: Round) -> Ordering

Performs the multiplication.

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

Performs the multiplication.

impl MulFromRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: u64, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: u8, round: Round) -> Ordering

Performs the multiplication.

impl Neg for Float

type Output = Float

The resulting type after applying the - operator.

fn neg(self) -> Float

Performs the unary - operation.

impl<'a> Neg for &'a Float

type Output = NegIncomplete<'a>

The resulting type after applying the - operator.

fn neg(self) -> NegIncomplete<'a>

Performs the unary - operation.

impl NegAssign for Float

fn neg_assign(&mut self)

Peforms the negation.

impl Octal for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl PartialEq<Float> for Float

fn eq(&self, other: &Float) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Float> for Integer

fn eq(&self, other: &Float) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Float> for Special

fn eq(&self, other: &Float) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Integer> for Float

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Special> for Float

fn eq(&self, other: &Special) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<f32> for Float

fn eq(&self, other: &f32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<f64> for Float

fn eq(&self, other: &f64) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i128> for Float

fn eq(&self, other: &i128) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i16> for Float

fn eq(&self, other: &i16) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i32> for Float

fn eq(&self, other: &i32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i64> for Float

fn eq(&self, other: &i64) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i8> for Float

fn eq(&self, other: &i8) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<isize> for Float

fn eq(&self, other: &isize) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u128> for Float

fn eq(&self, other: &u128) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u16> for Float

fn eq(&self, other: &u16) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u32> for Float

fn eq(&self, other: &u32) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u64> for Float

fn eq(&self, other: &u64) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u8> for Float

fn eq(&self, other: &u8) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<usize> for Float

fn eq(&self, other: &usize) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Float> for Float

fn partial_cmp(&self, other: &Float) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Float) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Float) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Float) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Float) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Float> for Integer

fn partial_cmp(&self, other: &Float) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Float> for Special

fn partial_cmp(&self, other: &Float) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for Float

fn partial_cmp(&self, z: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Special> for Float

fn partial_cmp(&self, other: &Special) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f32> for Float

fn partial_cmp(&self, t: &f32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f64> for Float

fn partial_cmp(&self, t: &f64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i128> for Float

fn partial_cmp(&self, t: &i128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i16> for Float

fn partial_cmp(&self, t: &i16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i32> for Float

fn partial_cmp(&self, t: &i32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i64> for Float

fn partial_cmp(&self, t: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i8> for Float

fn partial_cmp(&self, t: &i8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<isize> for Float

fn partial_cmp(&self, t: &isize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u128> for Float

fn partial_cmp(&self, t: &u128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u16> for Float

fn partial_cmp(&self, t: &u16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u32> for Float

fn partial_cmp(&self, t: &u32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u64> for Float

fn partial_cmp(&self, t: &u64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u8> for Float

fn partial_cmp(&self, t: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<usize> for Float

fn partial_cmp(&self, t: &usize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Pow<&'_ Float> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> Float

Performs the power operation.

impl Pow<&'_ Integer> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &Integer) -> Float

Performs the power operation.

impl Pow<&'_ f32> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &f32) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<&'_ f64> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &f64) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<&'_ i128> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &i128) -> Float

Performs the power operation.

impl<'b> Pow<&'_ i128> for &'b Float

type Output = PowI128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &i128) -> PowI128Incomplete<'b>

Performs the power operation.

impl Pow<&'_ i16> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &i16) -> Float

Performs the power operation.

impl<'b> Pow<&'_ i16> for &'b Float

type Output = PowI16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &i16) -> PowI16Incomplete<'b>

Performs the power operation.

impl Pow<&'_ i32> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &i32) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<&'_ i64> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &i64) -> Float

Performs the power operation.

impl<'b> Pow<&'_ i64> for &'b Float

type Output = PowI64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &i64) -> PowI64Incomplete<'b>

Performs the power operation.

impl Pow<&'_ i8> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &i8) -> Float

Performs the power operation.

impl<'b> Pow<&'_ i8> for &'b Float

type Output = PowI8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &i8) -> PowI8Incomplete<'b>

Performs the power operation.

impl Pow<&'_ u128> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &u128) -> Float

Performs the power operation.

impl<'b> Pow<&'_ u128> for &'b Float

type Output = PowU128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &u128) -> PowU128Incomplete<'b>

Performs the power operation.

impl Pow<&'_ u16> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &u16) -> Float

Performs the power operation.

impl<'b> Pow<&'_ u16> for &'b Float

type Output = PowU16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &u16) -> PowU16Incomplete<'b>

Performs the power operation.

impl Pow<&'_ u32> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &u32) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<&'_ u64> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &u64) -> Float

Performs the power operation.

impl<'b> Pow<&'_ u64> for &'b Float

type Output = PowU64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &u64) -> PowU64Incomplete<'b>

Performs the power operation.

impl Pow<&'_ u8> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &u8) -> Float

Performs the power operation.

impl<'b> Pow<&'_ u8> for &'b Float

type Output = PowU8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &u8) -> PowU8Incomplete<'b>

Performs the power operation.

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<'_>

Performs the power operation.

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<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for i8

type Output = PowFromI8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromI8Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &i8

type Output = PowFromI8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromI8Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for u8

type Output = PowFromU8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromU8Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &u8

type Output = PowFromU8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromU8Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for u16

type Output = PowFromU16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromU16Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &u16

type Output = PowFromU16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromU16Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for u32

type Output = PowFromU32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromU32Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &u32

type Output = PowFromU32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromU32Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for u64

type Output = PowFromU64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromU64Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &u64

type Output = PowFromU64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromU64Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for u128

type Output = PowFromU128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromU128Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &u128

type Output = PowFromU128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromU128Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for i16

type Output = PowFromI16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromI16Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for f32

type Output = PowFromF32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromF32Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &f32

type Output = PowFromF32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromF32Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for f64

type Output = PowFromF64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromF64Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &f64

type Output = PowFromF64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromF64Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for &i16

type Output = PowFromI16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromI16Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for i32

type Output = PowFromI32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromI32Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &i32

type Output = PowFromI32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromI32Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for i64

type Output = PowFromI64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromI64Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &i64

type Output = PowFromI64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromI64Incomplete<'b>

Performs the power operation.

impl<'b> Pow<&'b Float> for i128

type Output = PowFromI128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &Float) -> PowFromI128Incomplete<'_>

Performs the power operation.

impl<'b> Pow<&'b Float> for &i128

type Output = PowFromI128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'b Float) -> PowFromI128Incomplete<'b>

Performs the power operation.

impl Pow<Float> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for i128

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &i128

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for u8

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &u8

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for u16

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &u16

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for u32

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &u32

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for u64

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &u64

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for i8

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for u128

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &u128

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for f32

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &f32

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for f64

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &f64

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &i8

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for i16

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &i16

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for i32

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &i32

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for i64

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Float> for &i64

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Float) -> Float

Performs the power operation.

impl Pow<Integer> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<f32> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: f32) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<f64> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: f64) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<i128> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: i128) -> Float

Performs the power operation.

impl<'b> Pow<i128> for &'b Float

type Output = PowI128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: i128) -> PowI128Incomplete<'b>

Performs the power operation.

impl Pow<i16> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: i16) -> Float

Performs the power operation.

impl<'b> Pow<i16> for &'b Float

type Output = PowI16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: i16) -> PowI16Incomplete<'b>

Performs the power operation.

impl Pow<i32> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: i32) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<i64> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: i64) -> Float

Performs the power operation.

impl<'b> Pow<i64> for &'b Float

type Output = PowI64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: i64) -> PowI64Incomplete<'b>

Performs the power operation.

impl Pow<i8> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: i8) -> Float

Performs the power operation.

impl<'b> Pow<i8> for &'b Float

type Output = PowI8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: i8) -> PowI8Incomplete<'b>

Performs the power operation.

impl Pow<u128> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: u128) -> Float

Performs the power operation.

impl<'b> Pow<u128> for &'b Float

type Output = PowU128Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: u128) -> PowU128Incomplete<'b>

Performs the power operation.

impl Pow<u16> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: u16) -> Float

Performs the power operation.

impl<'b> Pow<u16> for &'b Float

type Output = PowU16Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: u16) -> PowU16Incomplete<'b>

Performs the power operation.

impl Pow<u32> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: u32) -> Float

Performs the power operation.

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>

Performs the power operation.

impl Pow<u64> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: u64) -> Float

Performs the power operation.

impl<'b> Pow<u64> for &'b Float

type Output = PowU64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: u64) -> PowU64Incomplete<'b>

Performs the power operation.

impl Pow<u8> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: u8) -> Float

Performs the power operation.

impl<'b> Pow<u8> for &'b Float

type Output = PowU8Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: u8) -> PowU8Incomplete<'b>

Performs the power operation.

impl PowAssign<&'_ Float> for Float

fn pow_assign(&mut self, rhs: &Float)

Peforms the power operation.

impl PowAssign<&'_ Integer> for Float

fn pow_assign(&mut self, rhs: &Integer)

Peforms the power operation.

impl PowAssign<&'_ f32> for Float

fn pow_assign(&mut self, rhs: &f32)

Peforms the power operation.

impl PowAssign<&'_ f64> for Float

fn pow_assign(&mut self, rhs: &f64)

Peforms the power operation.

impl PowAssign<&'_ i128> for Float

fn pow_assign(&mut self, rhs: &i128)

Peforms the power operation.

impl PowAssign<&'_ i16> for Float

fn pow_assign(&mut self, rhs: &i16)

Peforms the power operation.

impl PowAssign<&'_ i32> for Float

fn pow_assign(&mut self, rhs: &i32)

Peforms the power operation.

impl PowAssign<&'_ i64> for Float

fn pow_assign(&mut self, rhs: &i64)

Peforms the power operation.

impl PowAssign<&'_ i8> for Float

fn pow_assign(&mut self, rhs: &i8)

Peforms the power operation.

impl PowAssign<&'_ u128> for Float

fn pow_assign(&mut self, rhs: &u128)

Peforms the power operation.

impl PowAssign<&'_ u16> for Float

fn pow_assign(&mut self, rhs: &u16)

Peforms the power operation.

impl PowAssign<&'_ u32> for Float

fn pow_assign(&mut self, rhs: &u32)

Peforms the power operation.

impl PowAssign<&'_ u64> for Float

fn pow_assign(&mut self, rhs: &u64)

Peforms the power operation.

impl PowAssign<&'_ u8> for Float

fn pow_assign(&mut self, rhs: &u8)

Peforms the power operation.

impl PowAssign<Float> for Float

fn pow_assign(&mut self, rhs: Float)

Peforms the power operation.

impl PowAssign<Integer> for Float

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

impl PowAssign<f32> for Float

fn pow_assign(&mut self, rhs: f32)

Peforms the power operation.

impl PowAssign<f64> for Float

fn pow_assign(&mut self, rhs: f64)

Peforms the power operation.

impl PowAssign<i128> for Float

fn pow_assign(&mut self, rhs: i128)

Peforms the power operation.

impl PowAssign<i16> for Float

fn pow_assign(&mut self, rhs: i16)

Peforms the power operation.

impl PowAssign<i32> for Float

fn pow_assign(&mut self, rhs: i32)

Peforms the power operation.

impl PowAssign<i64> for Float

fn pow_assign(&mut self, rhs: i64)

Peforms the power operation.

impl PowAssign<i8> for Float

fn pow_assign(&mut self, rhs: i8)

Peforms the power operation.

impl PowAssign<u128> for Float

fn pow_assign(&mut self, rhs: u128)

Peforms the power operation.

impl PowAssign<u16> for Float

fn pow_assign(&mut self, rhs: u16)

Peforms the power operation.

impl PowAssign<u32> for Float

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl PowAssign<u64> for Float

fn pow_assign(&mut self, rhs: u64)

Peforms the power operation.

impl PowAssign<u8> for Float

fn pow_assign(&mut self, rhs: u8)

Peforms the power operation.

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

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

impl PowAssignRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &i128, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &i16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowAssignRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &i64, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &i8, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &u128, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &u16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowAssignRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &u64, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &u8, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

impl PowAssignRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: i128, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: i16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowAssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: i64, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: i8, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: u128, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: u16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowAssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: u64, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: u8, round: Round) -> Ordering

Performs the power operation.

impl PowFrom<&'_ Float> for Float

fn pow_from(&mut self, lhs: &Float)

Peforms the power operation.

impl PowFrom<&'_ f32> for Float

fn pow_from(&mut self, lhs: &f32)

Peforms the power operation.

impl PowFrom<&'_ f64> for Float

fn pow_from(&mut self, lhs: &f64)

Peforms the power operation.

impl PowFrom<&'_ i128> for Float

fn pow_from(&mut self, lhs: &i128)

Peforms the power operation.

impl PowFrom<&'_ i16> for Float

fn pow_from(&mut self, lhs: &i16)

Peforms the power operation.

impl PowFrom<&'_ i32> for Float

fn pow_from(&mut self, lhs: &i32)

Peforms the power operation.

impl PowFrom<&'_ i64> for Float

fn pow_from(&mut self, lhs: &i64)

Peforms the power operation.

impl PowFrom<&'_ i8> for Float

fn pow_from(&mut self, lhs: &i8)

Peforms the power operation.

impl PowFrom<&'_ u128> for Float

fn pow_from(&mut self, lhs: &u128)

Peforms the power operation.

impl PowFrom<&'_ u16> for Float

fn pow_from(&mut self, lhs: &u16)

Peforms the power operation.

impl PowFrom<&'_ u32> for Float

fn pow_from(&mut self, lhs: &u32)

Peforms the power operation.

impl PowFrom<&'_ u64> for Float

fn pow_from(&mut self, lhs: &u64)

Peforms the power operation.

impl PowFrom<&'_ u8> for Float

fn pow_from(&mut self, lhs: &u8)

Peforms the power operation.

impl PowFrom<Float> for Float

fn pow_from(&mut self, lhs: Float)

Peforms the power operation.

impl PowFrom<f32> for Float

fn pow_from(&mut self, lhs: f32)

Peforms the power operation.

impl PowFrom<f64> for Float

fn pow_from(&mut self, lhs: f64)

Peforms the power operation.

impl PowFrom<i128> for Float

fn pow_from(&mut self, lhs: i128)

Peforms the power operation.

impl PowFrom<i16> for Float

fn pow_from(&mut self, lhs: i16)

Peforms the power operation.

impl PowFrom<i32> for Float

fn pow_from(&mut self, lhs: i32)

Peforms the power operation.

impl PowFrom<i64> for Float

fn pow_from(&mut self, lhs: i64)

Peforms the power operation.

impl PowFrom<i8> for Float

fn pow_from(&mut self, lhs: i8)

Peforms the power operation.

impl PowFrom<u128> for Float

fn pow_from(&mut self, lhs: u128)

Peforms the power operation.

impl PowFrom<u16> for Float

fn pow_from(&mut self, lhs: u16)

Peforms the power operation.

impl PowFrom<u32> for Float

fn pow_from(&mut self, lhs: u32)

Peforms the power operation.

impl PowFrom<u64> for Float

fn pow_from(&mut self, lhs: u64)

Peforms the power operation.

impl PowFrom<u8> for Float

fn pow_from(&mut self, lhs: u8)

Peforms the power operation.

impl 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

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

impl PowFromRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &i128, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &i16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowFromRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &i64, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &i8, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &u128, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &u16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowFromRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &u64, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &u8, round: Round) -> Ordering

Performs the power operation.

impl 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

Performs the power operation.

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

Performs the power operation.

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

Performs the power operation.

impl PowFromRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: i128, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: i16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowFromRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: i64, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: i8, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: u128, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: u16, round: Round) -> Ordering

Performs the power operation.

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

Performs the power operation.

impl PowFromRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: u64, round: Round) -> Ordering

Performs the power operation.

impl PowFromRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: u8, round: Round) -> Ordering

Performs the power operation.

impl Rem<&'_ Float> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &Float) -> Float

Performs the % operation.

impl Rem<&'_ f32> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> Float

Performs the % operation.

impl<'b> Rem<&'_ f32> for &'b Float

type Output = RemF32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> RemF32Incomplete<'b>

Performs the % operation.

impl Rem<&'_ f64> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> Float

Performs the % operation.

impl<'b> Rem<&'_ f64> for &'b Float

type Output = RemF64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> RemF64Incomplete<'b>

Performs the % operation.

impl Rem<&'_ i128> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> Float

Performs the % operation.

impl<'b> Rem<&'_ i128> for &'b Float

type Output = RemI128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> RemI128Incomplete<'b>

Performs the % operation.

impl Rem<&'_ i16> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Float

Performs the % operation.

impl<'b> Rem<&'_ i16> for &'b Float

type Output = RemI16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> RemI16Incomplete<'b>

Performs the % operation.

impl Rem<&'_ i32> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Float

Performs the % operation.

impl<'b> Rem<&'_ i32> for &'b Float

type Output = RemI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> RemI32Incomplete<'b>

Performs the % operation.

impl Rem<&'_ i64> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Float

Performs the % operation.

impl<'b> Rem<&'_ i64> for &'b Float

type Output = RemI64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> RemI64Incomplete<'b>

Performs the % operation.

impl Rem<&'_ i8> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Float

Performs the % operation.

impl<'b> Rem<&'_ i8> for &'b Float

type Output = RemI8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> RemI8Incomplete<'b>

Performs the % operation.

impl Rem<&'_ u128> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> Float

Performs the % operation.

impl<'b> Rem<&'_ u128> for &'b Float

type Output = RemU128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> RemU128Incomplete<'b>

Performs the % operation.

impl Rem<&'_ u16> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Float

Performs the % operation.

impl<'b> Rem<&'_ u16> for &'b Float

type Output = RemU16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> RemU16Incomplete<'b>

Performs the % operation.

impl Rem<&'_ u32> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Float

Performs the % operation.

impl<'b> Rem<&'_ u32> for &'b Float

type Output = RemU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> RemU32Incomplete<'b>

Performs the % operation.

impl Rem<&'_ u64> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Float

Performs the % operation.

impl<'b> Rem<&'_ u64> for &'b Float

type Output = RemU64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> RemU64Incomplete<'b>

Performs the % operation.

impl Rem<&'_ u8> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Float

Performs the % operation.

impl<'b> Rem<&'_ u8> for &'b Float

type Output = RemU8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> RemU8Incomplete<'b>

Performs the % operation.

impl<'a> Rem<&'a Float> for &'a Float

type Output = RemIncomplete<'a>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Float) -> RemIncomplete<'_>

Performs the % operation.

impl Rem<Float> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: Float) -> Float

Performs the % operation.

impl Rem<Float> for &Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: Float) -> Float

Performs the % operation.

impl Rem<f32> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Float

Performs the % operation.

impl<'b> Rem<f32> for &'b Float

type Output = RemF32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> RemF32Incomplete<'b>

Performs the % operation.

impl Rem<f64> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Float

Performs the % operation.

impl<'b> Rem<f64> for &'b Float

type Output = RemF64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> RemF64Incomplete<'b>

Performs the % operation.

impl Rem<i128> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> Float

Performs the % operation.

impl<'b> Rem<i128> for &'b Float

type Output = RemI128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> RemI128Incomplete<'b>

Performs the % operation.

impl Rem<i16> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Float

Performs the % operation.

impl<'b> Rem<i16> for &'b Float

type Output = RemI16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> RemI16Incomplete<'b>

Performs the % operation.

impl Rem<i32> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Float

Performs the % operation.

impl<'b> Rem<i32> for &'b Float

type Output = RemI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> RemI32Incomplete<'b>

Performs the % operation.

impl Rem<i64> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Float

Performs the % operation.

impl<'b> Rem<i64> for &'b Float

type Output = RemI64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> RemI64Incomplete<'b>

Performs the % operation.

impl Rem<i8> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Float

Performs the % operation.

impl<'b> Rem<i8> for &'b Float

type Output = RemI8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> RemI8Incomplete<'b>

Performs the % operation.

impl Rem<u128> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> Float

Performs the % operation.

impl<'b> Rem<u128> for &'b Float

type Output = RemU128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> RemU128Incomplete<'b>

Performs the % operation.

impl Rem<u16> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Float

Performs the % operation.

impl<'b> Rem<u16> for &'b Float

type Output = RemU16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> RemU16Incomplete<'b>

Performs the % operation.

impl Rem<u32> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Float

Performs the % operation.

impl<'b> Rem<u32> for &'b Float

type Output = RemU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> RemU32Incomplete<'b>

Performs the % operation.

impl Rem<u64> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Float

Performs the % operation.

impl<'b> Rem<u64> for &'b Float

type Output = RemU64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> RemU64Incomplete<'b>

Performs the % operation.

impl Rem<u8> for Float

type Output = Float

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Float

Performs the % operation.

impl<'b> Rem<u8> for &'b Float

type Output = RemU8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> RemU8Incomplete<'b>

Performs the % operation.

impl RemAssign<&'_ Float> for Float

fn rem_assign(&mut self, rhs: &Float)

Performs the %= operation.

impl RemAssign<&'_ f32> for Float

fn rem_assign(&mut self, rhs: &f32)

Performs the %= operation.

impl RemAssign<&'_ f64> for Float

fn rem_assign(&mut self, rhs: &f64)

Performs the %= operation.

impl RemAssign<&'_ i128> for Float

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl RemAssign<&'_ i16> for Float

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl RemAssign<&'_ i32> for Float

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl RemAssign<&'_ i64> for Float

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl RemAssign<&'_ i8> for Float

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl RemAssign<&'_ u128> for Float

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl RemAssign<&'_ u16> for Float

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl RemAssign<&'_ u32> for Float

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl RemAssign<&'_ u64> for Float

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl RemAssign<&'_ u8> for Float

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl RemAssign<Float> for Float

fn rem_assign(&mut self, rhs: Float)

Performs the %= operation.

impl RemAssign<f32> for Float

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl RemAssign<f64> for Float

fn rem_assign(&mut self, rhs: f64)

Performs the %= operation.

impl RemAssign<i128> for Float

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl RemAssign<i16> for Float

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl RemAssign<i32> for Float

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl RemAssign<i64> for Float

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl RemAssign<i8> for Float

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl RemAssign<u128> for Float

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl RemAssign<u16> for Float

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl RemAssign<u32> for Float

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl RemAssign<u64> for Float

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl RemAssign<u8> for Float

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl RemAssignRound<&'_ Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &Float, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &f32, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &f64, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &i128, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &i16, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &i32, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &i64, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &i8, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &u128, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &u16, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &u32, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &u64, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: &u8, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: Float, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: f32, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: f64, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: i128, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: i16, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: i32, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: i64, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: i8, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: u128, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: u16, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: u32, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: u64, round: Round) -> Ordering

Performs the remainder operation.

impl RemAssignRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_assign_round(&mut self, rhs: u8, round: Round) -> Ordering

Performs the remainder operation.

impl RemFrom<&'_ Float> for Float

fn rem_from(&mut self, lhs: &Float)

Peforms the remainder operation.

impl RemFrom<&'_ f32> for Float

fn rem_from(&mut self, lhs: &f32)

Peforms the remainder operation.

impl RemFrom<&'_ f64> for Float

fn rem_from(&mut self, lhs: &f64)

Peforms the remainder operation.

impl RemFrom<&'_ i128> for Float

fn rem_from(&mut self, lhs: &i128)

Peforms the remainder operation.

impl RemFrom<&'_ i16> for Float

fn rem_from(&mut self, lhs: &i16)

Peforms the remainder operation.

impl RemFrom<&'_ i32> for Float

fn rem_from(&mut self, lhs: &i32)

Peforms the remainder operation.

impl RemFrom<&'_ i64> for Float

fn rem_from(&mut self, lhs: &i64)

Peforms the remainder operation.

impl RemFrom<&'_ i8> for Float

fn rem_from(&mut self, lhs: &i8)

Peforms the remainder operation.

impl RemFrom<&'_ u128> for Float

fn rem_from(&mut self, lhs: &u128)

Peforms the remainder operation.

impl RemFrom<&'_ u16> for Float

fn rem_from(&mut self, lhs: &u16)

Peforms the remainder operation.

impl RemFrom<&'_ u32> for Float

fn rem_from(&mut self, lhs: &u32)

Peforms the remainder operation.

impl RemFrom<&'_ u64> for Float

fn rem_from(&mut self, lhs: &u64)

Peforms the remainder operation.

impl RemFrom<&'_ u8> for Float

fn rem_from(&mut self, lhs: &u8)

Peforms the remainder operation.

impl RemFrom<Float> for Float

fn rem_from(&mut self, lhs: Float)

Peforms the remainder operation.

impl RemFrom<f32> for Float

fn rem_from(&mut self, lhs: f32)

Peforms the remainder operation.

impl RemFrom<f64> for Float

fn rem_from(&mut self, lhs: f64)

Peforms the remainder operation.

impl RemFrom<i128> for Float

fn rem_from(&mut self, lhs: i128)

Peforms the remainder operation.

impl RemFrom<i16> for Float

fn rem_from(&mut self, lhs: i16)

Peforms the remainder operation.

impl RemFrom<i32> for Float

fn rem_from(&mut self, lhs: i32)

Peforms the remainder operation.

impl RemFrom<i64> for Float

fn rem_from(&mut self, lhs: i64)

Peforms the remainder operation.

impl RemFrom<i8> for Float

fn rem_from(&mut self, lhs: i8)

Peforms the remainder operation.

impl RemFrom<u128> for Float

fn rem_from(&mut self, lhs: u128)

Peforms the remainder operation.

impl RemFrom<u16> for Float

fn rem_from(&mut self, lhs: u16)

Peforms the remainder operation.

impl RemFrom<u32> for Float

fn rem_from(&mut self, lhs: u32)

Peforms the remainder operation.

impl RemFrom<u64> for Float

fn rem_from(&mut self, lhs: u64)

Peforms the remainder operation.

impl RemFrom<u8> for Float

fn rem_from(&mut self, lhs: u8)

Peforms the remainder operation.

impl RemFromRound<&'_ Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &Float, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &f32, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &f64, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &i128, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &i16, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &i32, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &i64, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &i8, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &u128, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &u16, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &u32, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &u64, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: &u8, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: Float, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: f32, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: f64, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: i128, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: i16, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: i32, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: i64, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: i8, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: u128, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: u16, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: u32, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: u64, round: Round) -> Ordering

Performs the remainder operation.

impl RemFromRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn rem_from_round(&mut self, lhs: u8, round: Round) -> Ordering

Performs the remainder operation.

impl SaturatingCast<i128> for Float

fn saturating_cast(self) -> i128

Casts the value.

impl SaturatingCast<i128> for &Float

fn saturating_cast(self) -> i128

Casts the value.

impl SaturatingCast<i16> for Float

fn saturating_cast(self) -> i16

Casts the value.

impl SaturatingCast<i16> for &Float

fn saturating_cast(self) -> i16

Casts the value.

impl SaturatingCast<i32> for Float

fn saturating_cast(self) -> i32

Casts the value.

impl SaturatingCast<i32> for &Float

fn saturating_cast(self) -> i32

Casts the value.

impl SaturatingCast<i64> for Float

fn saturating_cast(self) -> i64

Casts the value.

impl SaturatingCast<i64> for &Float

fn saturating_cast(self) -> i64

Casts the value.

impl SaturatingCast<i8> for Float

fn saturating_cast(self) -> i8

Casts the value.

impl SaturatingCast<i8> for &Float

fn saturating_cast(self) -> i8

Casts the value.

impl SaturatingCast<isize> for Float

fn saturating_cast(self) -> isize

Casts the value.

impl SaturatingCast<isize> for &Float

fn saturating_cast(self) -> isize

Casts the value.

impl SaturatingCast<u128> for Float

fn saturating_cast(self) -> u128

Casts the value.

impl SaturatingCast<u128> for &Float

fn saturating_cast(self) -> u128

Casts the value.

impl SaturatingCast<u16> for Float

fn saturating_cast(self) -> u16

Casts the value.

impl SaturatingCast<u16> for &Float

fn saturating_cast(self) -> u16

Casts the value.

impl SaturatingCast<u32> for Float

fn saturating_cast(self) -> u32

Casts the value.

impl SaturatingCast<u32> for &Float

fn saturating_cast(self) -> u32

Casts the value.

impl SaturatingCast<u64> for Float

fn saturating_cast(self) -> u64

Casts the value.

impl SaturatingCast<u64> for &Float

fn saturating_cast(self) -> u64

Casts the value.

impl SaturatingCast<u8> for Float

fn saturating_cast(self) -> u8

Casts the value.

impl SaturatingCast<u8> for &Float

fn saturating_cast(self) -> u8

Casts the value.

impl SaturatingCast<usize> for Float

fn saturating_cast(self) -> usize

Casts the value.

impl SaturatingCast<usize> for &Float

fn saturating_cast(self) -> usize

Casts the value.

impl Send for Float

impl Shl<&'_ i32> for Float

type Output = Float

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Float

Performs the << operation.

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>

Performs the << operation.

impl Shl<&'_ u32> for Float

type Output = Float

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Float

Performs the << operation.

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>

Performs the << operation.

impl Shl<i32> for Float

type Output = Float

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Float

Performs the << operation.

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>

Performs the << operation.

impl Shl<u32> for Float

type Output = Float

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Float

Performs the << operation.

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>

Performs the << operation.

impl ShlAssign<&'_ i32> for Float

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl ShlAssign<&'_ u32> for Float

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl ShlAssign<i32> for Float

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<u32> for Float

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl Shr<&'_ i32> for Float

type Output = Float

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Float

Performs the >> operation.

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>

Performs the >> operation.

impl Shr<&'_ u32> for Float

type Output = Float

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Float

Performs the >> operation.

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>

Performs the >> operation.

impl Shr<i32> for Float

type Output = Float

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Float

Performs the >> operation.

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>

Performs the >> operation.

impl Shr<u32> for Float

type Output = Float

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Float

Performs the >> operation.

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>

Performs the >> operation.

impl ShrAssign<&'_ i32> for Float

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl ShrAssign<&'_ u32> for Float

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl ShrAssign<i32> for Float

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<u32> for Float

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl Sub<&'_ Float> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &Float) -> Float

Performs the - operation.

impl Sub<&'_ Integer> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> Float

Performs the - operation.

impl Sub<&'_ f32> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<&'_ f64> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<&'_ i128> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Float

Performs the - operation.

impl<'b> Sub<&'_ i128> for &'b Float

type Output = SubI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> SubI128Incomplete<'b>

Performs the - operation.

impl Sub<&'_ i16> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Float

Performs the - operation.

impl<'b> Sub<&'_ i16> for &'b Float

type Output = SubI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> SubI16Incomplete<'b>

Performs the - operation.

impl Sub<&'_ i32> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<&'_ i64> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Float

Performs the - operation.

impl<'b> Sub<&'_ i64> for &'b Float

type Output = SubI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> SubI64Incomplete<'b>

Performs the - operation.

impl Sub<&'_ i8> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Float

Performs the - operation.

impl<'b> Sub<&'_ i8> for &'b Float

type Output = SubI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> SubI8Incomplete<'b>

Performs the - operation.

impl Sub<&'_ u128> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Float

Performs the - operation.

impl<'b> Sub<&'_ u128> for &'b Float

type Output = SubU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> SubU128Incomplete<'b>

Performs the - operation.

impl Sub<&'_ u16> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Float

Performs the - operation.

impl<'b> Sub<&'_ u16> for &'b Float

type Output = SubU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> SubU16Incomplete<'b>

Performs the - operation.

impl Sub<&'_ u32> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<&'_ u64> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Float

Performs the - operation.

impl<'b> Sub<&'_ u64> for &'b Float

type Output = SubU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> SubU64Incomplete<'b>

Performs the - operation.

impl Sub<&'_ u8> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Float

Performs the - operation.

impl<'b> Sub<&'_ u8> for &'b Float

type Output = SubU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> SubU8Incomplete<'b>

Performs the - operation.

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<'_>

Performs the - operation.

impl<'a> Sub<&'a Float> for Integer

type Output = SubFromOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Float) -> SubFromOwnedIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Float> for &'a Integer

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubFromIntegerIncomplete<'_>

Performs the - operation.

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<'_>

Performs the - operation.

impl Sub<Float> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

impl Sub<Float> for &Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

impl Sub<Float> for Integer

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

impl Sub<Float> for &Integer

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

impl Sub<Integer> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Float

Performs the - operation.

impl<'a> Sub<Integer> for &'a Float

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubOwnedIntegerIncomplete<'a>

Performs the - operation.

impl Sub<f32> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<f64> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<i128> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Float

Performs the - operation.

impl<'b> Sub<i128> for &'b Float

type Output = SubI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> SubI128Incomplete<'b>

Performs the - operation.

impl Sub<i16> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Float

Performs the - operation.

impl<'b> Sub<i16> for &'b Float

type Output = SubI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> SubI16Incomplete<'b>

Performs the - operation.

impl Sub<i32> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<i64> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Float

Performs the - operation.

impl<'b> Sub<i64> for &'b Float

type Output = SubI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> SubI64Incomplete<'b>

Performs the - operation.

impl Sub<i8> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Float

Performs the - operation.

impl<'b> Sub<i8> for &'b Float

type Output = SubI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> SubI8Incomplete<'b>

Performs the - operation.

impl Sub<u128> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Float

Performs the - operation.

impl<'b> Sub<u128> for &'b Float

type Output = SubU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> SubU128Incomplete<'b>

Performs the - operation.

impl Sub<u16> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Float

Performs the - operation.

impl<'b> Sub<u16> for &'b Float

type Output = SubU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> SubU16Incomplete<'b>

Performs the - operation.

impl Sub<u32> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Float

Performs the - operation.

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>

Performs the - operation.

impl Sub<u64> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Float

Performs the - operation.

impl<'b> Sub<u64> for &'b Float

type Output = SubU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> SubU64Incomplete<'b>

Performs the - operation.

impl Sub<u8> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Float

Performs the - operation.

impl<'b> Sub<u8> for &'b Float

type Output = SubU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> SubU8Incomplete<'b>

Performs the - operation.

impl SubAssign<&'_ Float> for Float

fn sub_assign(&mut self, rhs: &Float)

Performs the -= operation.

impl SubAssign<&'_ Integer> for Float

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&'_ f32> for Float

fn sub_assign(&mut self, rhs: &f32)

Performs the -= operation.

impl SubAssign<&'_ f64> for Float

fn sub_assign(&mut self, rhs: &f64)

Performs the -= operation.

impl SubAssign<&'_ i128> for Float

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl SubAssign<&'_ i16> for Float

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl SubAssign<&'_ i32> for Float

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl SubAssign<&'_ i64> for Float

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl SubAssign<&'_ i8> for Float

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl SubAssign<&'_ u128> for Float

fn sub_assign(&mut self, rhs: &u128)

Performs the -= operation.

impl SubAssign<&'_ u16> for Float

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl SubAssign<&'_ u32> for Float

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl SubAssign<&'_ u64> for Float

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl SubAssign<&'_ u8> for Float

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl SubAssign<Float> for Float

fn sub_assign(&mut self, rhs: Float)

Performs the -= operation.

impl SubAssign<Integer> for Float

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssign<f32> for Float

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl SubAssign<f64> for Float

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl SubAssign<i128> for Float

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl SubAssign<i16> for Float

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for Float

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for Float

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for Float

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<u128> for Float

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for Float

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for Float

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for Float

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for Float

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

impl SubAssignRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &i128, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &i16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubAssignRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &i64, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &i8, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &u128, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &u16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubAssignRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &u64, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &u8, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

impl SubAssignRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: i128, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: i16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubAssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: i64, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: i8, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: u128, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: u16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubAssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: u64, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: u8, round: Round) -> Ordering

Performs the subtraction.

impl SubFrom<&'_ Float> for Float

fn sub_from(&mut self, lhs: &Float)

Peforms the subtraction.

impl SubFrom<&'_ Integer> for Float

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

impl SubFrom<&'_ f32> for Float

fn sub_from(&mut self, lhs: &f32)

Peforms the subtraction.

impl SubFrom<&'_ f64> for Float

fn sub_from(&mut self, lhs: &f64)

Peforms the subtraction.

impl SubFrom<&'_ i128> for Float

fn sub_from(&mut self, lhs: &i128)

Peforms the subtraction.

impl SubFrom<&'_ i16> for Float

fn sub_from(&mut self, lhs: &i16)

Peforms the subtraction.

impl SubFrom<&'_ i32> for Float

fn sub_from(&mut self, lhs: &i32)

Peforms the subtraction.

impl SubFrom<&'_ i64> for Float

fn sub_from(&mut self, lhs: &i64)

Peforms the subtraction.

impl SubFrom<&'_ i8> for Float

fn sub_from(&mut self, lhs: &i8)

Peforms the subtraction.

impl SubFrom<&'_ u128> for Float

fn sub_from(&mut self, lhs: &u128)

Peforms the subtraction.

impl SubFrom<&'_ u16> for Float

fn sub_from(&mut self, lhs: &u16)

Peforms the subtraction.

impl SubFrom<&'_ u32> for Float

fn sub_from(&mut self, lhs: &u32)

Peforms the subtraction.

impl SubFrom<&'_ u64> for Float

fn sub_from(&mut self, lhs: &u64)

Peforms the subtraction.

impl SubFrom<&'_ u8> for Float

fn sub_from(&mut self, lhs: &u8)

Peforms the subtraction.

impl SubFrom<Float> for Float

fn sub_from(&mut self, lhs: Float)

Peforms the subtraction.

impl SubFrom<Integer> for Float

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl SubFrom<f32> for Float

fn sub_from(&mut self, lhs: f32)

Peforms the subtraction.

impl SubFrom<f64> for Float

fn sub_from(&mut self, lhs: f64)

Peforms the subtraction.

impl SubFrom<i128> for Float

fn sub_from(&mut self, lhs: i128)

Peforms the subtraction.

impl SubFrom<i16> for Float

fn sub_from(&mut self, lhs: i16)

Peforms the subtraction.

impl SubFrom<i32> for Float

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

impl SubFrom<i64> for Float

fn sub_from(&mut self, lhs: i64)

Peforms the subtraction.

impl SubFrom<i8> for Float

fn sub_from(&mut self, lhs: i8)

Peforms the subtraction.

impl SubFrom<u128> for Float

fn sub_from(&mut self, lhs: u128)

Peforms the subtraction.

impl SubFrom<u16> for Float

fn sub_from(&mut self, lhs: u16)

Peforms the subtraction.

impl SubFrom<u32> for Float

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

impl SubFrom<u64> for Float

fn sub_from(&mut self, lhs: u64)

Peforms the subtraction.

impl SubFrom<u8> for Float

fn sub_from(&mut self, lhs: u8)

Peforms the subtraction.

impl 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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

impl SubFromRound<&'_ i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &i128, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<&'_ i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &i16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubFromRound<&'_ i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &i64, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<&'_ i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &i8, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<&'_ u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &u128, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<&'_ u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &u16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubFromRound<&'_ u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &u64, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<&'_ u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &u8, round: Round) -> Ordering

Performs the subtraction.

impl 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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

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

Performs the subtraction.

impl SubFromRound<i128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: i128, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<i16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: i16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubFromRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: i64, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<i8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: i8, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<u128> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: u128, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<u16> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: u16, round: Round) -> Ordering

Performs the subtraction.

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

Performs the subtraction.

impl SubFromRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: u64, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<u8> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: u8, round: Round) -> Ordering

Performs the subtraction.

impl Sync for Float

impl UpperExp for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl UpperHex for Float

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.