pub struct Float { /* private fields */ }
Expand description
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;
use rug::ops::DivAssignRound;
use rug::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:
- The first method consumes the operand and rounds the returned
Float
to the nearest representable value. - The second method has a “
_mut
” suffix, mutates the operand and rounds it the nearest representable value. - The third method has a “
_round
” suffix, mutates the operand, applies the specified rounding method, and returns the rounding direction: - The fourth method has a “
_ref
” suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to aFloat
; the rounding method is selected during the assignment.
use core::cmp::Ordering;
use rug::float::Round;
use rug::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;
use rug::float::{FreeCache, Round};
use rug::ops::{AddAssignRound, AssignRound, MulAssignRound};
use rug::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§
source§impl Float
impl Float
sourcepub fn with_val_round<T>(prec: u32, val: T, round: Round) -> (Self, Ordering)
pub fn with_val_round<T>(prec: u32, val: T, round: Round) -> (Self, 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;
use rug::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);
sourcepub fn set_prec_round(&mut self, prec: u32, round: Round) -> Ordering
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;
use rug::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);
sourcepub const unsafe fn from_raw(raw: mpfr_t) -> Self
pub const unsafe fn from_raw(raw: mpfr_t) -> Self
Creates a Float
from an initialized MPFR floating-point
number.
§Safety
- The function must not be used to create a constant
Float
, though it can be used to create a staticFloat
. This is because constant values are copied on use, leading to undefined behavior when they are dropped. - The value must be initialized as a valid
mpfr_t
. - 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;
use gmp_mpfr_sys::mpfr::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
This can be used to create a static Float
. See mpfr_t
and the
MPFR documentation for details.
use core::ptr::NonNull;
use gmp_mpfr_sys::gmp::limb_t;
use gmp_mpfr_sys::mpfr::{mpfr_t, prec_t};
use rug::Float;
const LIMBS: [limb_t; 2] = [5, 1 << (limb_t::BITS - 1)];
const LIMBS_PTR: *const [limb_t; 2] = &LIMBS;
const MANTISSA_DIGITS: u32 = limb_t::BITS * 2;
const MPFR: mpfr_t = mpfr_t {
prec: MANTISSA_DIGITS as prec_t,
sign: -1,
exp: 1,
d: unsafe { NonNull::new_unchecked(LIMBS_PTR.cast_mut().cast()) },
};
// Must *not* be const, otherwise it would lead to undefined
// behavior on use, as it would create a copy that is dropped.
static F: Float = unsafe { Float::from_raw(MPFR) };
let lsig = Float::with_val(MANTISSA_DIGITS, 5) >> (MANTISSA_DIGITS - 1);
let msig = 1u32;
let check = -(lsig + msig);
assert_eq!(F, check);
sourcepub const fn into_raw(self) -> mpfr_t
pub const 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;
use gmp_mpfr_sys::mpfr::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);
}
sourcepub const fn as_raw(&self) -> *const mpfr_t
pub const 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;
use gmp_mpfr_sys::mpfr::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);
sourcepub fn as_raw_mut(&mut self) -> *mut mpfr_t
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;
use gmp_mpfr_sys::mpfr::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);
sourcepub fn parse<S: AsRef<[u8]>>(src: S) -> Result<ParseIncomplete, ParseFloatError>
pub fn parse<S: AsRef<[u8]>>(src: S) -> Result<ParseIncomplete, ParseFloatError>
Parses a decimal string slice (&str
) or byte slice
(&[u8]
) into a Float
.
The following are implemented with the unwrapped returned
incomplete-computation value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for 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());
sourcepub fn parse_radix<S: AsRef<[u8]>>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseFloatError>
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
.
The following are implemented with the unwrapped returned
incomplete-computation value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for 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());
sourcepub fn to_integer(&self) -> Option<Integer>
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>()
float.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);
sourcepub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>
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;
use rug::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);
sourcepub fn to_integer_exp(&self) -> Option<(Integer, i32)>
pub fn to_integer_exp(&self) -> Option<(Integer, i32)>
If the value is a finite number, returns an
Integer
and exponent such that it is exactly equal to the integer
multiplied by two raised to the power of the exponent.
§Examples
use rug::float::Special;
use rug::{Assign, Float};
let mut float = Float::with_val(16, 6.5);
// 6.5 in binary is 110.1
// Since the precision is 16 bits, this becomes
// 1101_0000_0000_0000 times two to the power of -12
let (int, exp) = float.to_integer_exp().unwrap();
assert_eq!(int, 0b1101_0000_0000_0000);
assert_eq!(exp, -13);
float.assign(0);
let (zero, _) = float.to_integer_exp().unwrap();
assert_eq!(zero, 0);
float.assign(Special::Infinity);
assert!(float.to_integer_exp().is_none());
sourcepub fn to_rational(&self) -> Option<Rational>
pub fn to_rational(&self) -> Option<Rational>
If the value is a finite number, returns a
Rational
number preserving all the precision of the value.
This conversion can also be performed using
Rational::try_from(&float)
Rational::try_from(float)
(&float).checked_as::<Rational>()
float.borrow().checked_as::<Rational>()
float.checked_as::<Rational>()
§Examples
use core::cmp::Ordering;
use core::str::FromStr;
use rug::float::Round;
use rug::{Float, Rational};
// Consider the number 123,456,789 / 10,000,000,000.
let parse = Float::parse("0.0123456789").unwrap();
let (f, f_rounding) = Float::with_val_round(35, parse, Round::Down);
assert_eq!(f_rounding, Ordering::Less);
let r = Rational::from_str("123456789/10000000000").unwrap();
// Set fr to the value of f exactly.
let fr = f.to_rational().unwrap();
// Since f == fr and f was rounded down, r != fr.
assert_ne!(r, fr);
let (frf, frf_rounding) = Float::with_val_round(35, &fr, Round::Down);
assert_eq!(frf_rounding, Ordering::Equal);
assert_eq!(frf, f);
assert_eq!(format!("{:.9}", frf), "1.23456789e-2");
In the following example, the Float
values can be represented
exactly.
use rug::Float;
let large_f = Float::with_val(16, 6.5);
let large_r = large_f.to_rational().unwrap();
let small_f = Float::with_val(16, -0.125);
let small_r = small_f.to_rational().unwrap();
assert_eq!(*large_r.numer(), 13);
assert_eq!(*large_r.denom(), 2);
assert_eq!(*small_r.numer(), -1);
assert_eq!(*small_r.denom(), 8);
sourcepub fn to_i32_saturating(&self) -> Option<i32>
pub fn to_i32_saturating(&self) -> Option<i32>
Converts to an i32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
§Examples
use rug::{Assign, Float};
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));
sourcepub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>
pub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>
Converts to an i32
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
§Examples
use rug::float::Round;
use rug::Float;
let f = Float::with_val(53, -13.7);
assert_eq!(f.to_i32_saturating_round(Round::Up), Some(-13));
sourcepub fn to_u32_saturating(&self) -> Option<u32>
pub fn to_u32_saturating(&self) -> Option<u32>
Converts to a u32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
§Examples
use rug::{Assign, Float};
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));
sourcepub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>
pub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>
Converts to a u32
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
§Examples
use rug::float::Round;
use rug::Float;
let f = Float::with_val(53, 13.7);
assert_eq!(f.to_u32_saturating_round(Round::Down), Some(13));
sourcepub fn to_f32(&self) -> f32
pub fn to_f32(&self) -> f32
Converts to an f32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
§Examples
use rug::{Assign, Float};
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);
sourcepub fn to_f32_round(&self, round: Round) -> f32
pub fn to_f32_round(&self, round: Round) -> f32
Converts to an f32
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
§Examples
use rug::float::Round;
use rug::Float;
let f = Float::with_val(53, 1.0 + (-50f64).exp2());
assert_eq!(f.to_f32_round(Round::Up), 1.0 + f32::EPSILON);
sourcepub fn to_f64(&self) -> f64
pub fn to_f64(&self) -> f64
Converts to an f64
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
§Examples
use rug::{Assign, Float};
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);
sourcepub fn to_f64_round(&self, round: Round) -> f64
pub fn to_f64_round(&self, round: Round) -> f64
Converts to an f64
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
§Examples
use rug::float::Round;
use rug::Float;
// (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);
sourcepub fn to_f32_exp(&self) -> (f32, i32)
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));
sourcepub fn to_f32_exp_round(&self, round: Round) -> (f32, i32)
pub fn to_f32_exp_round(&self, round: Round) -> (f32, i32)
Converts to an f32
and an exponent, applying the specified rounding
method.
The returned f32
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
§Examples
use rug::float::Round;
use rug::Float;
let frac_10_3 = Float::with_val(64, 10) / 3u32;
let (f_down, exp_down) = frac_10_3.to_f32_exp_round(Round::Down);
assert_eq!((f_down, exp_down), (0.8333333, 2));
let (f_up, exp_up) = frac_10_3.to_f32_exp_round(Round::Up);
assert_eq!((f_up, exp_up), (0.8333334, 2));
sourcepub fn to_f64_exp(&self) -> (f64, i32)
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));
sourcepub fn to_f64_exp_round(&self, round: Round) -> (f64, i32)
pub fn to_f64_exp_round(&self, round: Round) -> (f64, i32)
Converts to an f64
and an exponent, applying the specified rounding
method.
The returned f64
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
§Examples
use rug::float::Round;
use rug::Float;
let frac_10_3 = Float::with_val(64, 10) / 3u32;
let (f_down, exp_down) = frac_10_3.to_f64_exp_round(Round::Down);
assert_eq!((f_down, exp_down), (0.8333333333333333, 2));
let (f_up, exp_up) = frac_10_3.to_f64_exp_round(Round::Up);
assert_eq!((f_up, exp_up), (0.8333333333333334, 2));
sourcepub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
pub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
Returns a string representation of self
for the specified radix
rounding to the nearest.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
§Panics
Panics if radix
is less than 2 or greater than 36.
§Examples
use rug::float::Special;
use rug::Float;
let neg_inf = Float::with_val(53, Special::NegInfinity);
assert_eq!(neg_inf.to_string_radix(10, None), "-inf");
assert_eq!(neg_inf.to_string_radix(16, None), "-@inf@");
let twentythree = Float::with_val(8, 23);
assert_eq!(twentythree.to_string_radix(10, None), "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");
sourcepub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: Round
) -> String
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;
use rug::Float;
let twentythree = Float::with_val(8, 23.3);
let down = twentythree.to_string_radix_round(10, Some(2), Round::Down);
assert_eq!(down, "23");
let up = twentythree.to_string_radix_round(10, Some(2), Round::Up);
assert_eq!(up, "24");
sourcepub fn to_sign_string_exp(
&self,
radix: i32,
num_digits: Option<usize>
) -> (bool, String, Option<i32>)
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;
use rug::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)));
sourcepub fn to_sign_string_exp_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: Round
) -> (bool, String, Option<i32>)
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;
use rug::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)));
sourcepub const fn as_neg(&self) -> BorrowFloat<'_>
pub const 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.
Unlike the other negation methods (the -
operator,
Neg::neg
, etc.), this method does not set the
MPFR NaN flag if a NaN is encountered.
§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);
sourcepub const fn as_abs(&self) -> BorrowFloat<'_>
pub const 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.
Unlike the other absolute value methods (abs
, abs_mut
, etc.),
this method does not set the MPFR NaN flag if a NaN is encountered.
§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);
sourcepub const fn as_ord(&self) -> &OrdFloat
pub const 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;
use rug::Float;
let nan_f = Float::with_val(53, Special::Nan);
let nan = nan_f.as_ord();
let neg_nan_f = nan_f.as_neg();
let neg_nan = neg_nan_f.as_ord();
assert_eq!(nan.cmp(nan), Ordering::Equal);
assert_eq!(neg_nan.cmp(nan), Ordering::Less);
let inf_f = Float::with_val(53, Special::Infinity);
let inf = inf_f.as_ord();
let neg_inf_f = Float::with_val(53, Special::NegInfinity);
let neg_inf = neg_inf_f.as_ord();
assert_eq!(nan.cmp(inf), Ordering::Greater);
assert_eq!(neg_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);
sourcepub const fn as_complex(&self) -> BorrowComplex<'_>
pub const fn as_complex(&self) -> BorrowComplex<'_>
Borrows a copy of the Float
as a Complex
number.
The returned object implements
Deref<Target = Complex>
.
The imaginary part of the return value has the same precision as the real part. While this has no effect for the zero value of the returned complex number, it could have an effect if the return value is cloned.
§Examples
use rug::Float;
let f = Float::with_val(53, 4.2);
let c = f.as_complex();
assert_eq!(*c, (4.2, 0.0));
// methods taking &self can be used on the returned object
let c_mul_i = c.as_mul_i(false);
assert_eq!(*c_mul_i, (0.0, 4.2));
sourcepub fn is_integer(&self) -> bool
pub fn is_integer(&self) -> bool
sourcepub const fn is_infinite(&self) -> bool
pub const fn is_infinite(&self) -> bool
sourcepub const fn is_normal(&self) -> bool
pub const fn is_normal(&self) -> bool
Returns true
if self
is a normal number, that is neither NaN, nor
infinity, nor zero. Note that Float
cannot be subnormal.
§Examples
use rug::float::Special;
use rug::{Assign, Float};
let mut f = Float::with_val(53, Special::Zero);
assert!(!f.is_normal());
f += 5.2;
assert!(f.is_normal());
f.assign(Special::Infinity);
assert!(!f.is_normal());
f.assign(Special::Nan);
assert!(!f.is_normal());
sourcepub const fn classify(&self) -> FpCategory
pub const 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;
use rug::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);
sourcepub const fn cmp0(&self) -> Option<Ordering>
pub const 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;
use rug::{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);
sourcepub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
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));
sourcepub fn total_cmp(&self, other: &Float) -> Ordering
pub fn total_cmp(&self, other: &Float) -> Ordering
Returns the total ordering between self
and other
.
Negative zero is ordered as less than positive zero. Negative NaN is ordered as less than negative infinity, while positive NaN is ordered as greater than positive infinity. Comparing two negative NaNs or two positive NaNs produces equality.
§Examples
use rug::float::Special;
use rug::Float;
let mut values = vec![
Float::with_val(53, Special::Zero),
Float::with_val(53, Special::NegZero),
Float::with_val(53, Special::Infinity),
Float::with_val(53, Special::NegInfinity),
Float::with_val(53, Special::Nan),
-Float::with_val(53, Special::Nan),
];
values.sort_by(Float::total_cmp);
// NaN with negative sign
assert!(values[0].is_nan() && values[0].is_sign_negative());
// -∞
assert!(values[1].is_infinite() && values[1].is_sign_negative());
// -0
assert!(values[2].is_zero() && values[2].is_sign_negative());
// +0
assert!(values[3].is_zero() && values[3].is_sign_positive());
// +∞
assert!(values[4].is_infinite() && values[4].is_sign_positive());
// NaN with positive sign
assert!(values[5].is_nan() && values[5].is_sign_positive());
sourcepub const fn get_exp(&self) -> Option<i32>
pub const 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);
sourcepub fn clamp_exp(
&mut self,
dir: Ordering,
round: Round,
exp_min: i32,
exp_max: i32
) -> Option<Ordering>
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;
use rug::ops::DivAssignRound;
use rug::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;
use rug::ops::DivAssignRound;
use rug::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);
sourcepub fn get_significand(&self) -> Option<BorrowInteger<'_>>
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);
sourcepub const fn is_sign_positive(&self) -> bool
pub const fn is_sign_positive(&self) -> bool
sourcepub const fn is_sign_negative(&self) -> bool
pub const fn is_sign_negative(&self) -> bool
sourcepub fn next_toward(&mut self, to: &Self)
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);
sourcepub fn next_up(&mut self)
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);
sourcepub fn next_down(&mut self)
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);
sourcepub fn subnormalize_ieee(&mut self) -> &mut Self
pub fn subnormalize_ieee(&mut self) -> &mut Self
Emulate subnormal numbers for precisions specified in IEEE 754, rounding to the nearest.
Subnormalization is only performed for precisions specified in IEEE 754:
- binary16 with 16 storage bits and a precision of 11 bits,
- binary32 (single precision) with 32 storage bits and a precision of 24 bits,
- binary64 (double precision) with 64 storage bits and a precision of 53 bits,
- binary{k} with k storage bits where k is a multiple of 32 and k ≥ 128, and a precision of k − round(4 × log2 k) + 13 bits.
This method has no effect if the value is not in the subnormal range.
§Examples
use rug::Float;
// 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);
sourcepub fn subnormalize_ieee_round(
&mut self,
prev_rounding: Ordering,
round: Round
) -> Ordering
pub fn subnormalize_ieee_round( &mut self, prev_rounding: Ordering, round: Round ) -> Ordering
Emulate subnormal numbers for precisions specified in IEEE 754, applying the specified rounding method.
Subnormalization is only performed for precisions specified in IEEE 754:
- binary16 with 16 storage bits and a precision of 11 bits,
- binary32 (single precision) with 32 storage bits and a precision of 24 bits,
- binary64 (double precision) with 64 storage bits and a precision of 53 bits,
- binary{k} with k storage bits where k is a multiple of 32 and k ≥ 128, and a precision of k − round(4 × log2 k) + 13 bits.
This method simply propagates prev_rounding
if the value is not in the
subnormal range.
§Examples
use core::cmp::Ordering;
use rug::float::Round;
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);
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);
sourcepub fn subnormalize(&mut self, normal_exp_min: i32) -> &mut Self
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);
sourcepub fn subnormalize_round(
&mut self,
normal_exp_min: i32,
prev_rounding: Ordering,
round: Round
) -> Ordering
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;
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);
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);
sourcepub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I>
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I>
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
,Add<Float> for Src
SubAssign<Src> for Float
,SubFrom<Src> for Float
SubAssignRound<Src> for Float
,SubFromRound<Src> for Float
Sub<Src> for Float
,Sub<Float> for Src
CompleteRound<Completed = Float> for Src
§Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::ops::AddAssignRound;
use rug::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);
sourcepub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I>
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I>
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
,Add<Float> for Src
SubAssign<Src> for Float
,SubFrom<Src> for Float
SubAssignRound<Src> for Float
,SubFromRound<Src> for Float
Sub<Src> for Float
,Sub<Float> for Src
CompleteRound<Completed = Float> for Src
This method will produce a result with correct rounding, except for some cases where underflow or overflow occurs in intermediate products.
§Examples
use rug::Float;
let a = [Float::with_val(53, 2.75), Float::with_val(53, -1.25)];
let b = [Float::with_val(53, 10.5), Float::with_val(53, 0.5)];
let r = Float::dot(a.iter().zip(b.iter()));
let dot = Float::with_val(53, r);
let expected = 2.75 * 10.5 - 1.25 * 0.5;
assert_eq!(dot, expected);
let r = Float::dot(b.iter().zip(a.iter()));
let twice = dot + r;
assert_eq!(twice, expected * 2.0);
sourcepub fn remainder(self, divisor: &Self) -> Self
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);
sourcepub fn remainder_mut(&mut self, divisor: &Self)
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);
sourcepub fn remainder_round(&mut self, divisor: &Self, round: Round) -> Ordering
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;
use rug::ops::RemAssignRound;
use rug::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);
sourcepub fn remainder_from(&mut self, dividend: &Self)
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;
use rug::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);
sourcepub fn remainder_from_round(
&mut self,
dividend: &Self,
round: Round
) -> Ordering
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;
use rug::ops::RemFromRound;
use rug::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);
sourcepub fn remainder_ref<'a>(&'a self, divisor: &'a Self) -> RemainderIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§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);
sourcepub fn mul_add(self, mul: &Self, add: &Self) -> Self
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);
sourcepub fn mul_add_mut(&mut self, mul: &Self, add: &Self)
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);
sourcepub fn mul_add_round(
&mut self,
mul: &Self,
add: &Self,
round: Round
) -> Ordering
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;
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
let dir = mul1.mul_add_round(&mul2, &add, Round::Nearest);
assert_eq!(mul1, 4.5);
assert_eq!(dir, Ordering::Equal);
sourcepub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
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
CompleteRound<Completed = Float> for Src
a.mul_add_ref(&b, &c)
produces the exact same result as &a * &b + &c
.
§Examples
use rug::Float;
// Use only 4 bits of precision for demonstration purposes.
// 1.5 in binary is 1.1.
let mul1 = Float::with_val(4, 1.5);
// -13 in binary is -1101.
let mul2 = Float::with_val(4, -13);
// 24 in binary is 11000.
let add = Float::with_val(4, 24);
// 1.5 × -13 + 24 = 4.5
let ans = Float::with_val(4, mul1.mul_add_ref(&mul2, &add));
assert_eq!(ans, 4.5);
sourcepub fn mul_sub(self, mul: &Self, sub: &Self) -> Self
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);
sourcepub fn mul_sub_mut(&mut self, mul: &Self, sub: &Self)
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);
sourcepub fn mul_sub_round(
&mut self,
mul: &Self,
sub: &Self,
round: Round
) -> Ordering
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;
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.
let dir = mul1.mul_sub_round(&mul2, &sub, Round::Nearest);
assert_eq!(mul1, -44);
assert_eq!(dir, Ordering::Less);
sourcepub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
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
CompleteRound<Completed = Float> for Src
a.mul_sub_ref(&b, &c)
produces the exact same result as &a * &b - &c
.
§Examples
use rug::Float;
// Use only 4 bits of precision for demonstration purposes.
// 1.5 in binary is 1.1.
let mul1 = Float::with_val(4, 1.5);
// -13 in binary is -1101.
let mul2 = Float::with_val(4, -13);
// 24 in binary is 11000.
let sub = Float::with_val(4, 24);
// 1.5 × -13 - 24 = -43.5, rounded to 44 using four bits of precision.
let ans = Float::with_val(4, mul1.mul_sub_ref(&mul2, &sub));
assert_eq!(ans, -44);
sourcepub fn mul_add_mul(self, mul: &Self, add_mul1: &Self, add_mul2: &Self) -> Self
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);
sourcepub fn mul_add_mul_mut(&mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self)
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);
sourcepub fn mul_add_mul_round(
&mut self,
mul: &Self,
add_mul1: &Self,
add_mul2: &Self,
round: Round
) -> Ordering
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;
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
let dir = a.mul_add_mul_round(&b, &c, &d, Round::Nearest);
assert_eq!(a, 60);
assert_eq!(dir, Ordering::Equal);
sourcepub fn mul_add_mul_ref<'a>(
&'a self,
mul: &'a Self,
add_mul1: &'a Self,
add_mul2: &'a Self
) -> MulAddMulIncomplete<'a>
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
CompleteRound<Completed = Float> for Src
a.mul_add_mul_ref(&b, &c, &d)
produces the exact same result
as &a * &b + &c * &d
.
§Examples
use rug::Float;
let a = Float::with_val(53, 24);
let b = Float::with_val(53, 1.5);
let c = Float::with_val(53, 12);
let d = Float::with_val(53, 2);
// 24 × 1.5 + 12 × 2 = 60
let ans = Float::with_val(53, a.mul_add_mul_ref(&b, &c, &d));
assert_eq!(ans, 60);
sourcepub fn mul_sub_mul(self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self) -> Self
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);
sourcepub fn mul_sub_mul_mut(&mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self)
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);
sourcepub fn mul_sub_mul_round(
&mut self,
mul: &Self,
sub_mul1: &Self,
sub_mul2: &Self,
round: Round
) -> Ordering
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;
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
let dir = a.mul_sub_mul_round(&b, &c, &d, Round::Nearest);
assert_eq!(a, 12);
assert_eq!(dir, Ordering::Equal);
sourcepub fn mul_sub_mul_ref<'a>(
&'a self,
mul: &'a Self,
sub_mul1: &'a Self,
sub_mul2: &'a Self
) -> MulSubMulIncomplete<'a>
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
CompleteRound<Completed = Float> for Src
a.mul_sub_mul_ref(&b, &c, &d)
produces the exact same result as &a * &b - &c * &d
.
§Examples
use rug::Float;
let a = Float::with_val(53, 24);
let b = Float::with_val(53, 1.5);
let c = Float::with_val(53, 12);
let d = Float::with_val(53, 2);
// 24 × 1.5 - 12 × 2 = 12
let ans = Float::with_val(53, a.mul_sub_mul_ref(&b, &c, &d));
assert_eq!(ans, 12);
sourcepub fn u_exp(u: u32, exp: i32) -> UExpIncomplete
pub fn u_exp(u: u32, exp: i32) -> UExpIncomplete
Multiplies u
by 2exp
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
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);
sourcepub fn i_exp(i: i32, exp: i32) -> IExpIncomplete
pub fn i_exp(i: i32, exp: i32) -> IExpIncomplete
Multiplies i
by 2exp
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
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);
sourcepub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let p = Float::u_pow_u(13, 6);
let f = Float::with_val(53, p);
assert_eq!(f, 13u32.pow(6));
sourcepub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let p = Float::i_pow_u(-13, 5);
let f = Float::with_val(53, p);
assert_eq!(f, -13i32.pow(5));
sourcepub fn square(self) -> Self
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);
sourcepub fn square_mut(&mut self)
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);
sourcepub fn square_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn square_ref(&self) -> SquareIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 5.0);
let r = f.square_ref();
let square = Float::with_val(53, r);
assert_eq!(square, 25.0);
sourcepub fn sqrt(self) -> Self
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);
sourcepub fn sqrt_mut(&mut self)
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);
sourcepub fn sqrt_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn sqrt_ref(&self) -> SqrtIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 25.0);
let r = f.sqrt_ref();
let sqrt = Float::with_val(53, r);
assert_eq!(sqrt, 5.0);
sourcepub fn sqrt_u(u: u32) -> SqrtUIncomplete
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let s = Float::sqrt_u(25);
let f = Float::with_val(53, s);
assert_eq!(f, 5.0);
sourcepub fn recip_sqrt(self) -> Self
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);
sourcepub fn recip_sqrt_mut(&mut self)
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);
sourcepub fn recip_sqrt_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn recip_sqrt_ref(&self) -> RecipSqrtIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 16.0);
let r = f.recip_sqrt_ref();
let recip_sqrt = Float::with_val(53, r);
assert_eq!(recip_sqrt, 0.25);
sourcepub fn cbrt(self) -> Self
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);
sourcepub fn cbrt_mut(&mut self)
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);
sourcepub fn cbrt_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn cbrt_ref(&self) -> CbrtIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 125.0);
let r = f.cbrt_ref();
let cbrt = Float::with_val(53, r);
assert_eq!(cbrt, 5.0);
sourcepub fn root(self, k: u32) -> Self
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);
sourcepub fn root_mut(&mut self, k: u32)
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);
sourcepub fn root_round(&mut self, k: u32, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn root_ref(&self, k: u32) -> RootIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 625.0);
let r = f.root_ref(4);
let root = Float::with_val(53, r);
assert_eq!(root, 5.0);
sourcepub fn root_i(self, k: i32) -> Self
pub fn root_i(self, k: i32) -> Self
Computes the kth root, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, 625.0);
let root_i = f.root_i(-4);
let expected = 0.2000_f64;
assert!((root_i - expected).abs() < 0.0001);
sourcepub fn root_i_mut(&mut self, k: i32)
pub fn root_i_mut(&mut self, k: i32)
Computes the kth root, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 625.0);
f.root_i_mut(-4);
let expected = 0.2000_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn root_i_round(&mut self, k: i32, round: Round) -> Ordering
pub fn root_i_round(&mut self, k: i32, round: Round) -> Ordering
Computes the kth root, 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, 5.0);
// 5.0 ^ -1/4 = 0.6687
// using 4 significant bits: 0.6875
let dir = f.root_i_round(-4, Round::Nearest);
assert_eq!(f, 0.6875);
assert_eq!(dir, Ordering::Greater);
sourcepub fn root_i_ref(&self, k: i32) -> RootIIncomplete<'_>
pub fn root_i_ref(&self, k: i32) -> RootIIncomplete<'_>
Computes the kth root.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 625.0);
let r = f.root_i_ref(-4);
let root_i = Float::with_val(53, r);
let expected = 0.2000_f64;
assert!((root_i - expected).abs() < 0.0001);
sourcepub fn abs(self) -> Self
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);
sourcepub fn abs_mut(&mut self)
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);
sourcepub fn abs_ref(&self) -> AbsIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -23.5);
let r = f.abs_ref();
let abs = Float::with_val(53, r);
assert_eq!(abs, 23.5);
sourcepub fn signum(self) -> Self
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);
sourcepub fn signum_mut(&mut self)
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);
sourcepub fn signum_ref(&self) -> SignumIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -23.5);
let r = f.signum_ref();
let signum = Float::with_val(53, r);
assert_eq!(signum, -1);
sourcepub fn copysign(self, y: &Self) -> Self
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);
sourcepub fn copysign_mut(&mut self, y: &Self)
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);
sourcepub fn copysign_ref<'a>(&'a self, y: &'a Self) -> CopysignIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§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);
sourcepub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Selfwhere
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
pub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Selfwhere
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);
sourcepub 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>,
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);
sourcepub fn clamp_round<Min, Max>(
&mut self,
min: &Min,
max: &Max,
round: Round
) -> Orderingwhere
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
pub fn clamp_round<Min, Max>(
&mut self,
min: &Min,
max: &Max,
round: Round
) -> Orderingwhere
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;
use rug::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);
sourcepub 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>,
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
CompleteRound<Completed = Float> for Src
§Panics
Panics if the maximum value is less than the minimum value, unless assigning any of them to the target produces the same value with the same rounding direction.
§Examples
use rug::Float;
let min = -1.5;
let max = 1.5;
let too_small = Float::with_val(53, -2.5);
let r1 = too_small.clamp_ref(&min, &max);
let clamped1 = Float::with_val(53, r1);
assert_eq!(clamped1, -1.5);
let in_range = Float::with_val(53, 0.5);
let r2 = in_range.clamp_ref(&min, &max);
let clamped2 = Float::with_val(53, r2);
assert_eq!(clamped2, 0.5);
sourcepub fn recip(self) -> Self
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);
sourcepub fn recip_mut(&mut self)
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);
sourcepub fn recip_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn recip_ref(&self) -> RecipIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.25);
let r = f.recip_ref();
let recip = Float::with_val(53, r);
assert_eq!(recip, -4.0);
sourcepub fn min(self, other: &Self) -> Self
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);
sourcepub fn min_mut(&mut self, other: &Self)
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);
sourcepub fn min_round(&mut self, other: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn min_ref<'a>(&'a self, other: &'a Self) -> MinIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let a = Float::with_val(53, 5.2);
let b = Float::with_val(53, -2);
let r = a.min_ref(&b);
let min = Float::with_val(53, r);
assert_eq!(min, -2);
sourcepub fn max(self, other: &Self) -> Self
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);
sourcepub fn max_mut(&mut self, other: &Self)
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);
sourcepub fn max_round(&mut self, other: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn max_ref<'a>(&'a self, other: &'a Self) -> MaxIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let a = Float::with_val(53, 5.2);
let b = Float::with_val(53, 12.5);
let r = a.max_ref(&b);
let max = Float::with_val(53, r);
assert_eq!(max, 12.5);
sourcepub fn positive_diff(self, other: &Self) -> Self
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);
sourcepub fn positive_diff_mut(&mut self, other: &Self)
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);
sourcepub fn positive_diff_round(&mut self, other: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn positive_diff_ref<'a>(
&'a self,
other: &'a Self
) -> PositiveDiffIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let a = Float::with_val(53, 12.5);
let b = Float::with_val(53, 7.3);
let rab = a.positive_diff_ref(&b);
let ab = Float::with_val(53, rab);
assert_eq!(ab, 5.2);
let rba = b.positive_diff_ref(&a);
let ba = Float::with_val(53, rba);
assert_eq!(ba, 0);
sourcepub fn ln(self) -> Self
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);
sourcepub fn ln_mut(&mut self)
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);
sourcepub fn ln_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn ln_ref(&self) -> LnIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.5);
let ln = Float::with_val(53, f.ln_ref());
let expected = 0.4055_f64;
assert!((ln - expected).abs() < 0.0001);
sourcepub fn ln_u(u: u32) -> LnUIncomplete
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let l = Float::ln_u(3);
let f = Float::with_val(53, l);
let expected = 1.0986f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn log2(self) -> Self
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);
sourcepub fn log2_mut(&mut self)
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);
sourcepub fn log2_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn log2_ref(&self) -> Log2Incomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.5);
let log2 = Float::with_val(53, f.log2_ref());
let expected = 0.5850_f64;
assert!((log2 - expected).abs() < 0.0001);
sourcepub fn log10(self) -> Self
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);
sourcepub fn log10_mut(&mut self)
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);
sourcepub fn log10_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn log10_ref(&self) -> Log10Incomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.5);
let log10 = Float::with_val(53, f.log10_ref());
let expected = 0.1761_f64;
assert!((log10 - expected).abs() < 0.0001);
sourcepub fn exp(self) -> Self
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);
sourcepub fn exp_mut(&mut self)
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);
sourcepub fn exp_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn exp_ref(&self) -> ExpIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.5);
let exp = Float::with_val(53, f.exp_ref());
let expected = 4.4817_f64;
assert!((exp - expected).abs() < 0.0001);
sourcepub fn exp2(self) -> Self
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);
sourcepub fn exp2_mut(&mut self)
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);
sourcepub fn exp2_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn exp2_ref(&self) -> Exp2Incomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.5);
let exp2 = Float::with_val(53, f.exp2_ref());
let expected = 2.8284_f64;
assert!((exp2 - expected).abs() < 0.0001);
sourcepub fn exp10(self) -> Self
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);
sourcepub fn exp10_mut(&mut self)
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);
sourcepub fn exp10_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn exp10_ref(&self) -> Exp10Incomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.5);
let exp10 = Float::with_val(53, f.exp10_ref());
let expected = 31.6228_f64;
assert!((exp10 - expected).abs() < 0.0001);
sourcepub fn sin(self) -> Self
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);
sourcepub fn sin_mut(&mut self)
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);
sourcepub fn sin_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn sin_ref(&self) -> SinIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let sin = Float::with_val(53, f.sin_ref());
let expected = 0.9490_f64;
assert!((sin - expected).abs() < 0.0001);
sourcepub fn cos(self) -> Self
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);
sourcepub fn cos_mut(&mut self)
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);
sourcepub fn cos_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn cos_ref(&self) -> CosIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let cos = Float::with_val(53, f.cos_ref());
let expected = 0.3153_f64;
assert!((cos - expected).abs() < 0.0001);
sourcepub fn tan(self) -> Self
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);
sourcepub fn tan_mut(&mut self)
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);
sourcepub fn tan_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn tan_ref(&self) -> TanIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let tan = Float::with_val(53, f.tan_ref());
let expected = 3.0096_f64;
assert!((tan - expected).abs() < 0.0001);
sourcepub fn sin_cos(self, cos: Self) -> (Self, Self)
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);
sourcepub fn sin_cos_mut(&mut self, cos: &mut Self)
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);
sourcepub fn sin_cos_round(
&mut self,
cos: &mut Self,
round: Round
) -> (Ordering, Ordering)
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;
use rug::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);
sourcepub fn sin_cos_ref(&self) -> SinCosIncomplete<'_>
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)
CompleteRound<Completed = (Float, Float)> for Src
§Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::ops::AssignRound;
use rug::{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);
sourcepub fn sin_u(self, u: u32) -> Self
pub fn sin_u(self, u: u32) -> Self
Computes the sine of (2π/u) × self
, rounding to the
nearest.
For example, if u = 360, then this is the sine for
self
in degrees.
§Examples
use rug::Float;
let f = Float::with_val(53, 60);
let sin = f.sin_u(360);
let expected = 0.75_f64.sqrt();
assert!((sin - expected).abs() < 0.0001);
sourcepub fn sin_u_mut(&mut self, u: u32)
pub fn sin_u_mut(&mut self, u: u32)
Computes the sine of (2π/u) × self
, rounding to the
nearest.
For example, if u = 360, then this is the sine for
self
in degrees.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 60);
f.sin_u_mut(360);
let expected = 0.75_f64.sqrt();
assert!((f - expected).abs() < 0.0001);
sourcepub fn sin_u_round(&mut self, u: u32, round: Round) -> Ordering
pub fn sin_u_round(&mut self, u: u32, round: Round) -> Ordering
Computes the sine of (2π/u) × self
, applying the
specified rounding method.
For example, if u = 360, then this is the sine for
self
in degrees.
§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, 60);
// sin(60°) = 0.8660
// using 4 significant bits: 0.875
let dir = f.sin_u_round(360, Round::Nearest);
assert_eq!(f, 0.875);
assert_eq!(dir, Ordering::Greater);
sourcepub fn sin_u_ref(&self, u: u32) -> SinUIncomplete<'_>
pub fn sin_u_ref(&self, u: u32) -> SinUIncomplete<'_>
Computes the sine of (2π/u) × self
.
For example, if u = 360, then this is the sine for
self
in degrees.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 60);
let sin = Float::with_val(53, f.sin_u_ref(360));
let expected = 0.75_f64.sqrt();
assert!((sin - expected).abs() < 0.0001);
sourcepub fn cos_u(self, u: u32) -> Self
pub fn cos_u(self, u: u32) -> Self
Computes the cosine of (2π/u) × self
, rounding to the
nearest.
For example, if u = 360, then this is the cosine for
self
in degrees.
§Examples
use rug::Float;
let f = Float::with_val(53, 30);
let cos = f.cos_u(360);
let expected = 0.75_f64.sqrt();
assert!((cos - expected).abs() < 0.0001);
sourcepub fn cos_u_mut(&mut self, u: u32)
pub fn cos_u_mut(&mut self, u: u32)
Computes the cosine of (2π/u) × self
, rounding to the
nearest.
For example, if u = 360, then this is the cosine for
self
in degrees.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 30);
f.cos_u_mut(360);
let expected = 0.75_f64.sqrt();
assert!((f - expected).abs() < 0.0001);
sourcepub fn cos_u_round(&mut self, u: u32, round: Round) -> Ordering
pub fn cos_u_round(&mut self, u: u32, round: Round) -> Ordering
Computes the cosine of (2π/u) × self
, applying the
specified rounding method.
For example, if u = 360, then this is the cosine for
self
in degrees.
§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, 30);
// cos(30°) = 0.8660
// using 4 significant bits: 0.875
let dir = f.cos_u_round(360, Round::Nearest);
assert_eq!(f, 0.875);
assert_eq!(dir, Ordering::Greater);
sourcepub fn cos_u_ref(&self, u: u32) -> CosUIncomplete<'_>
pub fn cos_u_ref(&self, u: u32) -> CosUIncomplete<'_>
Computes the cosine of (2π/u) × self
.
For example, if u = 360, then this is the cosine for
self
in degrees.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 30);
let cos = Float::with_val(53, f.cos_u_ref(360));
let expected = 0.75_f64.sqrt();
assert!((cos - expected).abs() < 0.0001);
sourcepub fn tan_u(self, u: u32) -> Self
pub fn tan_u(self, u: u32) -> Self
Computes the tangent of (2π/u) × self
, rounding to
the nearest.
For example, if u = 360, then this is the tangent for
self
in degrees.
§Examples
use rug::Float;
let f = Float::with_val(53, 60);
let tan = f.tan_u(360);
let expected = 3_f64.sqrt();
assert!((tan - expected).abs() < 0.0001);
sourcepub fn tan_u_mut(&mut self, u: u32)
pub fn tan_u_mut(&mut self, u: u32)
Computes the tangent of (2π/u) × self
, rounding to
the nearest.
For example, if u = 360, then this is the tangent for
self
in degrees.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 60);
f.tan_u_mut(360);
let expected = 3_f64.sqrt();
assert!((f - expected).abs() < 0.0001);
sourcepub fn tan_u_round(&mut self, u: u32, round: Round) -> Ordering
pub fn tan_u_round(&mut self, u: u32, round: Round) -> Ordering
Computes the tangent of (2π/u) × self
, applying the
specified rounding method.
For example, if u = 360, then this is the tangent for
self
in degrees.
§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, 60);
// tan(60°) = 1.7321
// using 4 significant bits: 1.75
let dir = f.tan_u_round(360, Round::Nearest);
assert_eq!(f, 1.75);
assert_eq!(dir, Ordering::Greater);
sourcepub fn tan_u_ref(&self, u: u32) -> TanUIncomplete<'_>
pub fn tan_u_ref(&self, u: u32) -> TanUIncomplete<'_>
Computes the tangent of (2π/u) × self
.
For example, if u = 360, then this is the tangent for
self
in degrees.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 60);
let tan = Float::with_val(53, f.tan_u_ref(360));
let expected = 3_f64.sqrt();
assert!((tan - expected).abs() < 0.0001);
sourcepub fn sin_pi(self) -> Self
pub fn sin_pi(self) -> Self
Computes the sine of π × self
, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, 0.25);
let sin = f.sin_pi();
let expected = 0.5_f64.sqrt();
assert!((sin - expected).abs() < 0.0001);
sourcepub fn sin_pi_mut(&mut self)
pub fn sin_pi_mut(&mut self)
Computes the sine of π × self
, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 0.25);
f.sin_pi_mut();
let expected = 0.5_f64.sqrt();
assert!((f - expected).abs() < 0.0001);
sourcepub fn sin_pi_round(&mut self, round: Round) -> Ordering
pub fn sin_pi_round(&mut self, round: Round) -> Ordering
Computes the sine 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, 0.25);
// sin(π/4°) = 0.7071
// using 4 significant bits: 0.6875
let dir = f.sin_pi_round(Round::Nearest);
assert_eq!(f, 0.6875);
assert_eq!(dir, Ordering::Less);
sourcepub fn sin_pi_ref(&self) -> SinPiIncomplete<'_>
pub fn sin_pi_ref(&self) -> SinPiIncomplete<'_>
Computes the sine of π × self
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 0.25);
let sin = Float::with_val(53, f.sin_pi_ref());
let expected = 0.5_f64.sqrt();
assert!((sin - expected).abs() < 0.0001);
sourcepub fn cos_pi(self) -> Self
pub fn cos_pi(self) -> Self
Computes the cosine of π × self
, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, 0.25);
let cos = f.cos_pi();
let expected = 0.5_f64.sqrt();
assert!((cos - expected).abs() < 0.0001);
sourcepub fn cos_pi_mut(&mut self)
pub fn cos_pi_mut(&mut self)
Computes the cosine of π × self
, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 0.25);
f.cos_pi_mut();
let expected = 0.5_f64.sqrt();
assert!((f - expected).abs() < 0.0001);
sourcepub fn cos_pi_round(&mut self, round: Round) -> Ordering
pub fn cos_pi_round(&mut self, round: Round) -> Ordering
Computes the cosine 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, 0.25);
// cos(π/4) = 0.7071
// using 4 significant bits: 0.6875
let dir = f.cos_pi_round(Round::Nearest);
assert_eq!(f, 0.6875);
assert_eq!(dir, Ordering::Less);
sourcepub fn cos_pi_ref(&self) -> CosPiIncomplete<'_>
pub fn cos_pi_ref(&self) -> CosPiIncomplete<'_>
Computes the cosine of π × self
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 0.25);
let cos = Float::with_val(53, f.cos_pi_ref());
let expected = 0.5_f64.sqrt();
assert!((cos - expected).abs() < 0.0001);
sourcepub fn tan_pi(self) -> Self
pub fn tan_pi(self) -> Self
Computes the tangent of π × self
, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, 0.125);
let tan = f.tan_pi();
let expected = 0.4142_f64;
assert!((tan - expected).abs() < 0.0001);
sourcepub fn tan_pi_mut(&mut self)
pub fn tan_pi_mut(&mut self)
Computes the tangent of π × self
, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, 0.125);
f.tan_pi_mut();
let expected = 0.4142_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn tan_pi_round(&mut self, round: Round) -> Ordering
pub fn tan_pi_round(&mut self, round: Round) -> Ordering
Computes the tangent 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, 0.125);
// tan(π/8) = 0.4142
// using 4 significant bits: 0.40625
let dir = f.tan_pi_round(Round::Nearest);
assert_eq!(f, 0.40625);
assert_eq!(dir, Ordering::Less);
sourcepub fn tan_pi_ref(&self) -> TanPiIncomplete<'_>
pub fn tan_pi_ref(&self) -> TanPiIncomplete<'_>
Computes the tangent of π × self
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 0.125);
let tan = Float::with_val(53, f.tan_pi_ref());
let expected = 0.4142_f64;
assert!((tan - expected).abs() < 0.0001);
sourcepub fn sec(self) -> Self
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);
sourcepub fn sec_mut(&mut self)
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);
sourcepub fn sec_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn sec_ref(&self) -> SecIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let sec = Float::with_val(53, f.sec_ref());
let expected = 3.1714_f64;
assert!((sec - expected).abs() < 0.0001);
sourcepub fn csc(self) -> Self
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);
sourcepub fn csc_mut(&mut self)
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);
sourcepub fn csc_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn csc_ref(&self) -> CscIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let csc = Float::with_val(53, f.csc_ref());
let expected = 1.0538_f64;
assert!((csc - expected).abs() < 0.0001);
sourcepub fn cot(self) -> Self
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);
sourcepub fn cot_mut(&mut self)
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);
sourcepub fn cot_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn cot_ref(&self) -> CotIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let cot = Float::with_val(53, f.cot_ref());
let expected = 0.3323_f64;
assert!((cot - expected).abs() < 0.0001);
sourcepub fn asin(self) -> Self
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);
sourcepub fn asin_mut(&mut self)
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);
sourcepub fn asin_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn asin_ref(&self) -> AsinIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = Float::with_val(53, f.asin_ref());
let expected = -0.8481_f64;
assert!((asin - expected).abs() < 0.0001);
sourcepub fn acos(self) -> Self
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);
sourcepub fn acos_mut(&mut self)
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);
sourcepub fn acos_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn acos_ref(&self) -> AcosIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = Float::with_val(53, f.acos_ref());
let expected = 2.4189_f64;
assert!((acos - expected).abs() < 0.0001);
sourcepub fn atan(self) -> Self
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);
sourcepub fn atan_mut(&mut self)
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);
sourcepub fn atan_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn atan_ref(&self) -> AtanIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = Float::with_val(53, f.atan_ref());
let expected = -0.6435_f64;
assert!((atan - expected).abs() < 0.0001);
sourcepub fn atan2(self, x: &Self) -> Self
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);
sourcepub fn atan2_mut(&mut self, x: &Self)
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);
sourcepub fn atan2_round(&mut self, x: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn atan2_ref<'a>(&'a self, x: &'a Self) -> Atan2Incomplete<'_>
pub fn atan2_ref<'a>(&'a self, x: &'a Self) -> Atan2Incomplete<'_>
Computes the arc-tangent2.
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let r = y.atan2_ref(&x);
let atan2 = Float::with_val(53, r);
let expected = 2.4981_f64;
assert!((atan2 - expected).abs() < 0.0001);
sourcepub fn asin_u(self, u: u32) -> Self
pub fn asin_u(self, u: u32) -> Self
Computes the arc-sine then divides by 2π/u, rounding to the nearest.
For example, if u = 360, then this is the arc-sine in degrees.
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = f.asin_u(360);
let expected = -48.5904_f64;
assert!((asin - expected).abs() < 0.0001);
sourcepub fn asin_u_mut(&mut self, u: u32)
pub fn asin_u_mut(&mut self, u: u32)
Computes the arc-sine then divides by 2π/u, rounding to the nearest.
For example, if u = 360, then this is the arc-sine in degrees.
§Examples
use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.asin_u_mut(360);
let expected = -48.5904_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn asin_u_round(&mut self, u: u32, round: Round) -> Ordering
pub fn asin_u_round(&mut self, u: u32, round: Round) -> Ordering
Computes the arc-sine then divides by 2π/u, applying the specified rounding method.
For example, if u = 360, then this is the arc-sine in degrees.
§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) = -48.5904°
// using 4 significant bits: -48
let dir = f.asin_u_round(360, Round::Nearest);
assert_eq!(f, -48);
assert_eq!(dir, Ordering::Greater);
sourcepub fn asin_u_ref(&self, u: u32) -> AsinUIncomplete<'_>
pub fn asin_u_ref(&self, u: u32) -> AsinUIncomplete<'_>
Computes the arc-sine then divides by 2π/u.
For example, if u = 360, then this is the arc-sine in degrees.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = Float::with_val(53, f.asin_u_ref(360));
let expected = -48.5904_f64;
assert!((asin - expected).abs() < 0.0001);
sourcepub fn acos_u(self, u: u32) -> Self
pub fn acos_u(self, u: u32) -> Self
Computes the arc-cosine then divides by 2π/u, rounding to the nearest.
For example, if u = 360, then this is the arc-cosine in degrees.
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = f.acos_u(360);
let expected = 138.5904_f64;
assert!((acos - expected).abs() < 0.0001);
sourcepub fn acos_u_mut(&mut self, u: u32)
pub fn acos_u_mut(&mut self, u: u32)
Computes the arc-cosine then divides by 2π/u, rounding to the nearest.
For example, if u = 360, then this is the arc-cosine in degrees.
§Examples
use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.acos_u_mut(360);
let expected = 138.5904_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn acos_u_round(&mut self, u: u32, round: Round) -> Ordering
pub fn acos_u_round(&mut self, u: u32, round: Round) -> Ordering
Computes the arc-cosine then divides by 2π/u, applying the specified rounding method.
For example, if u = 360, then this is the arc-cosine in degrees.
§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) = 138.5904°
// using 4 significant bits: 144
let dir = f.acos_u_round(360, Round::Nearest);
assert_eq!(f, 144);
assert_eq!(dir, Ordering::Greater);
sourcepub fn acos_u_ref(&self, u: u32) -> AcosUIncomplete<'_>
pub fn acos_u_ref(&self, u: u32) -> AcosUIncomplete<'_>
Computes the arc-cosine then divides by 2π/u.
For example, if u = 360, then this is the arc-cosine in degrees.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = Float::with_val(53, f.acos_u_ref(360));
let expected = 138.5904_f64;
assert!((acos - expected).abs() < 0.0001);
sourcepub fn atan_u(self, u: u32) -> Self
pub fn atan_u(self, u: u32) -> Self
Computes the arc-tangent then divides by 2π/u, rounding to the nearest.
For example, if u = 360, then this is the arc-tangent in degrees.
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = f.atan_u(360);
let expected = -36.8699_f64;
assert!((atan - expected).abs() < 0.0001);
sourcepub fn atan_u_mut(&mut self, u: u32)
pub fn atan_u_mut(&mut self, u: u32)
Computes the arc-tangent then divides by 2π/u, rounding to the nearest.
For example, if u = 360, then this is the arc-tangent in degrees.
§Examples
use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.atan_u_mut(360);
let expected = -36.8699_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn atan_u_round(&mut self, u: u32, round: Round) -> Ordering
pub fn atan_u_round(&mut self, u: u32, round: Round) -> Ordering
Computes the arc-tangent then divides by 2π/u, applying the specified rounding method.
For example, if u = 360, then this is the arc-tangent in degrees.
§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) = -36.8699°
// using 4 significant bits: -36
let dir = f.atan_u_round(360, Round::Nearest);
assert_eq!(f, -36);
assert_eq!(dir, Ordering::Greater);
sourcepub fn atan_u_ref(&self, u: u32) -> AtanUIncomplete<'_>
pub fn atan_u_ref(&self, u: u32) -> AtanUIncomplete<'_>
Computes the arc-tangent then divides by 2π/u.
For example, if u = 360, then this is the arc-tangent in degrees.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = Float::with_val(53, f.atan_u_ref(360));
let expected = -36.8699_f64;
assert!((atan - expected).abs() < 0.0001);
sourcepub fn atan2_u(self, x: &Self, u: u32) -> Self
pub fn atan2_u(self, x: &Self, u: u32) -> Self
Computes the arc-tangent2 of self
and x
then divides by 2π/u,
rounding to the nearest.
For example, if u = 360, then this is the arc-tangent in degrees.
This is similar to the arc-tangent of self / x
, but has an output
range of u rather than u/2.
§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let atan2 = y.atan2_u(&x, 360);
let expected = 143.1301_f64;
assert!((atan2 - expected).abs() < 0.0001);
sourcepub fn atan2_u_mut(&mut self, x: &Self, u: u32)
pub fn atan2_u_mut(&mut self, x: &Self, u: u32)
Computes the arc-tangent2 of self
and x
then divides by 2π/u,
rounding to the nearest.
For example, if u = 360, then this is the arc-tangent in degrees.
This is similar to the arc-tangent of self / x
, but has an output
range of u rather than u/2.
§Examples
use rug::Float;
let mut y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
y.atan2_u_mut(&x, 360);
let expected = 143.1301_f64;
assert!((y - expected).abs() < 0.0001);
sourcepub fn atan2_u_round(&mut self, x: &Self, u: u32, round: Round) -> Ordering
pub fn atan2_u_round(&mut self, x: &Self, u: u32, round: Round) -> Ordering
Computes the arc-tangent2 of self
and x
then divides by 2π/u,
applying the specified rounding method.
For example, if u = 360, then this is the arc-tangent in degrees.
This is similar to the arc-tangent of self / x
, but has an output
range of u rather than u/2.
§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) = 143.1301°
// using 4 significant bits: 144
let dir = y.atan2_u_round(&x, 360, Round::Nearest);
assert_eq!(y, 144);
assert_eq!(dir, Ordering::Greater);
sourcepub fn atan2_u_ref<'a>(&'a self, x: &'a Self, u: u32) -> Atan2UIncomplete<'_>
pub fn atan2_u_ref<'a>(&'a self, x: &'a Self, u: u32) -> Atan2UIncomplete<'_>
Computes the arc-tangent2 then divides by 2π/u.
For example, if u = 360, then this is the arc-tangent in degrees.
This is similar to the arc-tangent of self / x
, but has an output
range of u rather than u/2.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let r = y.atan2_u_ref(&x, 360);
let atan2 = Float::with_val(53, r);
let expected = 143.1301_f64;
assert!((atan2 - expected).abs() < 0.0001);
sourcepub fn asin_pi(self) -> Self
pub fn asin_pi(self) -> Self
Computes the arc-sine then divides by π, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = f.asin_pi();
let expected = -0.2699_f64;
assert!((asin - expected).abs() < 0.0001);
sourcepub fn asin_pi_mut(&mut self)
pub fn asin_pi_mut(&mut self)
Computes the arc-sine then divides by π, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.asin_pi_mut();
let expected = -0.2699_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn asin_pi_round(&mut self, round: Round) -> Ordering
pub fn asin_pi_round(&mut self, round: Round) -> Ordering
Computes the arc-sine then divides by π, 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.2699
// using 4 significant bits: -0.28125
let dir = f.asin_pi_round(Round::Nearest);
assert_eq!(f, -0.28125);
assert_eq!(dir, Ordering::Less);
sourcepub fn asin_pi_ref(&self) -> AsinPiIncomplete<'_>
pub fn asin_pi_ref(&self) -> AsinPiIncomplete<'_>
Computes the arc-sine then divides by π.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = Float::with_val(53, f.asin_pi_ref());
let expected = -0.2699_f64;
assert!((asin - expected).abs() < 0.0001);
sourcepub fn acos_pi(self) -> Self
pub fn acos_pi(self) -> Self
Computes the arc-cosine then divides by π, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = f.acos_pi();
let expected = 0.7699_f64;
assert!((acos - expected).abs() < 0.0001);
sourcepub fn acos_pi_mut(&mut self)
pub fn acos_pi_mut(&mut self)
Computes the arc-cosine then divides by π, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.acos_pi_mut();
let expected = 0.7699_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn acos_pi_round(&mut self, round: Round) -> Ordering
pub fn acos_pi_round(&mut self, round: Round) -> Ordering
Computes the arc-cosine then divides by π, 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) = 0.7699
// using 4 significant bits: 0.75
let dir = f.acos_pi_round(Round::Nearest);
assert_eq!(f, 0.75);
assert_eq!(dir, Ordering::Less);
sourcepub fn acos_pi_ref(&self) -> AcosPiIncomplete<'_>
pub fn acos_pi_ref(&self) -> AcosPiIncomplete<'_>
Computes the arc-cosine then divides by π.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = Float::with_val(53, f.acos_pi_ref());
let expected = 0.7699_f64;
assert!((acos - expected).abs() < 0.0001);
sourcepub fn atan_pi(self) -> Self
pub fn atan_pi(self) -> Self
Computes the arc-tangent then divides by π, rounding to the nearest.
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = f.atan_pi();
let expected = -0.2048_f64;
assert!((atan - expected).abs() < 0.0001);
sourcepub fn atan_pi_mut(&mut self)
pub fn atan_pi_mut(&mut self)
Computes the arc-tangent then divides by π, rounding to the nearest.
§Examples
use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.atan_pi_mut();
let expected = -0.2048_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn atan_pi_round(&mut self, round: Round) -> Ordering
pub fn atan_pi_round(&mut self, round: Round) -> Ordering
Computes the arc-tangent then divides by π, 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.2048
// using 4 significant bits: -0.203125
let dir = f.atan_pi_round(Round::Nearest);
assert_eq!(f, -0.203125);
assert_eq!(dir, Ordering::Greater);
sourcepub fn atan_pi_ref(&self) -> AtanPiIncomplete<'_>
pub fn atan_pi_ref(&self) -> AtanPiIncomplete<'_>
Computes the arc-tangent then divides by π.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = Float::with_val(53, f.atan_pi_ref());
let expected = -0.2048_f64;
assert!((atan - expected).abs() < 0.0001);
sourcepub fn atan2_pi(self, x: &Self) -> Self
pub fn atan2_pi(self, x: &Self) -> Self
Computes the arc-tangent2 of self
and x
then divides by π, rounding
to the nearest.
This is similar to the arc-tangent of self / x
, but has an output
range of 2 rather than 1.
§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let atan2 = y.atan2_pi(&x);
let expected = 0.7952_f64;
assert!((atan2 - expected).abs() < 0.0001);
sourcepub fn atan2_pi_mut(&mut self, x: &Self)
pub fn atan2_pi_mut(&mut self, x: &Self)
Computes the arc-tangent2 of self
and x
then divides by π, rounding
to the nearest.
This is similar to the arc-tangent of self / x
, but has an output
range of 2 rather than 1.
§Examples
use rug::Float;
let mut y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
y.atan2_pi_mut(&x);
let expected = 0.7952_f64;
assert!((y - expected).abs() < 0.0001);
sourcepub fn atan2_pi_round(&mut self, x: &Self, round: Round) -> Ordering
pub fn atan2_pi_round(&mut self, x: &Self, round: Round) -> Ordering
Computes the arc-tangent2 of self
and x
then divides by π, applying
the specified rounding method.
This is similar to the arc-tangent of self / x
, but has an output
range of 2 rather than 1.
§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) = 0.7952
// using 4 significant bits: 0.8125
let dir = y.atan2_pi_round(&x, Round::Nearest);
assert_eq!(y, 0.8125);
assert_eq!(dir, Ordering::Greater);
sourcepub fn atan2_pi_ref<'a>(&'a self, x: &'a Self) -> Atan2PiIncomplete<'_>
pub fn atan2_pi_ref<'a>(&'a self, x: &'a Self) -> Atan2PiIncomplete<'_>
Computes the arc-tangent2 then divides by π.
This is similar to the arc-tangent of self / x
, but has an output
range of 2 rather than 1.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let r = y.atan2_pi_ref(&x);
let atan2 = Float::with_val(53, r);
let expected = 0.7952_f64;
assert!((atan2 - expected).abs() < 0.0001);
sourcepub fn sinh(self) -> Self
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);
sourcepub fn sinh_mut(&mut self)
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);
sourcepub fn sinh_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn sinh_ref(&self) -> SinhIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let sinh = Float::with_val(53, f.sinh_ref());
let expected = 1.6019_f64;
assert!((sinh - expected).abs() < 0.0001);
sourcepub fn cosh(self) -> Self
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);
sourcepub fn cosh_mut(&mut self)
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);
sourcepub fn cosh_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn cosh_ref(&self) -> CoshIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let cosh = Float::with_val(53, f.cosh_ref());
let expected = 1.8884_f64;
assert!((cosh - expected).abs() < 0.0001);
sourcepub fn tanh(self) -> Self
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);
sourcepub fn tanh_mut(&mut self)
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);
sourcepub fn tanh_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn tanh_ref(&self) -> TanhIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let tanh = Float::with_val(53, f.tanh_ref());
let expected = 0.8483_f64;
assert!((tanh - expected).abs() < 0.0001);
sourcepub fn sinh_cosh(self, cos: Self) -> (Self, Self)
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);
sourcepub fn sinh_cosh_mut(&mut self, cos: &mut Self)
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);
sourcepub fn sinh_cosh_round(
&mut self,
cos: &mut Self,
round: Round
) -> (Ordering, Ordering)
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;
use rug::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);
sourcepub fn sinh_cosh_ref(&self) -> SinhCoshIncomplete<'_>
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)
CompleteRound<Completed = (Float, Float)> for Src
§Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::ops::AssignRound;
use rug::{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);
sourcepub fn sech(self) -> Self
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);
sourcepub fn sech_mut(&mut self)
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);
sourcepub fn sech_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn sech_ref(&self) -> SechIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let sech = Float::with_val(53, f.sech_ref());
let expected = 0.5295_f64;
assert!((sech - expected).abs() < 0.0001);
sourcepub fn csch(self) -> Self
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);
sourcepub fn csch_mut(&mut self)
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);
sourcepub fn csch_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn csch_ref(&self) -> CschIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let csch = Float::with_val(53, f.csch_ref());
let expected = 0.6243_f64;
assert!((csch - expected).abs() < 0.0001);
sourcepub fn coth(self) -> Self
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);
sourcepub fn coth_mut(&mut self)
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);
sourcepub fn coth_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn coth_ref(&self) -> CothIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let coth = Float::with_val(53, f.coth_ref());
let expected = 1.1789_f64;
assert!((coth - expected).abs() < 0.0001);
sourcepub fn asinh(self) -> Self
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);
sourcepub fn asinh_mut(&mut self)
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);
sourcepub fn asinh_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn asinh_ref(&self) -> AsinhIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let asinh = Float::with_val(53, f.asinh_ref());
let expected = 1.0476_f64;
assert!((asinh - expected).abs() < 0.0001);
sourcepub fn acosh(self) -> Self
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);
sourcepub fn acosh_mut(&mut self)
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);
sourcepub fn acosh_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn acosh_ref(&self) -> AcoshIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let acosh = Float::with_val(53, f.acosh_ref());
let expected = 0.6931_f64;
assert!((acosh - expected).abs() < 0.0001);
sourcepub fn atanh(self) -> Self
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);
sourcepub fn atanh_mut(&mut self)
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);
sourcepub fn atanh_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn atanh_ref(&self) -> AtanhIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 0.75);
let atanh = Float::with_val(53, f.atanh_ref());
let expected = 0.9730_f64;
assert!((atanh - expected).abs() < 0.0001);
sourcepub fn factorial(n: u32) -> FactorialIncomplete
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
// 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1
let n = Float::factorial(10);
let f = Float::with_val(53, n);
assert_eq!(f, 3628800.0);
sourcepub fn ln_1p(self) -> Self
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);
sourcepub fn ln_1p_mut(&mut self)
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);
sourcepub fn ln_1p_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn ln_1p_ref(&self) -> Ln1pIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let ln_1p = Float::with_val(53, f.ln_1p_ref());
let expected = 1.4989_f64 * two_to_m10;
assert!((ln_1p - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn log2_1p(self) -> Self
pub fn log2_1p(self) -> Self
Computes the logarithm to base 2 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 log2_1p = f.log2_1p();
let expected = 2.1625_f64 * two_to_m10;
assert!((log2_1p - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn log2_1p_mut(&mut self)
pub fn log2_1p_mut(&mut self)
Computes the logarithm to base 2 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.log2_1p_mut();
let expected = 2.1625_f64 * two_to_m10;
assert!((f - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn log2_1p_round(&mut self, round: Round) -> Ordering
pub fn log2_1p_round(&mut self, round: Round) -> Ordering
Computes the logarithm to base 2 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);
// log2_1p(1.5 × 2 ^ -10) = 2.1625 × 2 ^ -10
// using 4 significant bits: 2.25 × 2 ^ -10
let dir = f.log2_1p_round(Round::Nearest);
assert_eq!(f, 2.25 * two_to_m10);
assert_eq!(dir, Ordering::Greater);
sourcepub fn log2_1p_ref(&self) -> LogTwo1pIncomplete<'_>
pub fn log2_1p_ref(&self) -> LogTwo1pIncomplete<'_>
Computes the logorithm to base 2 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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let log2_1p = Float::with_val(53, f.log2_1p_ref());
let expected = 2.1625_f64 * two_to_m10;
assert!((log2_1p - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn log10_1p(self) -> Self
pub fn log10_1p(self) -> Self
Computes the logarithm to base 10 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 log10_1p = f.log10_1p();
let expected = 0.6510_f64 * two_to_m10;
assert!((log10_1p - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn log10_1p_mut(&mut self)
pub fn log10_1p_mut(&mut self)
Computes the logarithm to base 10 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.log10_1p_mut();
let expected = 0.6510_f64 * two_to_m10;
assert!((f - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn log10_1p_round(&mut self, round: Round) -> Ordering
pub fn log10_1p_round(&mut self, round: Round) -> Ordering
Computes the logarithm to base 10 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);
// log10_1p(1.5 × 2 ^ -10) = 0.6510 × 2 ^ -10
// using 4 significant bits: 0.625 × 2 ^ -10
let dir = f.log10_1p_round(Round::Nearest);
assert_eq!(f, 0.625 * two_to_m10);
assert_eq!(dir, Ordering::Less);
sourcepub fn log10_1p_ref(&self) -> LogTen1pIncomplete<'_>
pub fn log10_1p_ref(&self) -> LogTen1pIncomplete<'_>
Computes the logorithm to base 10 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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let log10_1p = Float::with_val(53, f.log10_1p_ref());
let expected = 0.6510_f64 * two_to_m10;
assert!((log10_1p - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp_m1(self) -> Self
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);
sourcepub fn exp_m1_mut(&mut self)
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);
sourcepub fn exp_m1_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn exp_m1_ref(&self) -> ExpM1Incomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let exp_m1 = Float::with_val(53, f.exp_m1_ref());
let expected = 1.5011_f64 * two_to_m10;
assert!((exp_m1 - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp2_m1(self) -> Self
pub fn exp2_m1(self) -> Self
Subtracts one from 2 to the power 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 exp2_m1 = f.exp2_m1();
let expected = 1.0402_f64 * two_to_m10;
assert!((exp2_m1 - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp2_m1_mut(&mut self)
pub fn exp2_m1_mut(&mut self)
Subtracts one from 2 to the power 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.exp2_m1_mut();
let expected = 1.0402_f64 * two_to_m10;
assert!((f - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp2_m1_round(&mut self, round: Round) -> Ordering
pub fn exp2_m1_round(&mut self, round: Round) -> Ordering
Subtracts one from 2 to the power 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);
// exp2_m1(1.5 × 2 ^ -10) = 1.0402 × 2 ^ -10
// using 4 significant bits: 1.0 × 2 ^ -10
let dir = f.exp2_m1_round(Round::Nearest);
assert_eq!(f, 1.0 * two_to_m10);
assert_eq!(dir, Ordering::Less);
sourcepub fn exp2_m1_ref(&self) -> Exp2M1Incomplete<'_>
pub fn exp2_m1_ref(&self) -> Exp2M1Incomplete<'_>
Computes one less than 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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let exp2_m1 = Float::with_val(53, f.exp2_m1_ref());
let expected = 1.0402_f64 * two_to_m10;
assert!((exp2_m1 - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp10_m1(self) -> Self
pub fn exp10_m1(self) -> Self
Subtracts one from 10 to the power 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 exp10_m1 = f.exp10_m1();
let expected = 3.4597_f64 * two_to_m10;
assert!((exp10_m1 - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp10_m1_mut(&mut self)
pub fn exp10_m1_mut(&mut self)
Subtracts one from 10 to the power 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.exp10_m1_mut();
let expected = 3.4597_f64 * two_to_m10;
assert!((f - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn exp10_m1_round(&mut self, round: Round) -> Ordering
pub fn exp10_m1_round(&mut self, round: Round) -> Ordering
Subtracts one from 10 to the power 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);
// exp10_m1(1.5 × 2 ^ -10) = 3.4597 × 2 ^ -10
// using 4 significant bits: 3.5 × 2 ^ -10
let dir = f.exp10_m1_round(Round::Nearest);
assert_eq!(f, 3.5 * two_to_m10);
assert_eq!(dir, Ordering::Greater);
sourcepub fn exp10_m1_ref(&self) -> Exp10M1Incomplete<'_>
pub fn exp10_m1_ref(&self) -> Exp10M1Incomplete<'_>
Computes one less than 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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let exp10_m1 = Float::with_val(53, f.exp10_m1_ref());
let expected = 3.4597_f64 * two_to_m10;
assert!((exp10_m1 - expected).abs() < 0.0001 * two_to_m10);
sourcepub fn compound_i(self, n: i32) -> Self
pub fn compound_i(self, n: i32) -> Self
Computes (1 + self
) to the power of n
, 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 compound = f.compound_i(100);
let expected = 1.1576_f64;
assert!((compound - expected).abs() < 0.0001);
sourcepub fn compound_i_mut(&mut self, n: i32)
pub fn compound_i_mut(&mut self, n: i32)
Computes (1 + self
) to the power of n
, 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.compound_i_mut(100);
let expected = 1.1576_f64;
assert!((f - expected).abs() < 0.0001);
sourcepub fn compound_i_round(&mut self, n: i32, round: Round) -> Ordering
pub fn compound_i_round(&mut self, n: i32, round: Round) -> Ordering
Computes (1 + self
) to the power of n
, 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);
// compound_i(1.5 × 2 ^ -10, 100) = 1.1576
// using 4 significant bits: 1.125
let dir = f.compound_i_round(100, Round::Nearest);
assert_eq!(f, 1.125);
assert_eq!(dir, Ordering::Less);
sourcepub fn compound_i_ref(&self, n: i32) -> CompoundIIncomplete<'_>
pub fn compound_i_ref(&self, n: i32) -> CompoundIIncomplete<'_>
Computes (1 + self
) to the power of n
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let compound = Float::with_val(53, f.compound_i_ref(100));
let expected = 1.1576_f64;
assert!((compound - expected).abs() < 0.0001);
sourcepub fn eint(self) -> Self
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);
sourcepub fn eint_mut(&mut self)
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);
sourcepub fn eint_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn eint_ref(&self) -> EintIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let eint = Float::with_val(53, f.eint_ref());
let expected = 2.5810_f64;
assert!((eint - expected).abs() < 0.0001);
sourcepub fn li2(self) -> Self
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);
sourcepub fn li2_mut(&mut self)
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);
sourcepub fn li2_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn li2_ref(&self) -> Li2Incomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let li2 = Float::with_val(53, f.li2_ref());
let expected = 2.1902_f64;
assert!((li2 - expected).abs() < 0.0001);
sourcepub fn gamma(self) -> Self
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);
sourcepub fn gamma_mut(&mut self)
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);
sourcepub fn gamma_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn gamma_ref(&self) -> GammaIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let gamma = Float::with_val(53, f.gamma_ref());
let expected = 0.9064_f64;
assert!((gamma - expected).abs() < 0.0001);
sourcepub fn gamma_inc(self, x: &Self) -> Self
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);
sourcepub fn gamma_inc_mut(&mut self, x: &Self)
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);
sourcepub fn gamma_inc_round(&mut self, x: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn gamma_inc_ref<'a>(&'a self, x: &'a Self) -> GammaIncIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let x = Float::with_val(53, 2.5);
let gamma_inc = Float::with_val(53, f.gamma_inc_ref(&x));
let expected = 0.1116_f64;
assert!((gamma_inc - expected).abs() < 0.0001);
sourcepub fn ln_gamma(self) -> Self
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);
sourcepub fn ln_gamma_mut(&mut self)
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);
sourcepub fn ln_gamma_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn ln_gamma_ref(&self) -> LnGammaIncomplete<'_>
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
CompleteRound<Completed = Float> for Src
§Examples
use rug::Float;
let f = Float::with_val(53, 1.25);
let ln_gamma = Float::with_val(53, f.ln_gamma_ref());
let expected = -0.0983_f64;
assert!((ln_gamma - expected).abs() < 0.0001);
sourcepub fn ln_abs_gamma(self) -> (Self, Ordering)
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;
use rug::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;
use rug::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));
sourcepub fn ln_abs_gamma_mut(&mut self) -> Ordering
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;
use rug::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));
sourcepub fn ln_abs_gamma_round(&mut self, round: Round) -> (Ordering, Ordering)
pub fn ln_abs_gamma_round(&mut self, round: Round) -> (Ordering, Ordering)
Computes the logarithm of the absolute value of the gamma function on
self
, applying the specified rounding method.
The returned tuple contains:
- The logarithm of the absolute value of the gamma function.
- The rounding direction.
§Examples
use core::cmp::Ordering;
use rug::float::{Constant, Round};
use rug::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);
sourcepub fn ln_abs_gamma_ref(&self) -> LnAbsGammaIncomplete<'_>
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)
CompleteRound<Completed = (Float, Float)> for Src
§Examples
use core::cmp::Ordering;
use rug::float::Constant;
use rug::{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));
sourcepub fn digamma(self) -> Self
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);
sourcepub fn digamma_mut(&mut self)
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);
sourcepub fn digamma_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn digamma_ref(&self) -> DigammaIncomplete<'_>
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);
sourcepub fn zeta(self) -> Self
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);
sourcepub fn zeta_mut(&mut self)
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);
sourcepub fn zeta_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn zeta_ref(&self) -> ZetaIncomplete<'_>
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);
sourcepub fn zeta_u(u: u32) -> ZetaUIncomplete
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);
sourcepub fn erf(self) -> Self
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);
sourcepub fn erf_mut(&mut self)
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);
sourcepub fn erf_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn erf_ref(&self) -> ErfIncomplete<'_>
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);
sourcepub fn erfc(self) -> Self
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);
sourcepub fn erfc_mut(&mut self)
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);
sourcepub fn erfc_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn erfc_ref(&self) -> ErfcIncomplete<'_>
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);
sourcepub fn j0(self) -> Self
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);
sourcepub fn j0_mut(&mut self)
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);
sourcepub fn j0_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn j0_ref(&self) -> J0Incomplete<'_>
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);
sourcepub fn j1(self) -> Self
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);
sourcepub fn j1_mut(&mut self)
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);
sourcepub fn j1_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn j1_ref(&self) -> J1Incomplete<'_>
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);
sourcepub fn jn(self, n: i32) -> Self
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);
sourcepub fn jn_mut(&mut self, n: i32)
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);
sourcepub fn jn_round(&mut self, n: i32, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn jn_ref(&self, n: i32) -> JnIncomplete<'_>
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);
sourcepub fn y0(self) -> Self
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);
sourcepub fn y0_mut(&mut self)
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);
sourcepub fn y0_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn y0_ref(&self) -> Y0Incomplete<'_>
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);
sourcepub fn y1(self) -> Self
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);
sourcepub fn y1_mut(&mut self)
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);
sourcepub fn y1_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn y1_ref(&self) -> Y1Incomplete<'_>
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);
sourcepub fn yn(self, n: i32) -> Self
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);
sourcepub fn yn_mut(&mut self, n: i32)
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);
sourcepub fn yn_round(&mut self, n: i32, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn yn_ref(&self, n: i32) -> YnIncomplete<'_>
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);
sourcepub fn agm(self, other: &Self) -> Self
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);
sourcepub fn agm_mut(&mut self, other: &Self)
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);
sourcepub fn agm_round(&mut self, other: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete<'_>
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);
sourcepub fn hypot(self, other: &Self) -> Self
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);
sourcepub fn hypot_mut(&mut self, other: &Self)
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);
sourcepub fn hypot_round(&mut self, other: &Self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn hypot_ref<'a>(&'a self, other: &'a Self) -> HypotIncomplete<'_>
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);
sourcepub fn ai(self) -> Self
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);
sourcepub fn ai_mut(&mut self)
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);
sourcepub fn ai_round(&mut self, round: Round) -> Ordering
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;
use rug::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);
sourcepub fn ai_ref(&self) -> AiIncomplete<'_>
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);
sourcepub fn ceil(self) -> Self
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);
sourcepub fn ceil_mut(&mut self)
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);
sourcepub fn ceil_ref(&self) -> CeilIncomplete<'_>
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);
sourcepub fn floor(self) -> Self
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);
sourcepub fn floor_mut(&mut self)
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);
sourcepub fn floor_ref(&self) -> FloorIncomplete<'_>
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);
sourcepub fn round(self) -> Self
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);
sourcepub fn round_mut(&mut self)
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);
sourcepub fn round_ref(&self) -> RoundIncomplete<'_>
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;
use rug::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);
sourcepub fn round_even(self) -> Self
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);
sourcepub fn round_even_mut(&mut self)
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);
sourcepub fn round_even_ref(&self) -> RoundEvenIncomplete<'_>
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);
sourcepub fn trunc(self) -> Self
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);
sourcepub fn trunc_mut(&mut self)
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);
sourcepub fn trunc_ref(&self) -> TruncIncomplete<'_>
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);
sourcepub fn fract(self) -> Self
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);
sourcepub fn fract_mut(&mut self)
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);
sourcepub fn fract_ref(&self) -> FractIncomplete<'_>
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);
sourcepub fn trunc_fract(self, fract: Self) -> (Self, Self)
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);
sourcepub fn trunc_fract_mut(&mut self, fract: &mut Self)
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);
sourcepub fn trunc_fract_round(
&mut self,
fract: &mut Self,
round: Round
) -> (Ordering, Ordering)
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;
use rug::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));
sourcepub fn trunc_fract_ref(&self) -> TruncFractIncomplete<'_>
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);
sourcepub fn random_bits(rng: &mut dyn MutRandState) -> RandomBitsIncomplete<'_>
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 < 2p, where 2p is two raised to the power of the precision, and then dividing the integer by 2p. The smallest non-zero result will thus be 2−p, and will only have one bit set. In the smaller possible results, many bits will be zero, and not all the precision will be used.
There is a corner case where the generated random number is converted to NaN: if the precision is very large, the generated random number could have an exponent less than the allowed minimum exponent, and NaN is used to indicate this. For this to occur in practice, the minimum exponent has to be set to have a very small magnitude using the low-level MPFR interface, or the random number generator has to be designed specifically to trigger this case.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
CompleteRound<Completed = Float> for Src
§Examples
use rug::rand::RandState;
use rug::{Assign, Float};
let mut rand = RandState::new();
let mut f = Float::new(2);
f.assign(Float::random_bits(&mut rand));
assert!(f == 0.0 || f == 0.25 || f == 0.5 || f == 0.75);
println!("0.0 ≤ {} < 1.0", f);
sourcepub fn random_cont(rng: &mut dyn MutRandState) -> RandomContIncomplete<'_>
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;
use rug::Float;
let mut rand = RandState::new();
let f = Float::with_val(2, Float::random_cont(&mut rand));
// The significand is either 0b10 or 0b11
assert!(
f == 1.0
|| f == 0.75
|| f == 0.5
|| f == 0.375
|| f == 0.25
|| f <= 0.1875
);
sourcepub fn random_normal(rng: &mut dyn MutRandState) -> RandomNormalIncomplete<'_>
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;
use rug::Float;
let mut rand = RandState::new();
let f = Float::with_val(53, Float::random_normal(&mut rand));
println!("Normal random number: {}", f);
sourcepub fn random_exp(rng: &mut dyn MutRandState) -> RandomExpIncomplete<'_>
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;
use rug::Float;
let mut rand = RandState::new();
let f = Float::with_val(53, Float::random_exp(&mut rand));
println!("Exponential random number: {}", f);
Trait Implementations§
source§impl AddAssign<&Float> for Complex
impl AddAssign<&Float> for Complex
source§fn add_assign(&mut self, rhs: &Float)
fn add_assign(&mut self, rhs: &Float)
+=
operation. Read moresource§impl AddAssign<&Float> for Float
impl AddAssign<&Float> for Float
source§fn add_assign(&mut self, rhs: &Float)
fn add_assign(&mut self, rhs: &Float)
+=
operation. Read moresource§impl AddAssign<&Integer> for Float
impl AddAssign<&Integer> for Float
source§fn add_assign(&mut self, rhs: &Integer)
fn add_assign(&mut self, rhs: &Integer)
+=
operation. Read moresource§impl AddAssign<&Rational> for Float
impl AddAssign<&Rational> for Float
source§fn add_assign(&mut self, rhs: &Rational)
fn add_assign(&mut self, rhs: &Rational)
+=
operation. Read moresource§impl AddAssign<&f32> for Float
impl AddAssign<&f32> for Float
source§fn add_assign(&mut self, rhs: &f32)
fn add_assign(&mut self, rhs: &f32)
+=
operation. Read moresource§impl AddAssign<&f64> for Float
impl AddAssign<&f64> for Float
source§fn add_assign(&mut self, rhs: &f64)
fn add_assign(&mut self, rhs: &f64)
+=
operation. Read moresource§impl AddAssign<&i128> for Float
impl AddAssign<&i128> for Float
source§fn add_assign(&mut self, rhs: &i128)
fn add_assign(&mut self, rhs: &i128)
+=
operation. Read moresource§impl AddAssign<&i16> for Float
impl AddAssign<&i16> for Float
source§fn add_assign(&mut self, rhs: &i16)
fn add_assign(&mut self, rhs: &i16)
+=
operation. Read moresource§impl AddAssign<&i32> for Float
impl AddAssign<&i32> for Float
source§fn add_assign(&mut self, rhs: &i32)
fn add_assign(&mut self, rhs: &i32)
+=
operation. Read moresource§impl AddAssign<&i64> for Float
impl AddAssign<&i64> for Float
source§fn add_assign(&mut self, rhs: &i64)
fn add_assign(&mut self, rhs: &i64)
+=
operation. Read moresource§impl AddAssign<&i8> for Float
impl AddAssign<&i8> for Float
source§fn add_assign(&mut self, rhs: &i8)
fn add_assign(&mut self, rhs: &i8)
+=
operation. Read moresource§impl AddAssign<&isize> for Float
impl AddAssign<&isize> for Float
source§fn add_assign(&mut self, rhs: &isize)
fn add_assign(&mut self, rhs: &isize)
+=
operation. Read moresource§impl AddAssign<&u128> for Float
impl AddAssign<&u128> for Float
source§fn add_assign(&mut self, rhs: &u128)
fn add_assign(&mut self, rhs: &u128)
+=
operation. Read moresource§impl AddAssign<&u16> for Float
impl AddAssign<&u16> for Float
source§fn add_assign(&mut self, rhs: &u16)
fn add_assign(&mut self, rhs: &u16)
+=
operation. Read moresource§impl AddAssign<&u32> for Float
impl AddAssign<&u32> for Float
source§fn add_assign(&mut self, rhs: &u32)
fn add_assign(&mut self, rhs: &u32)
+=
operation. Read moresource§impl AddAssign<&u64> for Float
impl AddAssign<&u64> for Float
source§fn add_assign(&mut self, rhs: &u64)
fn add_assign(&mut self, rhs: &u64)
+=
operation. Read moresource§impl AddAssign<&u8> for Float
impl AddAssign<&u8> for Float
source§fn add_assign(&mut self, rhs: &u8)
fn add_assign(&mut self, rhs: &u8)
+=
operation. Read moresource§impl AddAssign<&usize> for Float
impl AddAssign<&usize> for Float
source§fn add_assign(&mut self, rhs: &usize)
fn add_assign(&mut self, rhs: &usize)
+=
operation. Read moresource§impl AddAssign<Float> for Complex
impl AddAssign<Float> for Complex
source§fn add_assign(&mut self, rhs: Float)
fn add_assign(&mut self, rhs: Float)
+=
operation. Read moresource§impl AddAssign<Integer> for Float
impl AddAssign<Integer> for Float
source§fn add_assign(&mut self, rhs: Integer)
fn add_assign(&mut self, rhs: Integer)
+=
operation. Read moresource§impl AddAssign<Rational> for Float
impl AddAssign<Rational> for Float
source§fn add_assign(&mut self, rhs: Rational)
fn add_assign(&mut self, rhs: Rational)
+=
operation. Read moresource§impl AddAssign<f32> for Float
impl AddAssign<f32> for Float
source§fn add_assign(&mut self, rhs: f32)
fn add_assign(&mut self, rhs: f32)
+=
operation. Read moresource§impl AddAssign<f64> for Float
impl AddAssign<f64> for Float
source§fn add_assign(&mut self, rhs: f64)
fn add_assign(&mut self, rhs: f64)
+=
operation. Read moresource§impl AddAssign<i128> for Float
impl AddAssign<i128> for Float
source§fn add_assign(&mut self, rhs: i128)
fn add_assign(&mut self, rhs: i128)
+=
operation. Read moresource§impl AddAssign<i16> for Float
impl AddAssign<i16> for Float
source§fn add_assign(&mut self, rhs: i16)
fn add_assign(&mut self, rhs: i16)
+=
operation. Read moresource§impl AddAssign<i32> for Float
impl AddAssign<i32> for Float
source§fn add_assign(&mut self, rhs: i32)
fn add_assign(&mut self, rhs: i32)
+=
operation. Read moresource§impl AddAssign<i64> for Float
impl AddAssign<i64> for Float
source§fn add_assign(&mut self, rhs: i64)
fn add_assign(&mut self, rhs: i64)
+=
operation. Read moresource§impl AddAssign<i8> for Float
impl AddAssign<i8> for Float
source§fn add_assign(&mut self, rhs: i8)
fn add_assign(&mut self, rhs: i8)
+=
operation. Read moresource§impl AddAssign<isize> for Float
impl AddAssign<isize> for Float
source§fn add_assign(&mut self, rhs: isize)
fn add_assign(&mut self, rhs: isize)
+=
operation. Read moresource§impl AddAssign<u128> for Float
impl AddAssign<u128> for Float
source§fn add_assign(&mut self, rhs: u128)
fn add_assign(&mut self, rhs: u128)
+=
operation. Read moresource§impl AddAssign<u16> for Float
impl AddAssign<u16> for Float
source§fn add_assign(&mut self, rhs: u16)
fn add_assign(&mut self, rhs: u16)
+=
operation. Read moresource§impl AddAssign<u32> for Float
impl AddAssign<u32> for Float
source§fn add_assign(&mut self, rhs: u32)
fn add_assign(&mut self, rhs: u32)
+=
operation. Read moresource§impl AddAssign<u64> for Float
impl AddAssign<u64> for Float
source§fn add_assign(&mut self, rhs: u64)
fn add_assign(&mut self, rhs: u64)
+=
operation. Read moresource§impl AddAssign<u8> for Float
impl AddAssign<u8> for Float
source§fn add_assign(&mut self, rhs: u8)
fn add_assign(&mut self, rhs: u8)
+=
operation. Read moresource§impl AddAssign<usize> for Float
impl AddAssign<usize> for Float
source§fn add_assign(&mut self, rhs: usize)
fn add_assign(&mut self, rhs: usize)
+=
operation. Read moresource§impl AddAssign for Float
impl AddAssign for Float
source§fn add_assign(&mut self, rhs: Float)
fn add_assign(&mut self, rhs: Float)
+=
operation. Read moresource§impl AddAssignRound<&Float> for Complex
impl AddAssignRound<&Float> for Complex
source§impl AddAssignRound<&Float> for Float
impl AddAssignRound<&Float> for Float
source§impl AddAssignRound<&Integer> for Float
impl AddAssignRound<&Integer> for Float
source§impl AddAssignRound<&Rational> for Float
impl AddAssignRound<&Rational> for Float
source§impl AddAssignRound<&f32> for Float
impl AddAssignRound<&f32> for Float
source§impl AddAssignRound<&f64> for Float
impl AddAssignRound<&f64> for Float
source§impl AddAssignRound<&i128> for Float
impl AddAssignRound<&i128> for Float
source§impl AddAssignRound<&i16> for Float
impl AddAssignRound<&i16> for Float
source§impl AddAssignRound<&i32> for Float
impl AddAssignRound<&i32> for Float
source§impl AddAssignRound<&i64> for Float
impl AddAssignRound<&i64> for Float
source§impl AddAssignRound<&i8> for Float
impl AddAssignRound<&i8> for Float
source§impl AddAssignRound<&isize> for Float
impl AddAssignRound<&isize> for Float
source§impl AddAssignRound<&u128> for Float
impl AddAssignRound<&u128> for Float
source§impl AddAssignRound<&u16> for Float
impl AddAssignRound<&u16> for Float
source§impl AddAssignRound<&u32> for Float
impl AddAssignRound<&u32> for Float
source§impl AddAssignRound<&u64> for Float
impl AddAssignRound<&u64> for Float
source§impl AddAssignRound<&u8> for Float
impl AddAssignRound<&u8> for Float
source§impl AddAssignRound<&usize> for Float
impl AddAssignRound<&usize> for Float
source§impl AddAssignRound<Float> for Complex
impl AddAssignRound<Float> for Complex
source§impl AddAssignRound<Integer> for Float
impl AddAssignRound<Integer> for Float
source§impl AddAssignRound<Rational> for Float
impl AddAssignRound<Rational> for Float
source§impl AddAssignRound<f32> for Float
impl AddAssignRound<f32> for Float
source§impl AddAssignRound<f64> for Float
impl AddAssignRound<f64> for Float
source§impl AddAssignRound<i128> for Float
impl AddAssignRound<i128> for Float
source§impl AddAssignRound<i16> for Float
impl AddAssignRound<i16> for Float
source§impl AddAssignRound<i32> for Float
impl AddAssignRound<i32> for Float
source§impl AddAssignRound<i64> for Float
impl AddAssignRound<i64> for Float
source§impl AddAssignRound<i8> for Float
impl AddAssignRound<i8> for Float
source§impl AddAssignRound<isize> for Float
impl AddAssignRound<isize> for Float
source§impl AddAssignRound<u128> for Float
impl AddAssignRound<u128> for Float
source§impl AddAssignRound<u16> for Float
impl AddAssignRound<u16> for Float
source§impl AddAssignRound<u32> for Float
impl AddAssignRound<u32> for Float
source§impl AddAssignRound<u64> for Float
impl AddAssignRound<u64> for Float
source§impl AddAssignRound<u8> for Float
impl AddAssignRound<u8> for Float
source§impl AddAssignRound<usize> for Float
impl AddAssignRound<usize> for Float
source§impl AddAssignRound for Float
impl AddAssignRound for Float
source§impl AddFromRound<&Float> for Complex
impl AddFromRound<&Float> for Complex
source§impl AddFromRound<&Float> for Float
impl AddFromRound<&Float> for Float
source§impl AddFromRound<&Integer> for Float
impl AddFromRound<&Integer> for Float
source§impl AddFromRound<&Rational> for Float
impl AddFromRound<&Rational> for Float
source§impl AddFromRound<&f32> for Float
impl AddFromRound<&f32> for Float
source§impl AddFromRound<&f64> for Float
impl AddFromRound<&f64> for Float
source§impl AddFromRound<&i128> for Float
impl AddFromRound<&i128> for Float
source§impl AddFromRound<&i16> for Float
impl AddFromRound<&i16> for Float
source§impl AddFromRound<&i32> for Float
impl AddFromRound<&i32> for Float
source§impl AddFromRound<&i64> for Float
impl AddFromRound<&i64> for Float
source§impl AddFromRound<&i8> for Float
impl AddFromRound<&i8> for Float
source§impl AddFromRound<&isize> for Float
impl AddFromRound<&isize> for Float
source§impl AddFromRound<&u128> for Float
impl AddFromRound<&u128> for Float
source§impl AddFromRound<&u16> for Float
impl AddFromRound<&u16> for Float
source§impl AddFromRound<&u32> for Float
impl AddFromRound<&u32> for Float
source§impl AddFromRound<&u64> for Float
impl AddFromRound<&u64> for Float
source§impl AddFromRound<&u8> for Float
impl AddFromRound<&u8> for Float
source§impl AddFromRound<&usize> for Float
impl AddFromRound<&usize> for Float
source§impl AddFromRound<Float> for Complex
impl AddFromRound<Float> for Complex
source§impl AddFromRound<Integer> for Float
impl AddFromRound<Integer> for Float
source§impl AddFromRound<Rational> for Float
impl AddFromRound<Rational> for Float
source§impl AddFromRound<f32> for Float
impl AddFromRound<f32> for Float
source§impl AddFromRound<f64> for Float
impl AddFromRound<f64> for Float
source§impl AddFromRound<i128> for Float
impl AddFromRound<i128> for Float
source§impl AddFromRound<i16> for Float
impl AddFromRound<i16> for Float
source§impl AddFromRound<i32> for Float
impl AddFromRound<i32> for Float
source§impl AddFromRound<i64> for Float
impl AddFromRound<i64> for Float
source§impl AddFromRound<i8> for Float
impl AddFromRound<i8> for Float
source§impl AddFromRound<isize> for Float
impl AddFromRound<isize> for Float
source§impl AddFromRound<u128> for Float
impl AddFromRound<u128> for Float
source§impl AddFromRound<u16> for Float
impl AddFromRound<u16> for Float
source§impl AddFromRound<u32> for Float
impl AddFromRound<u32> for Float
source§impl AddFromRound<u64> for Float
impl AddFromRound<u64> for Float
source§impl AddFromRound<u8> for Float
impl AddFromRound<u8> for Float
source§impl AddFromRound<usize> for Float
impl AddFromRound<usize> for Float
source§impl AddFromRound for Float
impl AddFromRound for Float
source§impl AssignRound<&Constant> for Float
impl AssignRound<&Constant> for Float
source§impl AssignRound<&Float> for Float
impl AssignRound<&Float> for Float
source§impl AssignRound<&Integer> for Float
impl AssignRound<&Integer> for Float
source§impl AssignRound<&MiniFloat> for Float
impl AssignRound<&MiniFloat> for Float
source§impl AssignRound<&Rational> for Float
impl AssignRound<&Rational> for Float
source§impl AssignRound<&SmallFloat> for Float
impl AssignRound<&SmallFloat> for Float
source§impl AssignRound<&Special> for Float
impl AssignRound<&Special> for Float
source§impl AssignRound<&bool> for Float
impl AssignRound<&bool> for Float
source§impl AssignRound<&f32> for Float
impl AssignRound<&f32> for Float
source§impl AssignRound<&f64> for Float
impl AssignRound<&f64> for Float
source§impl AssignRound<&i128> for Float
impl AssignRound<&i128> for Float
source§impl AssignRound<&i16> for Float
impl AssignRound<&i16> for Float
source§impl AssignRound<&i32> for Float
impl AssignRound<&i32> for Float
source§impl AssignRound<&i64> for Float
impl AssignRound<&i64> for Float
source§impl AssignRound<&i8> for Float
impl AssignRound<&i8> for Float
source§impl AssignRound<&isize> for Float
impl AssignRound<&isize> for Float
source§impl AssignRound<&u128> for Float
impl AssignRound<&u128> for Float
source§impl AssignRound<&u16> for Float
impl AssignRound<&u16> for Float
source§impl AssignRound<&u32> for Float
impl AssignRound<&u32> for Float
source§impl AssignRound<&u64> for Float
impl AssignRound<&u64> for Float
source§impl AssignRound<&u8> for Float
impl AssignRound<&u8> for Float
source§impl AssignRound<&usize> for Float
impl AssignRound<&usize> for Float
source§impl AssignRound<Constant> for Float
impl AssignRound<Constant> for Float
source§impl AssignRound<Integer> for Float
impl AssignRound<Integer> for Float
source§impl AssignRound<MiniFloat> for Float
impl AssignRound<MiniFloat> for Float
source§impl AssignRound<Rational> for Float
impl AssignRound<Rational> for Float
source§impl AssignRound<SmallFloat> for Float
impl AssignRound<SmallFloat> for Float
source§impl AssignRound<Special> for Float
impl AssignRound<Special> for Float
source§impl AssignRound<bool> for Float
impl AssignRound<bool> for Float
source§impl AssignRound<f32> for Float
impl AssignRound<f32> for Float
source§impl AssignRound<f64> for Float
impl AssignRound<f64> for Float
source§impl AssignRound<i128> for Float
impl AssignRound<i128> for Float
source§impl AssignRound<i16> for Float
impl AssignRound<i16> for Float
source§impl AssignRound<i32> for Float
impl AssignRound<i32> for Float
source§impl AssignRound<i64> for Float
impl AssignRound<i64> for Float
source§impl AssignRound<i8> for Float
impl AssignRound<i8> for Float
source§impl AssignRound<isize> for Float
impl AssignRound<isize> for Float
source§impl AssignRound<u128> for Float
impl AssignRound<u128> for Float
source§impl AssignRound<u16> for Float
impl AssignRound<u16> for Float
source§impl AssignRound<u32> for Float
impl AssignRound<u32> for Float
source§impl AssignRound<u64> for Float
impl AssignRound<u64> for Float
source§impl AssignRound<u8> for Float
impl AssignRound<u8> for Float
source§impl AssignRound<usize> for Float
impl AssignRound<usize> for Float
source§impl AssignRound for Float
impl AssignRound for Float
source§impl CheckedCast<Integer> for &Float
impl CheckedCast<Integer> for &Float
source§fn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
source§impl CheckedCast<Integer> for Float
impl CheckedCast<Integer> for Float
source§fn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
source§impl CheckedCast<Rational> for &Float
impl CheckedCast<Rational> for &Float
source§fn checked_cast(self) -> Option<Rational>
fn checked_cast(self) -> Option<Rational>
source§impl CheckedCast<Rational> for Float
impl CheckedCast<Rational> for Float
source§fn checked_cast(self) -> Option<Rational>
fn checked_cast(self) -> Option<Rational>
source§impl CheckedCast<i128> for &Float
impl CheckedCast<i128> for &Float
source§fn checked_cast(self) -> Option<i128>
fn checked_cast(self) -> Option<i128>
source§impl CheckedCast<i128> for Float
impl CheckedCast<i128> for Float
source§fn checked_cast(self) -> Option<i128>
fn checked_cast(self) -> Option<i128>
source§impl CheckedCast<i16> for &Float
impl CheckedCast<i16> for &Float
source§fn checked_cast(self) -> Option<i16>
fn checked_cast(self) -> Option<i16>
source§impl CheckedCast<i16> for Float
impl CheckedCast<i16> for Float
source§fn checked_cast(self) -> Option<i16>
fn checked_cast(self) -> Option<i16>
source§impl CheckedCast<i32> for &Float
impl CheckedCast<i32> for &Float
source§fn checked_cast(self) -> Option<i32>
fn checked_cast(self) -> Option<i32>
source§impl CheckedCast<i32> for Float
impl CheckedCast<i32> for Float
source§fn checked_cast(self) -> Option<i32>
fn checked_cast(self) -> Option<i32>
source§impl CheckedCast<i64> for &Float
impl CheckedCast<i64> for &Float
source§fn checked_cast(self) -> Option<i64>
fn checked_cast(self) -> Option<i64>
source§impl CheckedCast<i64> for Float
impl CheckedCast<i64> for Float
source§fn checked_cast(self) -> Option<i64>
fn checked_cast(self) -> Option<i64>
source§impl CheckedCast<i8> for &Float
impl CheckedCast<i8> for &Float
source§fn checked_cast(self) -> Option<i8>
fn checked_cast(self) -> Option<i8>
source§impl CheckedCast<i8> for Float
impl CheckedCast<i8> for Float
source§fn checked_cast(self) -> Option<i8>
fn checked_cast(self) -> Option<i8>
source§impl CheckedCast<isize> for &Float
impl CheckedCast<isize> for &Float
source§fn checked_cast(self) -> Option<isize>
fn checked_cast(self) -> Option<isize>
source§impl CheckedCast<isize> for Float
impl CheckedCast<isize> for Float
source§fn checked_cast(self) -> Option<isize>
fn checked_cast(self) -> Option<isize>
source§impl CheckedCast<u128> for &Float
impl CheckedCast<u128> for &Float
source§fn checked_cast(self) -> Option<u128>
fn checked_cast(self) -> Option<u128>
source§impl CheckedCast<u128> for Float
impl CheckedCast<u128> for Float
source§fn checked_cast(self) -> Option<u128>
fn checked_cast(self) -> Option<u128>
source§impl CheckedCast<u16> for &Float
impl CheckedCast<u16> for &Float
source§fn checked_cast(self) -> Option<u16>
fn checked_cast(self) -> Option<u16>
source§impl CheckedCast<u16> for Float
impl CheckedCast<u16> for Float
source§fn checked_cast(self) -> Option<u16>
fn checked_cast(self) -> Option<u16>
source§impl CheckedCast<u32> for &Float
impl CheckedCast<u32> for &Float
source§fn checked_cast(self) -> Option<u32>
fn checked_cast(self) -> Option<u32>
source§impl CheckedCast<u32> for Float
impl CheckedCast<u32> for Float
source§fn checked_cast(self) -> Option<u32>
fn checked_cast(self) -> Option<u32>
source§impl CheckedCast<u64> for &Float
impl CheckedCast<u64> for &Float
source§fn checked_cast(self) -> Option<u64>
fn checked_cast(self) -> Option<u64>
source§impl CheckedCast<u64> for Float
impl CheckedCast<u64> for Float
source§fn checked_cast(self) -> Option<u64>
fn checked_cast(self) -> Option<u64>
source§impl CheckedCast<u8> for &Float
impl CheckedCast<u8> for &Float
source§fn checked_cast(self) -> Option<u8>
fn checked_cast(self) -> Option<u8>
source§impl CheckedCast<u8> for Float
impl CheckedCast<u8> for Float
source§fn checked_cast(self) -> Option<u8>
fn checked_cast(self) -> Option<u8>
source§impl CheckedCast<usize> for &Float
impl CheckedCast<usize> for &Float
source§fn checked_cast(self) -> Option<usize>
fn checked_cast(self) -> Option<usize>
source§impl CheckedCast<usize> for Float
impl CheckedCast<usize> for Float
source§fn checked_cast(self) -> Option<usize>
fn checked_cast(self) -> Option<usize>
source§impl<'de> Deserialize<'de> for Float
impl<'de> Deserialize<'de> for Float
source§fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Float, D::Error>
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Float, D::Error>
source§impl DivAssign<&Float> for Complex
impl DivAssign<&Float> for Complex
source§fn div_assign(&mut self, rhs: &Float)
fn div_assign(&mut self, rhs: &Float)
/=
operation. Read moresource§impl DivAssign<&Float> for Float
impl DivAssign<&Float> for Float
source§fn div_assign(&mut self, rhs: &Float)
fn div_assign(&mut self, rhs: &Float)
/=
operation. Read moresource§impl DivAssign<&Integer> for Float
impl DivAssign<&Integer> for Float
source§fn div_assign(&mut self, rhs: &Integer)
fn div_assign(&mut self, rhs: &Integer)
/=
operation. Read moresource§impl DivAssign<&Rational> for Float
impl DivAssign<&Rational> for Float
source§fn div_assign(&mut self, rhs: &Rational)
fn div_assign(&mut self, rhs: &Rational)
/=
operation. Read moresource§impl DivAssign<&f32> for Float
impl DivAssign<&f32> for Float
source§fn div_assign(&mut self, rhs: &f32)
fn div_assign(&mut self, rhs: &f32)
/=
operation. Read moresource§impl DivAssign<&f64> for Float
impl DivAssign<&f64> for Float
source§fn div_assign(&mut self, rhs: &f64)
fn div_assign(&mut self, rhs: &f64)
/=
operation. Read moresource§impl DivAssign<&i128> for Float
impl DivAssign<&i128> for Float
source§fn div_assign(&mut self, rhs: &i128)
fn div_assign(&mut self, rhs: &i128)
/=
operation. Read moresource§impl DivAssign<&i16> for Float
impl DivAssign<&i16> for Float
source§fn div_assign(&mut self, rhs: &i16)
fn div_assign(&mut self, rhs: &i16)
/=
operation. Read moresource§impl DivAssign<&i32> for Float
impl DivAssign<&i32> for Float
source§fn div_assign(&mut self, rhs: &i32)
fn div_assign(&mut self, rhs: &i32)
/=
operation. Read moresource§impl DivAssign<&i64> for Float
impl DivAssign<&i64> for Float
source§fn div_assign(&mut self, rhs: &i64)
fn div_assign(&mut self, rhs: &i64)
/=
operation. Read moresource§impl DivAssign<&i8> for Float
impl DivAssign<&i8> for Float
source§fn div_assign(&mut self, rhs: &i8)
fn div_assign(&mut self, rhs: &i8)
/=
operation. Read moresource§impl DivAssign<&isize> for Float
impl DivAssign<&isize> for Float
source§fn div_assign(&mut self, rhs: &isize)
fn div_assign(&mut self, rhs: &isize)
/=
operation. Read moresource§impl DivAssign<&u128> for Float
impl DivAssign<&u128> for Float
source§fn div_assign(&mut self, rhs: &u128)
fn div_assign(&mut self, rhs: &u128)
/=
operation. Read moresource§impl DivAssign<&u16> for Float
impl DivAssign<&u16> for Float
source§fn div_assign(&mut self, rhs: &u16)
fn div_assign(&mut self, rhs: &u16)
/=
operation. Read moresource§impl DivAssign<&u32> for Float
impl DivAssign<&u32> for Float
source§fn div_assign(&mut self, rhs: &u32)
fn div_assign(&mut self, rhs: &u32)
/=
operation. Read moresource§impl DivAssign<&u64> for Float
impl DivAssign<&u64> for Float
source§fn div_assign(&mut self, rhs: &u64)
fn div_assign(&mut self, rhs: &u64)
/=
operation. Read moresource§impl DivAssign<&u8> for Float
impl DivAssign<&u8> for Float
source§fn div_assign(&mut self, rhs: &u8)
fn div_assign(&mut self, rhs: &u8)
/=
operation. Read moresource§impl DivAssign<&usize> for Float
impl DivAssign<&usize> for Float
source§fn div_assign(&mut self, rhs: &usize)
fn div_assign(&mut self, rhs: &usize)
/=
operation. Read moresource§impl DivAssign<Float> for Complex
impl DivAssign<Float> for Complex
source§fn div_assign(&mut self, rhs: Float)
fn div_assign(&mut self, rhs: Float)
/=
operation. Read moresource§impl DivAssign<Integer> for Float
impl DivAssign<Integer> for Float
source§fn div_assign(&mut self, rhs: Integer)
fn div_assign(&mut self, rhs: Integer)
/=
operation. Read moresource§impl DivAssign<Rational> for Float
impl DivAssign<Rational> for Float
source§fn div_assign(&mut self, rhs: Rational)
fn div_assign(&mut self, rhs: Rational)
/=
operation. Read moresource§impl DivAssign<f32> for Float
impl DivAssign<f32> for Float
source§fn div_assign(&mut self, rhs: f32)
fn div_assign(&mut self, rhs: f32)
/=
operation. Read moresource§impl DivAssign<f64> for Float
impl DivAssign<f64> for Float
source§fn div_assign(&mut self, rhs: f64)
fn div_assign(&mut self, rhs: f64)
/=
operation. Read moresource§impl DivAssign<i128> for Float
impl DivAssign<i128> for Float
source§fn div_assign(&mut self, rhs: i128)
fn div_assign(&mut self, rhs: i128)
/=
operation. Read moresource§impl DivAssign<i16> for Float
impl DivAssign<i16> for Float
source§fn div_assign(&mut self, rhs: i16)
fn div_assign(&mut self, rhs: i16)
/=
operation. Read moresource§impl DivAssign<i32> for Float
impl DivAssign<i32> for Float
source§fn div_assign(&mut self, rhs: i32)
fn div_assign(&mut self, rhs: i32)
/=
operation. Read moresource§impl DivAssign<i64> for Float
impl DivAssign<i64> for Float
source§fn div_assign(&mut self, rhs: i64)
fn div_assign(&mut self, rhs: i64)
/=
operation. Read moresource§impl DivAssign<i8> for Float
impl DivAssign<i8> for Float
source§fn div_assign(&mut self, rhs: i8)
fn div_assign(&mut self, rhs: i8)
/=
operation. Read moresource§impl DivAssign<isize> for Float
impl DivAssign<isize> for Float
source§fn div_assign(&mut self, rhs: isize)
fn div_assign(&mut self, rhs: isize)
/=
operation. Read moresource§impl DivAssign<u128> for Float
impl DivAssign<u128> for Float
source§fn div_assign(&mut self, rhs: u128)
fn div_assign(&mut self, rhs: u128)
/=
operation. Read moresource§impl DivAssign<u16> for Float
impl DivAssign<u16> for Float
source§fn div_assign(&mut self, rhs: u16)
fn div_assign(&mut self, rhs: u16)
/=
operation. Read moresource§impl DivAssign<u32> for Float
impl DivAssign<u32> for Float
source§fn div_assign(&mut self, rhs: u32)
fn div_assign(&mut self, rhs: u32)
/=
operation. Read moresource§impl DivAssign<u64> for Float
impl DivAssign<u64> for Float
source§fn div_assign(&mut self, rhs: u64)
fn div_assign(&mut self, rhs: u64)
/=
operation. Read moresource§impl DivAssign<u8> for Float
impl DivAssign<u8> for Float
source§fn div_assign(&mut self, rhs: u8)
fn div_assign(&mut self, rhs: u8)
/=
operation. Read moresource§impl DivAssign<usize> for Float
impl DivAssign<usize> for Float
source§fn div_assign(&mut self, rhs: usize)
fn div_assign(&mut self, rhs: usize)
/=
operation. Read moresource§impl DivAssign for Float
impl DivAssign for Float
source§fn div_assign(&mut self, rhs: Float)
fn div_assign(&mut self, rhs: Float)
/=
operation. Read moresource§impl DivAssignRound<&Float> for Complex
impl DivAssignRound<&Float> for Complex
source§impl DivAssignRound<&Float> for Float
impl DivAssignRound<&Float> for Float
source§impl DivAssignRound<&Integer> for Float
impl DivAssignRound<&Integer> for Float
source§impl DivAssignRound<&Rational> for Float
impl DivAssignRound<&Rational> for Float
source§impl DivAssignRound<&f32> for Float
impl DivAssignRound<&f32> for Float
source§impl DivAssignRound<&f64> for Float
impl DivAssignRound<&f64> for Float
source§impl DivAssignRound<&i128> for Float
impl DivAssignRound<&i128> for Float
source§impl DivAssignRound<&i16> for Float
impl DivAssignRound<&i16> for Float
source§impl DivAssignRound<&i32> for Float
impl DivAssignRound<&i32> for Float
source§impl DivAssignRound<&i64> for Float
impl DivAssignRound<&i64> for Float
source§impl DivAssignRound<&i8> for Float
impl DivAssignRound<&i8> for Float
source§impl DivAssignRound<&isize> for Float
impl DivAssignRound<&isize> for Float
source§impl DivAssignRound<&u128> for Float
impl DivAssignRound<&u128> for Float
source§impl DivAssignRound<&u16> for Float
impl DivAssignRound<&u16> for Float
source§impl DivAssignRound<&u32> for Float
impl DivAssignRound<&u32> for Float
source§impl DivAssignRound<&u64> for Float
impl DivAssignRound<&u64> for Float
source§impl DivAssignRound<&u8> for Float
impl DivAssignRound<&u8> for Float
source§impl DivAssignRound<&usize> for Float
impl DivAssignRound<&usize> for Float
source§impl DivAssignRound<Float> for Complex
impl DivAssignRound<Float> for Complex
source§impl DivAssignRound<Integer> for Float
impl DivAssignRound<Integer> for Float
source§impl DivAssignRound<Rational> for Float
impl DivAssignRound<Rational> for Float
source§impl DivAssignRound<f32> for Float
impl DivAssignRound<f32> for Float
source§impl DivAssignRound<f64> for Float
impl DivAssignRound<f64> for Float
source§impl DivAssignRound<i128> for Float
impl DivAssignRound<i128> for Float
source§impl DivAssignRound<i16> for Float
impl DivAssignRound<i16> for Float
source§impl DivAssignRound<i32> for Float
impl DivAssignRound<i32> for Float
source§impl DivAssignRound<i64> for Float
impl DivAssignRound<i64> for Float
source§impl DivAssignRound<i8> for Float
impl DivAssignRound<i8> for Float
source§impl DivAssignRound<isize> for Float
impl DivAssignRound<isize> for Float
source§impl DivAssignRound<u128> for Float
impl DivAssignRound<u128> for Float
source§impl DivAssignRound<u16> for Float
impl DivAssignRound<u16> for Float
source§impl DivAssignRound<u32> for Float
impl DivAssignRound<u32> for Float
source§impl DivAssignRound<u64> for Float
impl DivAssignRound<u64> for Float
source§impl DivAssignRound<u8> for Float
impl DivAssignRound<u8> for Float
source§impl DivAssignRound<usize> for Float
impl DivAssignRound<usize> for Float
source§impl DivAssignRound for Float
impl DivAssignRound for Float
source§impl DivFromRound<&Float> for Complex
impl DivFromRound<&Float> for Complex
source§impl DivFromRound<&Float> for Float
impl DivFromRound<&Float> for Float
source§impl DivFromRound<&Integer> for Float
impl DivFromRound<&Integer> for Float
source§impl DivFromRound<&Rational> for Float
impl DivFromRound<&Rational> for Float
source§impl DivFromRound<&f32> for Float
impl DivFromRound<&f32> for Float
source§impl DivFromRound<&f64> for Float
impl DivFromRound<&f64> for Float
source§impl DivFromRound<&i128> for Float
impl DivFromRound<&i128> for Float
source§impl DivFromRound<&i16> for Float
impl DivFromRound<&i16> for Float
source§impl DivFromRound<&i32> for Float
impl DivFromRound<&i32> for Float
source§impl DivFromRound<&i64> for Float
impl DivFromRound<&i64> for Float
source§impl DivFromRound<&i8> for Float
impl DivFromRound<&i8> for Float
source§impl DivFromRound<&isize> for Float
impl DivFromRound<&isize> for Float
source§impl DivFromRound<&u128> for Float
impl DivFromRound<&u128> for Float
source§impl DivFromRound<&u16> for Float
impl DivFromRound<&u16> for Float
source§impl DivFromRound<&u32> for Float
impl DivFromRound<&u32> for Float
source§impl DivFromRound<&u64> for Float
impl DivFromRound<&u64> for Float
source§impl DivFromRound<&u8> for Float
impl DivFromRound<&u8> for Float
source§impl DivFromRound<&usize> for Float
impl DivFromRound<&usize> for Float
source§impl DivFromRound<Float> for Complex
impl DivFromRound<Float> for Complex
source§impl DivFromRound<Integer> for Float
impl DivFromRound<Integer> for Float
source§impl DivFromRound<Rational> for Float
impl DivFromRound<Rational> for Float
source§impl DivFromRound<f32> for Float
impl DivFromRound<f32> for Float
source§impl DivFromRound<f64> for Float
impl DivFromRound<f64> for Float
source§impl DivFromRound<i128> for Float
impl DivFromRound<i128> for Float
source§impl DivFromRound<i16> for Float
impl DivFromRound<i16> for Float
source§impl DivFromRound<i32> for Float
impl DivFromRound<i32> for Float
source§impl DivFromRound<i64> for Float
impl DivFromRound<i64> for Float
source§impl DivFromRound<i8> for Float
impl DivFromRound<i8> for Float
source§impl DivFromRound<isize> for Float
impl DivFromRound<isize> for Float
source§impl DivFromRound<u128> for Float
impl DivFromRound<u128> for Float
source§impl DivFromRound<u16> for Float
impl DivFromRound<u16> for Float
source§impl DivFromRound<u32> for Float
impl DivFromRound<u32> for Float
source§impl DivFromRound<u64> for Float
impl DivFromRound<u64> for Float
source§impl DivFromRound<u8> for Float
impl DivFromRound<u8> for Float
source§impl DivFromRound<usize> for Float
impl DivFromRound<usize> for Float
source§impl DivFromRound for Float
impl DivFromRound for Float
source§impl MulAddAssign<&Float, &Float> for Float
impl MulAddAssign<&Float, &Float> for Float
source§fn mul_add_assign(&mut self, a: &Float, b: &Float)
fn mul_add_assign(&mut self, a: &Float, b: &Float)
*self = (*self * a) + b
source§impl MulAddAssign for Float
impl MulAddAssign for Float
source§fn mul_add_assign(&mut self, a: Float, b: Float)
fn mul_add_assign(&mut self, a: Float, b: Float)
*self = (*self * a) + b
source§impl MulAssign<&Float> for Complex
impl MulAssign<&Float> for Complex
source§fn mul_assign(&mut self, rhs: &Float)
fn mul_assign(&mut self, rhs: &Float)
*=
operation. Read moresource§impl MulAssign<&Float> for Float
impl MulAssign<&Float> for Float
source§fn mul_assign(&mut self, rhs: &Float)
fn mul_assign(&mut self, rhs: &Float)
*=
operation. Read moresource§impl MulAssign<&Integer> for Float
impl MulAssign<&Integer> for Float
source§fn mul_assign(&mut self, rhs: &Integer)
fn mul_assign(&mut self, rhs: &Integer)
*=
operation. Read moresource§impl MulAssign<&Rational> for Float
impl MulAssign<&Rational> for Float
source§fn mul_assign(&mut self, rhs: &Rational)
fn mul_assign(&mut self, rhs: &Rational)
*=
operation. Read moresource§impl MulAssign<&f32> for Float
impl MulAssign<&f32> for Float
source§fn mul_assign(&mut self, rhs: &f32)
fn mul_assign(&mut self, rhs: &f32)
*=
operation. Read moresource§impl MulAssign<&f64> for Float
impl MulAssign<&f64> for Float
source§fn mul_assign(&mut self, rhs: &f64)
fn mul_assign(&mut self, rhs: &f64)
*=
operation. Read moresource§impl MulAssign<&i128> for Float
impl MulAssign<&i128> for Float
source§fn mul_assign(&mut self, rhs: &i128)
fn mul_assign(&mut self, rhs: &i128)
*=
operation. Read moresource§impl MulAssign<&i16> for Float
impl MulAssign<&i16> for Float
source§fn mul_assign(&mut self, rhs: &i16)
fn mul_assign(&mut self, rhs: &i16)
*=
operation. Read moresource§impl MulAssign<&i32> for Float
impl MulAssign<&i32> for Float
source§fn mul_assign(&mut self, rhs: &i32)
fn mul_assign(&mut self, rhs: &i32)
*=
operation. Read moresource§impl MulAssign<&i64> for Float
impl MulAssign<&i64> for Float
source§fn mul_assign(&mut self, rhs: &i64)
fn mul_assign(&mut self, rhs: &i64)
*=
operation. Read moresource§impl MulAssign<&i8> for Float
impl MulAssign<&i8> for Float
source§fn mul_assign(&mut self, rhs: &i8)
fn mul_assign(&mut self, rhs: &i8)
*=
operation. Read moresource§impl MulAssign<&isize> for Float
impl MulAssign<&isize> for Float
source§fn mul_assign(&mut self, rhs: &isize)
fn mul_assign(&mut self, rhs: &isize)
*=
operation. Read moresource§impl MulAssign<&u128> for Float
impl MulAssign<&u128> for Float
source§fn mul_assign(&mut self, rhs: &u128)
fn mul_assign(&mut self, rhs: &u128)
*=
operation. Read moresource§impl MulAssign<&u16> for Float
impl MulAssign<&u16> for Float
source§fn mul_assign(&mut self, rhs: &u16)
fn mul_assign(&mut self, rhs: &u16)
*=
operation. Read moresource§impl MulAssign<&u32> for Float
impl MulAssign<&u32> for Float
source§fn mul_assign(&mut self, rhs: &u32)
fn mul_assign(&mut self, rhs: &u32)
*=
operation. Read moresource§impl MulAssign<&u64> for Float
impl MulAssign<&u64> for Float
source§fn mul_assign(&mut self, rhs: &u64)
fn mul_assign(&mut self, rhs: &u64)
*=
operation. Read moresource§impl MulAssign<&u8> for Float
impl MulAssign<&u8> for Float
source§fn mul_assign(&mut self, rhs: &u8)
fn mul_assign(&mut self, rhs: &u8)
*=
operation. Read moresource§impl MulAssign<&usize> for Float
impl MulAssign<&usize> for Float
source§fn mul_assign(&mut self, rhs: &usize)
fn mul_assign(&mut self, rhs: &usize)
*=
operation. Read moresource§impl MulAssign<Float> for Complex
impl MulAssign<Float> for Complex
source§fn mul_assign(&mut self, rhs: Float)
fn mul_assign(&mut self, rhs: Float)
*=
operation. Read moresource§impl MulAssign<Integer> for Float
impl MulAssign<Integer> for Float
source§fn mul_assign(&mut self, rhs: Integer)
fn mul_assign(&mut self, rhs: Integer)
*=
operation. Read moresource§impl MulAssign<Rational> for Float
impl MulAssign<Rational> for Float
source§fn mul_assign(&mut self, rhs: Rational)
fn mul_assign(&mut self, rhs: Rational)
*=
operation. Read moresource§impl MulAssign<f32> for Float
impl MulAssign<f32> for Float
source§fn mul_assign(&mut self, rhs: f32)
fn mul_assign(&mut self, rhs: f32)
*=
operation. Read moresource§impl MulAssign<f64> for Float
impl MulAssign<f64> for Float
source§fn mul_assign(&mut self, rhs: f64)
fn mul_assign(&mut self, rhs: f64)
*=
operation. Read moresource§impl MulAssign<i128> for Float
impl MulAssign<i128> for Float
source§fn mul_assign(&mut self, rhs: i128)
fn mul_assign(&mut self, rhs: i128)
*=
operation. Read moresource§impl MulAssign<i16> for Float
impl MulAssign<i16> for Float
source§fn mul_assign(&mut self, rhs: i16)
fn mul_assign(&mut self, rhs: i16)
*=
operation. Read moresource§impl MulAssign<i32> for Float
impl MulAssign<i32> for Float
source§fn mul_assign(&mut self, rhs: i32)
fn mul_assign(&mut self, rhs: i32)
*=
operation. Read moresource§impl MulAssign<i64> for Float
impl MulAssign<i64> for Float
source§fn mul_assign(&mut self, rhs: i64)
fn mul_assign(&mut self, rhs: i64)
*=
operation. Read moresource§impl MulAssign<i8> for Float
impl MulAssign<i8> for Float
source§fn mul_assign(&mut self, rhs: i8)
fn mul_assign(&mut self, rhs: i8)
*=
operation. Read moresource§impl MulAssign<isize> for Float
impl MulAssign<isize> for Float
source§fn mul_assign(&mut self, rhs: isize)
fn mul_assign(&mut self, rhs: isize)
*=
operation. Read moresource§impl MulAssign<u128> for Float
impl MulAssign<u128> for Float
source§fn mul_assign(&mut self, rhs: u128)
fn mul_assign(&mut self, rhs: u128)
*=
operation. Read moresource§impl MulAssign<u16> for Float
impl MulAssign<u16> for Float
source§fn mul_assign(&mut self, rhs: u16)
fn mul_assign(&mut self, rhs: u16)
*=
operation. Read moresource§impl MulAssign<u32> for Float
impl MulAssign<u32> for Float
source§fn mul_assign(&mut self, rhs: u32)
fn mul_assign(&mut self, rhs: u32)
*=
operation. Read moresource§impl MulAssign<u64> for Float
impl MulAssign<u64> for Float
source§fn mul_assign(&mut self, rhs: u64)
fn mul_assign(&mut self, rhs: u64)
*=
operation. Read moresource§impl MulAssign<u8> for Float
impl MulAssign<u8> for Float
source§fn mul_assign(&mut self, rhs: u8)
fn mul_assign(&mut self, rhs: u8)
*=
operation. Read moresource§impl MulAssign<usize> for Float
impl MulAssign<usize> for Float
source§fn mul_assign(&mut self, rhs: usize)
fn mul_assign(&mut self, rhs: usize)
*=
operation. Read moresource§impl MulAssign for Float
impl MulAssign for Float
source§fn mul_assign(&mut self, rhs: Float)
fn mul_assign(&mut self, rhs: Float)
*=
operation. Read moresource§impl MulAssignRound<&Float> for Complex
impl MulAssignRound<&Float> for Complex
source§impl MulAssignRound<&Float> for Float
impl MulAssignRound<&Float> for Float
source§impl MulAssignRound<&Integer> for Float
impl MulAssignRound<&Integer> for Float
source§impl MulAssignRound<&Rational> for Float
impl MulAssignRound<&Rational> for Float
source§impl MulAssignRound<&f32> for Float
impl MulAssignRound<&f32> for Float
source§impl MulAssignRound<&f64> for Float
impl MulAssignRound<&f64> for Float
source§impl MulAssignRound<&i128> for Float
impl MulAssignRound<&i128> for Float
source§impl MulAssignRound<&i16> for Float
impl MulAssignRound<&i16> for Float
source§impl MulAssignRound<&i32> for Float
impl MulAssignRound<&i32> for Float
source§impl MulAssignRound<&i64> for Float
impl MulAssignRound<&i64> for Float
source§impl MulAssignRound<&i8> for Float
impl MulAssignRound<&i8> for Float
source§impl MulAssignRound<&isize> for Float
impl MulAssignRound<&isize> for Float
source§impl MulAssignRound<&u128> for Float
impl MulAssignRound<&u128> for Float
source§impl MulAssignRound<&u16> for Float
impl MulAssignRound<&u16> for Float
source§impl MulAssignRound<&u32> for Float
impl MulAssignRound<&u32> for Float
source§impl MulAssignRound<&u64> for Float
impl MulAssignRound<&u64> for Float
source§impl MulAssignRound<&u8> for Float
impl MulAssignRound<&u8> for Float
source§impl MulAssignRound<&usize> for Float
impl MulAssignRound<&usize> for Float
source§impl MulAssignRound<Float> for Complex
impl MulAssignRound<Float> for Complex
source§impl MulAssignRound<Integer> for Float
impl MulAssignRound<Integer> for Float
source§impl MulAssignRound<Rational> for Float
impl MulAssignRound<Rational> for Float
source§impl MulAssignRound<f32> for Float
impl MulAssignRound<f32> for Float
source§impl MulAssignRound<f64> for Float
impl MulAssignRound<f64> for Float
source§impl MulAssignRound<i128> for Float
impl MulAssignRound<i128> for Float
source§impl MulAssignRound<i16> for Float
impl MulAssignRound<i16> for Float
source§impl MulAssignRound<i32> for Float
impl MulAssignRound<i32> for Float
source§impl MulAssignRound<i64> for Float
impl MulAssignRound<i64> for Float
source§impl MulAssignRound<i8> for Float
impl MulAssignRound<i8> for Float
source§impl MulAssignRound<isize> for Float
impl MulAssignRound<isize> for Float
source§impl MulAssignRound<u128> for Float
impl MulAssignRound<u128> for Float
source§impl MulAssignRound<u16> for Float
impl MulAssignRound<u16> for Float
source§impl MulAssignRound<u32> for Float
impl MulAssignRound<u32> for Float
source§impl MulAssignRound<u64> for Float
impl MulAssignRound<u64> for Float
source§impl MulAssignRound<u8> for Float
impl MulAssignRound<u8> for Float
source§impl MulAssignRound<usize> for Float
impl MulAssignRound<usize> for Float
source§impl MulAssignRound for Float
impl MulAssignRound for Float
source§impl MulFromRound<&Float> for Complex
impl MulFromRound<&Float> for Complex
source§impl MulFromRound<&Float> for Float
impl MulFromRound<&Float> for Float
source§impl MulFromRound<&Integer> for Float
impl MulFromRound<&Integer> for Float
source§impl MulFromRound<&Rational> for Float
impl MulFromRound<&Rational> for Float
source§impl MulFromRound<&f32> for Float
impl MulFromRound<&f32> for Float
source§impl MulFromRound<&f64> for Float
impl MulFromRound<&f64> for Float
source§impl MulFromRound<&i128> for Float
impl MulFromRound<&i128> for Float
source§impl MulFromRound<&i16> for Float
impl MulFromRound<&i16> for Float
source§impl MulFromRound<&i32> for Float
impl MulFromRound<&i32> for Float
source§impl MulFromRound<&i64> for Float
impl MulFromRound<&i64> for Float
source§impl MulFromRound<&i8> for Float
impl MulFromRound<&i8> for Float
source§impl MulFromRound<&isize> for Float
impl MulFromRound<&isize> for Float
source§impl MulFromRound<&u128> for Float
impl MulFromRound<&u128> for Float
source§impl MulFromRound<&u16> for Float
impl MulFromRound<&u16> for Float
source§impl MulFromRound<&u32> for Float
impl MulFromRound<&u32> for Float
source§impl MulFromRound<&u64> for Float
impl MulFromRound<&u64> for Float
source§impl MulFromRound<&u8> for Float
impl MulFromRound<&u8> for Float
source§impl MulFromRound<&usize> for Float
impl MulFromRound<&usize> for Float
source§impl MulFromRound<Float> for Complex
impl MulFromRound<Float> for Complex
source§impl MulFromRound<Integer> for Float
impl MulFromRound<Integer> for Float
source§impl MulFromRound<Rational> for Float
impl MulFromRound<Rational> for Float
source§impl MulFromRound<f32> for Float
impl MulFromRound<f32> for Float
source§impl MulFromRound<f64> for Float
impl MulFromRound<f64> for Float
source§impl MulFromRound<i128> for Float
impl MulFromRound<i128> for Float
source§impl MulFromRound<i16> for Float
impl MulFromRound<i16> for Float
source§impl MulFromRound<i32> for Float
impl MulFromRound<i32> for Float
source§impl MulFromRound<i64> for Float
impl MulFromRound<i64> for Float
source§impl MulFromRound<i8> for Float
impl MulFromRound<i8> for Float
source§impl MulFromRound<isize> for Float
impl MulFromRound<isize> for Float
source§impl MulFromRound<u128> for Float
impl MulFromRound<u128> for Float
source§impl MulFromRound<u16> for Float
impl MulFromRound<u16> for Float
source§impl MulFromRound<u32> for Float
impl MulFromRound<u32> for Float
source§impl MulFromRound<u64> for Float
impl MulFromRound<u64> for Float
source§impl MulFromRound<u8> for Float
impl MulFromRound<u8> for Float
source§impl MulFromRound<usize> for Float
impl MulFromRound<usize> for Float
source§impl MulFromRound for Float
impl MulFromRound for Float
source§impl PartialEq<Complex> for Float
impl PartialEq<Complex> for Float
source§impl PartialEq<Float> for Complex
impl PartialEq<Float> for Complex
source§impl PartialEq<Float> for Integer
impl PartialEq<Float> for Integer
source§impl PartialEq<Float> for MiniFloat
impl PartialEq<Float> for MiniFloat
source§impl PartialEq<Float> for Rational
impl PartialEq<Float> for Rational
source§impl PartialEq<Float> for SmallFloat
impl PartialEq<Float> for SmallFloat
source§impl PartialEq<Float> for Special
impl PartialEq<Float> for Special
source§impl PartialEq<Float> for f32
impl PartialEq<Float> for f32
source§impl PartialEq<Float> for f64
impl PartialEq<Float> for f64
source§impl PartialEq<Float> for i128
impl PartialEq<Float> for i128
source§impl PartialEq<Float> for i16
impl PartialEq<Float> for i16
source§impl PartialEq<Float> for i32
impl PartialEq<Float> for i32
source§impl PartialEq<Float> for i64
impl PartialEq<Float> for i64
source§impl PartialEq<Float> for i8
impl PartialEq<Float> for i8
source§impl PartialEq<Float> for isize
impl PartialEq<Float> for isize
source§impl PartialEq<Float> for u128
impl PartialEq<Float> for u128
source§impl PartialEq<Float> for u16
impl PartialEq<Float> for u16
source§impl PartialEq<Float> for u32
impl PartialEq<Float> for u32
source§impl PartialEq<Float> for u64
impl PartialEq<Float> for u64
source§impl PartialEq<Float> for u8
impl PartialEq<Float> for u8
source§impl PartialEq<Float> for usize
impl PartialEq<Float> for usize
source§impl PartialEq<Integer> for Float
impl PartialEq<Integer> for Float
source§impl PartialEq<MiniFloat> for Float
impl PartialEq<MiniFloat> for Float
source§impl PartialEq<Rational> for Float
impl PartialEq<Rational> for Float
source§impl PartialEq<SmallFloat> for Float
impl PartialEq<SmallFloat> for Float
source§fn eq(&self, other: &SmallFloat) -> bool
fn eq(&self, other: &SmallFloat) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialEq<Special> for Float
impl PartialEq<Special> for Float
source§impl PartialEq<i128> for Float
impl PartialEq<i128> for Float
source§impl PartialEq<isize> for Float
impl PartialEq<isize> for Float
source§impl PartialEq<u128> for Float
impl PartialEq<u128> for Float
source§impl PartialEq<usize> for Float
impl PartialEq<usize> for Float
source§impl PartialEq for Float
impl PartialEq for Float
source§impl PartialOrd<Float> for Integer
impl PartialOrd<Float> for Integer
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for MiniFloat
impl PartialOrd<Float> for MiniFloat
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for Rational
impl PartialOrd<Float> for Rational
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for SmallFloat
impl PartialOrd<Float> for SmallFloat
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for Special
impl PartialOrd<Float> for Special
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for f32
impl PartialOrd<Float> for f32
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for f64
impl PartialOrd<Float> for f64
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for i128
impl PartialOrd<Float> for i128
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for i16
impl PartialOrd<Float> for i16
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for i32
impl PartialOrd<Float> for i32
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for i64
impl PartialOrd<Float> for i64
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for i8
impl PartialOrd<Float> for i8
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for isize
impl PartialOrd<Float> for isize
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for u128
impl PartialOrd<Float> for u128
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for u16
impl PartialOrd<Float> for u16
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for u32
impl PartialOrd<Float> for u32
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for u64
impl PartialOrd<Float> for u64
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for u8
impl PartialOrd<Float> for u8
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Float> for usize
impl PartialOrd<Float> for usize
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Integer> for Float
impl PartialOrd<Integer> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<MiniFloat> for Float
impl PartialOrd<MiniFloat> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Rational> for Float
impl PartialOrd<Rational> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<SmallFloat> for Float
impl PartialOrd<SmallFloat> for Float
source§fn partial_cmp(&self, other: &SmallFloat) -> Option<Ordering>
fn partial_cmp(&self, other: &SmallFloat) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Special> for Float
impl PartialOrd<Special> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<f32> for Float
impl PartialOrd<f32> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<f64> for Float
impl PartialOrd<f64> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<i128> for Float
impl PartialOrd<i128> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<i16> for Float
impl PartialOrd<i16> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<i32> for Float
impl PartialOrd<i32> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<i64> for Float
impl PartialOrd<i64> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<i8> for Float
impl PartialOrd<i8> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<isize> for Float
impl PartialOrd<isize> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<u128> for Float
impl PartialOrd<u128> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<u16> for Float
impl PartialOrd<u16> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<u32> for Float
impl PartialOrd<u32> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<u64> for Float
impl PartialOrd<u64> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<u8> for Float
impl PartialOrd<u8> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<usize> for Float
impl PartialOrd<usize> for Float
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd for Float
impl PartialOrd for Float
source§impl PowAssign<&Float> for Complex
impl PowAssign<&Float> for Complex
source§fn pow_assign(&mut self, rhs: &Float)
fn pow_assign(&mut self, rhs: &Float)
source§impl PowAssign<&Float> for Float
impl PowAssign<&Float> for Float
source§fn pow_assign(&mut self, rhs: &Float)
fn pow_assign(&mut self, rhs: &Float)
source§impl PowAssign<&Integer> for Float
impl PowAssign<&Integer> for Float
source§fn pow_assign(&mut self, rhs: &Integer)
fn pow_assign(&mut self, rhs: &Integer)
source§impl PowAssign<&f32> for Float
impl PowAssign<&f32> for Float
source§fn pow_assign(&mut self, rhs: &f32)
fn pow_assign(&mut self, rhs: &f32)
source§impl PowAssign<&f64> for Float
impl PowAssign<&f64> for Float
source§fn pow_assign(&mut self, rhs: &f64)
fn pow_assign(&mut self, rhs: &f64)
source§impl PowAssign<&i128> for Float
impl PowAssign<&i128> for Float
source§fn pow_assign(&mut self, rhs: &i128)
fn pow_assign(&mut self, rhs: &i128)
source§impl PowAssign<&i16> for Float
impl PowAssign<&i16> for Float
source§fn pow_assign(&mut self, rhs: &i16)
fn pow_assign(&mut self, rhs: &i16)
source§impl PowAssign<&i32> for Float
impl PowAssign<&i32> for Float
source§fn pow_assign(&mut self, rhs: &i32)
fn pow_assign(&mut self, rhs: &i32)
source§impl PowAssign<&i64> for Float
impl PowAssign<&i64> for Float
source§fn pow_assign(&mut self, rhs: &i64)
fn pow_assign(&mut self, rhs: &i64)
source§impl PowAssign<&i8> for Float
impl PowAssign<&i8> for Float
source§fn pow_assign(&mut self, rhs: &i8)
fn pow_assign(&mut self, rhs: &i8)
source§impl PowAssign<&isize> for Float
impl PowAssign<&isize> for Float
source§fn pow_assign(&mut self, rhs: &isize)
fn pow_assign(&mut self, rhs: &isize)
source§impl PowAssign<&u128> for Float
impl PowAssign<&u128> for Float
source§fn pow_assign(&mut self, rhs: &u128)
fn pow_assign(&mut self, rhs: &u128)
source§impl PowAssign<&u16> for Float
impl PowAssign<&u16> for Float
source§fn pow_assign(&mut self, rhs: &u16)
fn pow_assign(&mut self, rhs: &u16)
source§impl PowAssign<&u32> for Float
impl PowAssign<&u32> for Float
source§fn pow_assign(&mut self, rhs: &u32)
fn pow_assign(&mut self, rhs: &u32)
source§impl PowAssign<&u64> for Float
impl PowAssign<&u64> for Float
source§fn pow_assign(&mut self, rhs: &u64)
fn pow_assign(&mut self, rhs: &u64)
source§impl PowAssign<&u8> for Float
impl PowAssign<&u8> for Float
source§fn pow_assign(&mut self, rhs: &u8)
fn pow_assign(&mut self, rhs: &u8)
source§impl PowAssign<&usize> for Float
impl PowAssign<&usize> for Float
source§fn pow_assign(&mut self, rhs: &usize)
fn pow_assign(&mut self, rhs: &usize)
source§impl PowAssign<Float> for Complex
impl PowAssign<Float> for Complex
source§fn pow_assign(&mut self, rhs: Float)
fn pow_assign(&mut self, rhs: Float)
source§impl PowAssign<Float> for Float
impl PowAssign<Float> for Float
source§fn pow_assign(&mut self, rhs: Float)
fn pow_assign(&mut self, rhs: Float)
source§impl PowAssign<Integer> for Float
impl PowAssign<Integer> for Float
source§fn pow_assign(&mut self, rhs: Integer)
fn pow_assign(&mut self, rhs: Integer)
source§impl PowAssign<f32> for Float
impl PowAssign<f32> for Float
source§fn pow_assign(&mut self, rhs: f32)
fn pow_assign(&mut self, rhs: f32)
source§impl PowAssign<f64> for Float
impl PowAssign<f64> for Float
source§fn pow_assign(&mut self, rhs: f64)
fn pow_assign(&mut self, rhs: f64)
source§impl PowAssign<i128> for Float
impl PowAssign<i128> for Float
source§fn pow_assign(&mut self, rhs: i128)
fn pow_assign(&mut self, rhs: i128)
source§impl PowAssign<i16> for Float
impl PowAssign<i16> for Float
source§fn pow_assign(&mut self, rhs: i16)
fn pow_assign(&mut self, rhs: i16)
source§impl PowAssign<i32> for Float
impl PowAssign<i32> for Float
source§fn pow_assign(&mut self, rhs: i32)
fn pow_assign(&mut self, rhs: i32)
source§impl PowAssign<i64> for Float
impl PowAssign<i64> for Float
source§fn pow_assign(&mut self, rhs: i64)
fn pow_assign(&mut self, rhs: i64)
source§impl PowAssign<i8> for Float
impl PowAssign<i8> for Float
source§fn pow_assign(&mut self, rhs: i8)
fn pow_assign(&mut self, rhs: i8)
source§impl PowAssign<isize> for Float
impl PowAssign<isize> for Float
source§fn pow_assign(&mut self, rhs: isize)
fn pow_assign(&mut self, rhs: isize)
source§impl PowAssign<u128> for Float
impl PowAssign<u128> for Float
source§fn pow_assign(&mut self, rhs: u128)
fn pow_assign(&mut self, rhs: u128)
source§impl PowAssign<u16> for Float
impl PowAssign<u16> for Float
source§fn pow_assign(&mut self, rhs: u16)
fn pow_assign(&mut self, rhs: u16)
source§impl PowAssign<u32> for Float
impl PowAssign<u32> for Float
source§fn pow_assign(&mut self, rhs: u32)
fn pow_assign(&mut self, rhs: u32)
source§impl PowAssign<u64> for Float
impl PowAssign<u64> for Float
source§fn pow_assign(&mut self, rhs: u64)
fn pow_assign(&mut self, rhs: u64)
source§impl PowAssign<u8> for Float
impl PowAssign<u8> for Float
source§fn pow_assign(&mut self, rhs: u8)
fn pow_assign(&mut self, rhs: u8)
source§impl PowAssign<usize> for Float
impl PowAssign<usize> for Float
source§fn pow_assign(&mut self, rhs: usize)
fn pow_assign(&mut self, rhs: usize)
source§impl PowAssignRound<&Float> for Complex
impl PowAssignRound<&Float> for Complex
source§impl PowAssignRound<&Float> for Float
impl PowAssignRound<&Float> for Float
source§impl PowAssignRound<&Integer> for Float
impl PowAssignRound<&Integer> for Float
source§impl PowAssignRound<&f32> for Float
impl PowAssignRound<&f32> for Float
source§impl PowAssignRound<&f64> for Float
impl PowAssignRound<&f64> for Float
source§impl PowAssignRound<&i128> for Float
impl PowAssignRound<&i128> for Float
source§impl PowAssignRound<&i16> for Float
impl PowAssignRound<&i16> for Float
source§impl PowAssignRound<&i32> for Float
impl PowAssignRound<&i32> for Float
source§impl PowAssignRound<&i64> for Float
impl PowAssignRound<&i64> for Float
source§impl PowAssignRound<&i8> for Float
impl PowAssignRound<&i8> for Float
source§impl PowAssignRound<&isize> for Float
impl PowAssignRound<&isize> for Float
source§impl PowAssignRound<&u128> for Float
impl PowAssignRound<&u128> for Float
source§impl PowAssignRound<&u16> for Float
impl PowAssignRound<&u16> for Float
source§impl PowAssignRound<&u32> for Float
impl PowAssignRound<&u32> for Float
source§impl PowAssignRound<&u64> for Float
impl PowAssignRound<&u64> for Float
source§impl PowAssignRound<&u8> for Float
impl PowAssignRound<&u8> for Float
source§impl PowAssignRound<&usize> for Float
impl PowAssignRound<&usize> for Float
source§impl PowAssignRound<Float> for Complex
impl PowAssignRound<Float> for Complex
source§impl PowAssignRound<Integer> for Float
impl PowAssignRound<Integer> for Float
source§impl PowAssignRound<f32> for Float
impl PowAssignRound<f32> for Float
source§impl PowAssignRound<f64> for Float
impl PowAssignRound<f64> for Float
source§impl PowAssignRound<i128> for Float
impl PowAssignRound<i128> for Float
source§impl PowAssignRound<i16> for Float
impl PowAssignRound<i16> for Float
source§impl PowAssignRound<i32> for Float
impl PowAssignRound<i32> for Float
source§impl PowAssignRound<i64> for Float
impl PowAssignRound<i64> for Float
source§impl PowAssignRound<i8> for Float
impl PowAssignRound<i8> for Float
source§impl PowAssignRound<isize> for Float
impl PowAssignRound<isize> for Float
source§impl PowAssignRound<u128> for Float
impl PowAssignRound<u128> for Float
source§impl PowAssignRound<u16> for Float
impl PowAssignRound<u16> for Float
source§impl PowAssignRound<u32> for Float
impl PowAssignRound<u32> for Float
source§impl PowAssignRound<u64> for Float
impl PowAssignRound<u64> for Float
source§impl PowAssignRound<u8> for Float
impl PowAssignRound<u8> for Float
source§impl PowAssignRound<usize> for Float
impl PowAssignRound<usize> for Float
source§impl PowAssignRound for Float
impl PowAssignRound for Float
source§impl PowFromRound<&Float> for Float
impl PowFromRound<&Float> for Float
source§impl PowFromRound<&f32> for Float
impl PowFromRound<&f32> for Float
source§impl PowFromRound<&f64> for Float
impl PowFromRound<&f64> for Float
source§impl PowFromRound<&i128> for Float
impl PowFromRound<&i128> for Float
source§impl PowFromRound<&i16> for Float
impl PowFromRound<&i16> for Float
source§impl PowFromRound<&i32> for Float
impl PowFromRound<&i32> for Float
source§impl PowFromRound<&i64> for Float
impl PowFromRound<&i64> for Float
source§impl PowFromRound<&i8> for Float
impl PowFromRound<&i8> for Float
source§impl PowFromRound<&isize> for Float
impl PowFromRound<&isize> for Float
source§impl PowFromRound<&u128> for Float
impl PowFromRound<&u128> for Float
source§impl PowFromRound<&u16> for Float
impl PowFromRound<&u16> for Float
source§impl PowFromRound<&u32> for Float
impl PowFromRound<&u32> for Float
source§impl PowFromRound<&u64> for Float
impl PowFromRound<&u64> for Float
source§impl PowFromRound<&u8> for Float
impl PowFromRound<&u8> for Float
source§impl PowFromRound<&usize> for Float
impl PowFromRound<&usize> for Float
source§impl PowFromRound<f32> for Float
impl PowFromRound<f32> for Float
source§impl PowFromRound<f64> for Float
impl PowFromRound<f64> for Float
source§impl PowFromRound<i128> for Float
impl PowFromRound<i128> for Float
source§impl PowFromRound<i16> for Float
impl PowFromRound<i16> for Float
source§impl PowFromRound<i32> for Float
impl PowFromRound<i32> for Float
source§impl PowFromRound<i64> for Float
impl PowFromRound<i64> for Float
source§impl PowFromRound<i8> for Float
impl PowFromRound<i8> for Float
source§impl PowFromRound<isize> for Float
impl PowFromRound<isize> for Float
source§impl PowFromRound<u128> for Float
impl PowFromRound<u128> for Float
source§impl PowFromRound<u16> for Float
impl PowFromRound<u16> for Float
source§impl PowFromRound<u32> for Float
impl PowFromRound<u32> for Float
source§impl PowFromRound<u64> for Float
impl PowFromRound<u64> for Float
source§impl PowFromRound<u8> for Float
impl PowFromRound<u8> for Float
source§impl PowFromRound<usize> for Float
impl PowFromRound<usize> for Float
source§impl PowFromRound for Float
impl PowFromRound for Float
source§impl RemAssign<&Float> for Float
impl RemAssign<&Float> for Float
source§fn rem_assign(&mut self, rhs: &Float)
fn rem_assign(&mut self, rhs: &Float)
%=
operation. Read moresource§impl RemAssign<&f32> for Float
impl RemAssign<&f32> for Float
source§fn rem_assign(&mut self, rhs: &f32)
fn rem_assign(&mut self, rhs: &f32)
%=
operation. Read moresource§impl RemAssign<&f64> for Float
impl RemAssign<&f64> for Float
source§fn rem_assign(&mut self, rhs: &f64)
fn rem_assign(&mut self, rhs: &f64)
%=
operation. Read moresource§impl RemAssign<&i128> for Float
impl RemAssign<&i128> for Float
source§fn rem_assign(&mut self, rhs: &i128)
fn rem_assign(&mut self, rhs: &i128)
%=
operation. Read moresource§impl RemAssign<&i16> for Float
impl RemAssign<&i16> for Float
source§fn rem_assign(&mut self, rhs: &i16)
fn rem_assign(&mut self, rhs: &i16)
%=
operation. Read moresource§impl RemAssign<&i32> for Float
impl RemAssign<&i32> for Float
source§fn rem_assign(&mut self, rhs: &i32)
fn rem_assign(&mut self, rhs: &i32)
%=
operation. Read moresource§impl RemAssign<&i64> for Float
impl RemAssign<&i64> for Float
source§fn rem_assign(&mut self, rhs: &i64)
fn rem_assign(&mut self, rhs: &i64)
%=
operation. Read moresource§impl RemAssign<&i8> for Float
impl RemAssign<&i8> for Float
source§fn rem_assign(&mut self, rhs: &i8)
fn rem_assign(&mut self, rhs: &i8)
%=
operation. Read moresource§impl RemAssign<&isize> for Float
impl RemAssign<&isize> for Float
source§fn rem_assign(&mut self, rhs: &isize)
fn rem_assign(&mut self, rhs: &isize)
%=
operation. Read moresource§impl RemAssign<&u128> for Float
impl RemAssign<&u128> for Float
source§fn rem_assign(&mut self, rhs: &u128)
fn rem_assign(&mut self, rhs: &u128)
%=
operation. Read moresource§impl RemAssign<&u16> for Float
impl RemAssign<&u16> for Float
source§fn rem_assign(&mut self, rhs: &u16)
fn rem_assign(&mut self, rhs: &u16)
%=
operation. Read moresource§impl RemAssign<&u32> for Float
impl RemAssign<&u32> for Float
source§fn rem_assign(&mut self, rhs: &u32)
fn rem_assign(&mut self, rhs: &u32)
%=
operation. Read moresource§impl RemAssign<&u64> for Float
impl RemAssign<&u64> for Float
source§fn rem_assign(&mut self, rhs: &u64)
fn rem_assign(&mut self, rhs: &u64)
%=
operation. Read moresource§impl RemAssign<&u8> for Float
impl RemAssign<&u8> for Float
source§fn rem_assign(&mut self, rhs: &u8)
fn rem_assign(&mut self, rhs: &u8)
%=
operation. Read moresource§impl RemAssign<&usize> for Float
impl RemAssign<&usize> for Float
source§fn rem_assign(&mut self, rhs: &usize)
fn rem_assign(&mut self, rhs: &usize)
%=
operation. Read moresource§impl RemAssign<f32> for Float
impl RemAssign<f32> for Float
source§fn rem_assign(&mut self, rhs: f32)
fn rem_assign(&mut self, rhs: f32)
%=
operation. Read moresource§impl RemAssign<f64> for Float
impl RemAssign<f64> for Float
source§fn rem_assign(&mut self, rhs: f64)
fn rem_assign(&mut self, rhs: f64)
%=
operation. Read moresource§impl RemAssign<i128> for Float
impl RemAssign<i128> for Float
source§fn rem_assign(&mut self, rhs: i128)
fn rem_assign(&mut self, rhs: i128)
%=
operation. Read moresource§impl RemAssign<i16> for Float
impl RemAssign<i16> for Float
source§fn rem_assign(&mut self, rhs: i16)
fn rem_assign(&mut self, rhs: i16)
%=
operation. Read moresource§impl RemAssign<i32> for Float
impl RemAssign<i32> for Float
source§fn rem_assign(&mut self, rhs: i32)
fn rem_assign(&mut self, rhs: i32)
%=
operation. Read moresource§impl RemAssign<i64> for Float
impl RemAssign<i64> for Float
source§fn rem_assign(&mut self, rhs: i64)
fn rem_assign(&mut self, rhs: i64)
%=
operation. Read moresource§impl RemAssign<i8> for Float
impl RemAssign<i8> for Float
source§fn rem_assign(&mut self, rhs: i8)
fn rem_assign(&mut self, rhs: i8)
%=
operation. Read moresource§impl RemAssign<isize> for Float
impl RemAssign<isize> for Float
source§fn rem_assign(&mut self, rhs: isize)
fn rem_assign(&mut self, rhs: isize)
%=
operation. Read moresource§impl RemAssign<u128> for Float
impl RemAssign<u128> for Float
source§fn rem_assign(&mut self, rhs: u128)
fn rem_assign(&mut self, rhs: u128)
%=
operation. Read moresource§impl RemAssign<u16> for Float
impl RemAssign<u16> for Float
source§fn rem_assign(&mut self, rhs: u16)
fn rem_assign(&mut self, rhs: u16)
%=
operation. Read moresource§impl RemAssign<u32> for Float
impl RemAssign<u32> for Float
source§fn rem_assign(&mut self, rhs: u32)
fn rem_assign(&mut self, rhs: u32)
%=
operation. Read moresource§impl RemAssign<u64> for Float
impl RemAssign<u64> for Float
source§fn rem_assign(&mut self, rhs: u64)
fn rem_assign(&mut self, rhs: u64)
%=
operation. Read moresource§impl RemAssign<u8> for Float
impl RemAssign<u8> for Float
source§fn rem_assign(&mut self, rhs: u8)
fn rem_assign(&mut self, rhs: u8)
%=
operation. Read moresource§impl RemAssign<usize> for Float
impl RemAssign<usize> for Float
source§fn rem_assign(&mut self, rhs: usize)
fn rem_assign(&mut self, rhs: usize)
%=
operation. Read moresource§impl RemAssign for Float
impl RemAssign for Float
source§fn rem_assign(&mut self, rhs: Float)
fn rem_assign(&mut self, rhs: Float)
%=
operation. Read moresource§impl RemAssignRound<&Float> for Float
impl RemAssignRound<&Float> for Float
source§impl RemAssignRound<&f32> for Float
impl RemAssignRound<&f32> for Float
source§impl RemAssignRound<&f64> for Float
impl RemAssignRound<&f64> for Float
source§impl RemAssignRound<&i128> for Float
impl RemAssignRound<&i128> for Float
source§impl RemAssignRound<&i16> for Float
impl RemAssignRound<&i16> for Float
source§impl RemAssignRound<&i32> for Float
impl RemAssignRound<&i32> for Float
source§impl RemAssignRound<&i64> for Float
impl RemAssignRound<&i64> for Float
source§impl RemAssignRound<&i8> for Float
impl RemAssignRound<&i8> for Float
source§impl RemAssignRound<&isize> for Float
impl RemAssignRound<&isize> for Float
source§impl RemAssignRound<&u128> for Float
impl RemAssignRound<&u128> for Float
source§impl RemAssignRound<&u16> for Float
impl RemAssignRound<&u16> for Float
source§impl RemAssignRound<&u32> for Float
impl RemAssignRound<&u32> for Float
source§impl RemAssignRound<&u64> for Float
impl RemAssignRound<&u64> for Float
source§impl RemAssignRound<&u8> for Float
impl RemAssignRound<&u8> for Float
source§impl RemAssignRound<&usize> for Float
impl RemAssignRound<&usize> for Float
source§impl RemAssignRound<f32> for Float
impl RemAssignRound<f32> for Float
source§impl RemAssignRound<f64> for Float
impl RemAssignRound<f64> for Float
source§impl RemAssignRound<i128> for Float
impl RemAssignRound<i128> for Float
source§impl RemAssignRound<i16> for Float
impl RemAssignRound<i16> for Float
source§impl RemAssignRound<i32> for Float
impl RemAssignRound<i32> for Float
source§impl RemAssignRound<i64> for Float
impl RemAssignRound<i64> for Float
source§impl RemAssignRound<i8> for Float
impl RemAssignRound<i8> for Float
source§impl RemAssignRound<isize> for Float
impl RemAssignRound<isize> for Float
source§impl RemAssignRound<u128> for Float
impl RemAssignRound<u128> for Float
source§impl RemAssignRound<u16> for Float
impl RemAssignRound<u16> for Float
source§impl RemAssignRound<u32> for Float
impl RemAssignRound<u32> for Float
source§impl RemAssignRound<u64> for Float
impl RemAssignRound<u64> for Float
source§impl RemAssignRound<u8> for Float
impl RemAssignRound<u8> for Float
source§impl RemAssignRound<usize> for Float
impl RemAssignRound<usize> for Float
source§impl RemAssignRound for Float
impl RemAssignRound for Float
source§impl RemFromRound<&Float> for Float
impl RemFromRound<&Float> for Float
source§impl RemFromRound<&f32> for Float
impl RemFromRound<&f32> for Float
source§impl RemFromRound<&f64> for Float
impl RemFromRound<&f64> for Float
source§impl RemFromRound<&i128> for Float
impl RemFromRound<&i128> for Float
source§impl RemFromRound<&i16> for Float
impl RemFromRound<&i16> for Float
source§impl RemFromRound<&i32> for Float
impl RemFromRound<&i32> for Float
source§impl RemFromRound<&i64> for Float
impl RemFromRound<&i64> for Float
source§impl RemFromRound<&i8> for Float
impl RemFromRound<&i8> for Float
source§impl RemFromRound<&isize> for Float
impl RemFromRound<&isize> for Float
source§impl RemFromRound<&u128> for Float
impl RemFromRound<&u128> for Float
source§impl RemFromRound<&u16> for Float
impl RemFromRound<&u16> for Float
source§impl RemFromRound<&u32> for Float
impl RemFromRound<&u32> for Float
source§impl RemFromRound<&u64> for Float
impl RemFromRound<&u64> for Float
source§impl RemFromRound<&u8> for Float
impl RemFromRound<&u8> for Float
source§impl RemFromRound<&usize> for Float
impl RemFromRound<&usize> for Float
source§impl RemFromRound<f32> for Float
impl RemFromRound<f32> for Float
source§impl RemFromRound<f64> for Float
impl RemFromRound<f64> for Float
source§impl RemFromRound<i128> for Float
impl RemFromRound<i128> for Float
source§impl RemFromRound<i16> for Float
impl RemFromRound<i16> for Float
source§impl RemFromRound<i32> for Float
impl RemFromRound<i32> for Float
source§impl RemFromRound<i64> for Float
impl RemFromRound<i64> for Float
source§impl RemFromRound<i8> for Float
impl RemFromRound<i8> for Float
source§impl RemFromRound<isize> for Float
impl RemFromRound<isize> for Float
source§impl RemFromRound<u128> for Float
impl RemFromRound<u128> for Float
source§impl RemFromRound<u16> for Float
impl RemFromRound<u16> for Float
source§impl RemFromRound<u32> for Float
impl RemFromRound<u32> for Float
source§impl RemFromRound<u64> for Float
impl RemFromRound<u64> for Float
source§impl RemFromRound<u8> for Float
impl RemFromRound<u8> for Float
source§impl RemFromRound<usize> for Float
impl RemFromRound<usize> for Float
source§impl RemFromRound for Float
impl RemFromRound for Float
source§impl SaturatingCast<i128> for &Float
impl SaturatingCast<i128> for &Float
source§fn saturating_cast(self) -> i128
fn saturating_cast(self) -> i128
source§impl SaturatingCast<i128> for Float
impl SaturatingCast<i128> for Float
source§fn saturating_cast(self) -> i128
fn saturating_cast(self) -> i128
source§impl SaturatingCast<i16> for &Float
impl SaturatingCast<i16> for &Float
source§fn saturating_cast(self) -> i16
fn saturating_cast(self) -> i16
source§impl SaturatingCast<i16> for Float
impl SaturatingCast<i16> for Float
source§fn saturating_cast(self) -> i16
fn saturating_cast(self) -> i16
source§impl SaturatingCast<i32> for &Float
impl SaturatingCast<i32> for &Float
source§fn saturating_cast(self) -> i32
fn saturating_cast(self) -> i32
source§impl SaturatingCast<i32> for Float
impl SaturatingCast<i32> for Float
source§fn saturating_cast(self) -> i32
fn saturating_cast(self) -> i32
source§impl SaturatingCast<i64> for &Float
impl SaturatingCast<i64> for &Float
source§fn saturating_cast(self) -> i64
fn saturating_cast(self) -> i64
source§impl SaturatingCast<i64> for Float
impl SaturatingCast<i64> for Float
source§fn saturating_cast(self) -> i64
fn saturating_cast(self) -> i64
source§impl SaturatingCast<i8> for &Float
impl SaturatingCast<i8> for &Float
source§fn saturating_cast(self) -> i8
fn saturating_cast(self) -> i8
source§impl SaturatingCast<i8> for Float
impl SaturatingCast<i8> for Float
source§fn saturating_cast(self) -> i8
fn saturating_cast(self) -> i8
source§impl SaturatingCast<isize> for &Float
impl SaturatingCast<isize> for &Float
source§fn saturating_cast(self) -> isize
fn saturating_cast(self) -> isize
source§impl SaturatingCast<isize> for Float
impl SaturatingCast<isize> for Float
source§fn saturating_cast(self) -> isize
fn saturating_cast(self) -> isize
source§impl SaturatingCast<u128> for &Float
impl SaturatingCast<u128> for &Float
source§fn saturating_cast(self) -> u128
fn saturating_cast(self) -> u128
source§impl SaturatingCast<u128> for Float
impl SaturatingCast<u128> for Float
source§fn saturating_cast(self) -> u128
fn saturating_cast(self) -> u128
source§impl SaturatingCast<u16> for &Float
impl SaturatingCast<u16> for &Float
source§fn saturating_cast(self) -> u16
fn saturating_cast(self) -> u16
source§impl SaturatingCast<u16> for Float
impl SaturatingCast<u16> for Float
source§fn saturating_cast(self) -> u16
fn saturating_cast(self) -> u16
source§impl SaturatingCast<u32> for &Float
impl SaturatingCast<u32> for &Float
source§fn saturating_cast(self) -> u32
fn saturating_cast(self) -> u32
source§impl SaturatingCast<u32> for Float
impl SaturatingCast<u32> for Float
source§fn saturating_cast(self) -> u32
fn saturating_cast(self) -> u32
source§impl SaturatingCast<u64> for &Float
impl SaturatingCast<u64> for &Float
source§fn saturating_cast(self) -> u64
fn saturating_cast(self) -> u64
source§impl SaturatingCast<u64> for Float
impl SaturatingCast<u64> for Float
source§fn saturating_cast(self) -> u64
fn saturating_cast(self) -> u64
source§impl SaturatingCast<u8> for &Float
impl SaturatingCast<u8> for &Float
source§fn saturating_cast(self) -> u8
fn saturating_cast(self) -> u8
source§impl SaturatingCast<u8> for Float
impl SaturatingCast<u8> for Float
source§fn saturating_cast(self) -> u8
fn saturating_cast(self) -> u8
source§impl SaturatingCast<usize> for &Float
impl SaturatingCast<usize> for &Float
source§fn saturating_cast(self) -> usize
fn saturating_cast(self) -> usize
source§impl SaturatingCast<usize> for Float
impl SaturatingCast<usize> for Float
source§fn saturating_cast(self) -> usize
fn saturating_cast(self) -> usize
source§impl ShlAssign<&i32> for Float
impl ShlAssign<&i32> for Float
source§fn shl_assign(&mut self, rhs: &i32)
fn shl_assign(&mut self, rhs: &i32)
<<=
operation. Read moresource§impl ShlAssign<&isize> for Float
impl ShlAssign<&isize> for Float
source§fn shl_assign(&mut self, rhs: &isize)
fn shl_assign(&mut self, rhs: &isize)
<<=
operation. Read moresource§impl ShlAssign<&u32> for Float
impl ShlAssign<&u32> for Float
source§fn shl_assign(&mut self, rhs: &u32)
fn shl_assign(&mut self, rhs: &u32)
<<=
operation. Read moresource§impl ShlAssign<&usize> for Float
impl ShlAssign<&usize> for Float
source§fn shl_assign(&mut self, rhs: &usize)
fn shl_assign(&mut self, rhs: &usize)
<<=
operation. Read moresource§impl ShlAssign<i32> for Float
impl ShlAssign<i32> for Float
source§fn shl_assign(&mut self, rhs: i32)
fn shl_assign(&mut self, rhs: i32)
<<=
operation. Read moresource§impl ShlAssign<isize> for Float
impl ShlAssign<isize> for Float
source§fn shl_assign(&mut self, rhs: isize)
fn shl_assign(&mut self, rhs: isize)
<<=
operation. Read moresource§impl ShlAssign<u32> for Float
impl ShlAssign<u32> for Float
source§fn shl_assign(&mut self, rhs: u32)
fn shl_assign(&mut self, rhs: u32)
<<=
operation. Read moresource§impl ShlAssign<usize> for Float
impl ShlAssign<usize> for Float
source§fn shl_assign(&mut self, rhs: usize)
fn shl_assign(&mut self, rhs: usize)
<<=
operation. Read moresource§impl ShrAssign<&i32> for Float
impl ShrAssign<&i32> for Float
source§fn shr_assign(&mut self, rhs: &i32)
fn shr_assign(&mut self, rhs: &i32)
>>=
operation. Read moresource§impl ShrAssign<&isize> for Float
impl ShrAssign<&isize> for Float
source§fn shr_assign(&mut self, rhs: &isize)
fn shr_assign(&mut self, rhs: &isize)
>>=
operation. Read moresource§impl ShrAssign<&u32> for Float
impl ShrAssign<&u32> for Float
source§fn shr_assign(&mut self, rhs: &u32)
fn shr_assign(&mut self, rhs: &u32)
>>=
operation. Read moresource§impl ShrAssign<&usize> for Float
impl ShrAssign<&usize> for Float
source§fn shr_assign(&mut self, rhs: &usize)
fn shr_assign(&mut self, rhs: &usize)
>>=
operation. Read moresource§impl ShrAssign<i32> for Float
impl ShrAssign<i32> for Float
source§fn shr_assign(&mut self, rhs: i32)
fn shr_assign(&mut self, rhs: i32)
>>=
operation. Read moresource§impl ShrAssign<isize> for Float
impl ShrAssign<isize> for Float
source§fn shr_assign(&mut self, rhs: isize)
fn shr_assign(&mut self, rhs: isize)
>>=
operation. Read moresource§impl ShrAssign<u32> for Float
impl ShrAssign<u32> for Float
source§fn shr_assign(&mut self, rhs: u32)
fn shr_assign(&mut self, rhs: u32)
>>=
operation. Read moresource§impl ShrAssign<usize> for Float
impl ShrAssign<usize> for Float
source§fn shr_assign(&mut self, rhs: usize)
fn shr_assign(&mut self, rhs: usize)
>>=
operation. Read moresource§impl SubAssign<&Float> for Complex
impl SubAssign<&Float> for Complex
source§fn sub_assign(&mut self, rhs: &Float)
fn sub_assign(&mut self, rhs: &Float)
-=
operation. Read moresource§impl SubAssign<&Float> for Float
impl SubAssign<&Float> for Float
source§fn sub_assign(&mut self, rhs: &Float)
fn sub_assign(&mut self, rhs: &Float)
-=
operation. Read moresource§impl SubAssign<&Integer> for Float
impl SubAssign<&Integer> for Float
source§fn sub_assign(&mut self, rhs: &Integer)
fn sub_assign(&mut self, rhs: &Integer)
-=
operation. Read moresource§impl SubAssign<&Rational> for Float
impl SubAssign<&Rational> for Float
source§fn sub_assign(&mut self, rhs: &Rational)
fn sub_assign(&mut self, rhs: &Rational)
-=
operation. Read moresource§impl SubAssign<&f32> for Float
impl SubAssign<&f32> for Float
source§fn sub_assign(&mut self, rhs: &f32)
fn sub_assign(&mut self, rhs: &f32)
-=
operation. Read moresource§impl SubAssign<&f64> for Float
impl SubAssign<&f64> for Float
source§fn sub_assign(&mut self, rhs: &f64)
fn sub_assign(&mut self, rhs: &f64)
-=
operation. Read moresource§impl SubAssign<&i128> for Float
impl SubAssign<&i128> for Float
source§fn sub_assign(&mut self, rhs: &i128)
fn sub_assign(&mut self, rhs: &i128)
-=
operation. Read moresource§impl SubAssign<&i16> for Float
impl SubAssign<&i16> for Float
source§fn sub_assign(&mut self, rhs: &i16)
fn sub_assign(&mut self, rhs: &i16)
-=
operation. Read moresource§impl SubAssign<&i32> for Float
impl SubAssign<&i32> for Float
source§fn sub_assign(&mut self, rhs: &i32)
fn sub_assign(&mut self, rhs: &i32)
-=
operation. Read moresource§impl SubAssign<&i64> for Float
impl SubAssign<&i64> for Float
source§fn sub_assign(&mut self, rhs: &i64)
fn sub_assign(&mut self, rhs: &i64)
-=
operation. Read moresource§impl SubAssign<&i8> for Float
impl SubAssign<&i8> for Float
source§fn sub_assign(&mut self, rhs: &i8)
fn sub_assign(&mut self, rhs: &i8)
-=
operation. Read moresource§impl SubAssign<&isize> for Float
impl SubAssign<&isize> for Float
source§fn sub_assign(&mut self, rhs: &isize)
fn sub_assign(&mut self, rhs: &isize)
-=
operation. Read moresource§impl SubAssign<&u128> for Float
impl SubAssign<&u128> for Float
source§fn sub_assign(&mut self, rhs: &u128)
fn sub_assign(&mut self, rhs: &u128)
-=
operation. Read moresource§impl SubAssign<&u16> for Float
impl SubAssign<&u16> for Float
source§fn sub_assign(&mut self, rhs: &u16)
fn sub_assign(&mut self, rhs: &u16)
-=
operation. Read moresource§impl SubAssign<&u32> for Float
impl SubAssign<&u32> for Float
source§fn sub_assign(&mut self, rhs: &u32)
fn sub_assign(&mut self, rhs: &u32)
-=
operation. Read moresource§impl SubAssign<&u64> for Float
impl SubAssign<&u64> for Float
source§fn sub_assign(&mut self, rhs: &u64)
fn sub_assign(&mut self, rhs: &u64)
-=
operation. Read moresource§impl SubAssign<&u8> for Float
impl SubAssign<&u8> for Float
source§fn sub_assign(&mut self, rhs: &u8)
fn sub_assign(&mut self, rhs: &u8)
-=
operation. Read moresource§impl SubAssign<&usize> for Float
impl SubAssign<&usize> for Float
source§fn sub_assign(&mut self, rhs: &usize)
fn sub_assign(&mut self, rhs: &usize)
-=
operation. Read moresource§impl SubAssign<Float> for Complex
impl SubAssign<Float> for Complex
source§fn sub_assign(&mut self, rhs: Float)
fn sub_assign(&mut self, rhs: Float)
-=
operation. Read moresource§impl SubAssign<Integer> for Float
impl SubAssign<Integer> for Float
source§fn sub_assign(&mut self, rhs: Integer)
fn sub_assign(&mut self, rhs: Integer)
-=
operation. Read moresource§impl SubAssign<Rational> for Float
impl SubAssign<Rational> for Float
source§fn sub_assign(&mut self, rhs: Rational)
fn sub_assign(&mut self, rhs: Rational)
-=
operation. Read moresource§impl SubAssign<f32> for Float
impl SubAssign<f32> for Float
source§fn sub_assign(&mut self, rhs: f32)
fn sub_assign(&mut self, rhs: f32)
-=
operation. Read moresource§impl SubAssign<f64> for Float
impl SubAssign<f64> for Float
source§fn sub_assign(&mut self, rhs: f64)
fn sub_assign(&mut self, rhs: f64)
-=
operation. Read moresource§impl SubAssign<i128> for Float
impl SubAssign<i128> for Float
source§fn sub_assign(&mut self, rhs: i128)
fn sub_assign(&mut self, rhs: i128)
-=
operation. Read moresource§impl SubAssign<i16> for Float
impl SubAssign<i16> for Float
source§fn sub_assign(&mut self, rhs: i16)
fn sub_assign(&mut self, rhs: i16)
-=
operation. Read moresource§impl SubAssign<i32> for Float
impl SubAssign<i32> for Float
source§fn sub_assign(&mut self, rhs: i32)
fn sub_assign(&mut self, rhs: i32)
-=
operation. Read moresource§impl SubAssign<i64> for Float
impl SubAssign<i64> for Float
source§fn sub_assign(&mut self, rhs: i64)
fn sub_assign(&mut self, rhs: i64)
-=
operation. Read moresource§impl SubAssign<i8> for Float
impl SubAssign<i8> for Float
source§fn sub_assign(&mut self, rhs: i8)
fn sub_assign(&mut self, rhs: i8)
-=
operation. Read moresource§impl SubAssign<isize> for Float
impl SubAssign<isize> for Float
source§fn sub_assign(&mut self, rhs: isize)
fn sub_assign(&mut self, rhs: isize)
-=
operation. Read moresource§impl SubAssign<u128> for Float
impl SubAssign<u128> for Float
source§fn sub_assign(&mut self, rhs: u128)
fn sub_assign(&mut self, rhs: u128)
-=
operation. Read moresource§impl SubAssign<u16> for Float
impl SubAssign<u16> for Float
source§fn sub_assign(&mut self, rhs: u16)
fn sub_assign(&mut self, rhs: u16)
-=
operation. Read moresource§impl SubAssign<u32> for Float
impl SubAssign<u32> for Float
source§fn sub_assign(&mut self, rhs: u32)
fn sub_assign(&mut self, rhs: u32)
-=
operation. Read moresource§impl SubAssign<u64> for Float
impl SubAssign<u64> for Float
source§fn sub_assign(&mut self, rhs: u64)
fn sub_assign(&mut self, rhs: u64)
-=
operation. Read moresource§impl SubAssign<u8> for Float
impl SubAssign<u8> for Float
source§fn sub_assign(&mut self, rhs: u8)
fn sub_assign(&mut self, rhs: u8)
-=
operation. Read moresource§impl SubAssign<usize> for Float
impl SubAssign<usize> for Float
source§fn sub_assign(&mut self, rhs: usize)
fn sub_assign(&mut self, rhs: usize)
-=
operation. Read moresource§impl SubAssign for Float
impl SubAssign for Float
source§fn sub_assign(&mut self, rhs: Float)
fn sub_assign(&mut self, rhs: Float)
-=
operation. Read moresource§impl SubAssignRound<&Float> for Complex
impl SubAssignRound<&Float> for Complex
source§impl SubAssignRound<&Float> for Float
impl SubAssignRound<&Float> for Float
source§impl SubAssignRound<&Integer> for Float
impl SubAssignRound<&Integer> for Float
source§impl SubAssignRound<&Rational> for Float
impl SubAssignRound<&Rational> for Float
source§impl SubAssignRound<&f32> for Float
impl SubAssignRound<&f32> for Float
source§impl SubAssignRound<&f64> for Float
impl SubAssignRound<&f64> for Float
source§impl SubAssignRound<&i128> for Float
impl SubAssignRound<&i128> for Float
source§impl SubAssignRound<&i16> for Float
impl SubAssignRound<&i16> for Float
source§impl SubAssignRound<&i32> for Float
impl SubAssignRound<&i32> for Float
source§impl SubAssignRound<&i64> for Float
impl SubAssignRound<&i64> for Float
source§impl SubAssignRound<&i8> for Float
impl SubAssignRound<&i8> for Float
source§impl SubAssignRound<&isize> for Float
impl SubAssignRound<&isize> for Float
source§impl SubAssignRound<&u128> for Float
impl SubAssignRound<&u128> for Float
source§impl SubAssignRound<&u16> for Float
impl SubAssignRound<&u16> for Float
source§impl SubAssignRound<&u32> for Float
impl SubAssignRound<&u32> for Float
source§impl SubAssignRound<&u64> for Float
impl SubAssignRound<&u64> for Float
source§impl SubAssignRound<&u8> for Float
impl SubAssignRound<&u8> for Float
source§impl SubAssignRound<&usize> for Float
impl SubAssignRound<&usize> for Float
source§impl SubAssignRound<Float> for Complex
impl SubAssignRound<Float> for Complex
source§impl SubAssignRound<Integer> for Float
impl SubAssignRound<Integer> for Float
source§impl SubAssignRound<Rational> for Float
impl SubAssignRound<Rational> for Float
source§impl SubAssignRound<f32> for Float
impl SubAssignRound<f32> for Float
source§impl SubAssignRound<f64> for Float
impl SubAssignRound<f64> for Float
source§impl SubAssignRound<i128> for Float
impl SubAssignRound<i128> for Float
source§impl SubAssignRound<i16> for Float
impl SubAssignRound<i16> for Float
source§impl SubAssignRound<i32> for Float
impl SubAssignRound<i32> for Float
source§impl SubAssignRound<i64> for Float
impl SubAssignRound<i64> for Float
source§impl SubAssignRound<i8> for Float
impl SubAssignRound<i8> for Float
source§impl SubAssignRound<isize> for Float
impl SubAssignRound<isize> for Float
source§impl SubAssignRound<u128> for Float
impl SubAssignRound<u128> for Float
source§impl SubAssignRound<u16> for Float
impl SubAssignRound<u16> for Float
source§impl SubAssignRound<u32> for Float
impl SubAssignRound<u32> for Float
source§impl SubAssignRound<u64> for Float
impl SubAssignRound<u64> for Float
source§impl SubAssignRound<u8> for Float
impl SubAssignRound<u8> for Float
source§impl SubAssignRound<usize> for Float
impl SubAssignRound<usize> for Float
source§impl SubAssignRound for Float
impl SubAssignRound for Float
source§impl SubFromRound<&Float> for Complex
impl SubFromRound<&Float> for Complex
source§impl SubFromRound<&Float> for Float
impl SubFromRound<&Float> for Float
source§impl SubFromRound<&Integer> for Float
impl SubFromRound<&Integer> for Float
source§impl SubFromRound<&Rational> for Float
impl SubFromRound<&Rational> for Float
source§impl SubFromRound<&f32> for Float
impl SubFromRound<&f32> for Float
source§impl SubFromRound<&f64> for Float
impl SubFromRound<&f64> for Float
source§impl SubFromRound<&i128> for Float
impl SubFromRound<&i128> for Float
source§impl SubFromRound<&i16> for Float
impl SubFromRound<&i16> for Float
source§impl SubFromRound<&i32> for Float
impl SubFromRound<&i32> for Float
source§impl SubFromRound<&i64> for Float
impl SubFromRound<&i64> for Float
source§impl SubFromRound<&i8> for Float
impl SubFromRound<&i8> for Float
source§impl SubFromRound<&isize> for Float
impl SubFromRound<&isize> for Float
source§impl SubFromRound<&u128> for Float
impl SubFromRound<&u128> for Float
source§impl SubFromRound<&u16> for Float
impl SubFromRound<&u16> for Float
source§impl SubFromRound<&u32> for Float
impl SubFromRound<&u32> for Float
source§impl SubFromRound<&u64> for Float
impl SubFromRound<&u64> for Float
source§impl SubFromRound<&u8> for Float
impl SubFromRound<&u8> for Float
source§impl SubFromRound<&usize> for Float
impl SubFromRound<&usize> for Float
source§impl SubFromRound<Float> for Complex
impl SubFromRound<Float> for Complex
source§impl SubFromRound<Integer> for Float
impl SubFromRound<Integer> for Float
source§impl SubFromRound<Rational> for Float
impl SubFromRound<Rational> for Float
source§impl SubFromRound<f32> for Float
impl SubFromRound<f32> for Float
source§impl SubFromRound<f64> for Float
impl SubFromRound<f64> for Float
source§impl SubFromRound<i128> for Float
impl SubFromRound<i128> for Float
source§impl SubFromRound<i16> for Float
impl SubFromRound<i16> for Float
source§impl SubFromRound<i32> for Float
impl SubFromRound<i32> for Float
source§impl SubFromRound<i64> for Float
impl SubFromRound<i64> for Float
source§impl SubFromRound<i8> for Float
impl SubFromRound<i8> for Float
source§impl SubFromRound<isize> for Float
impl SubFromRound<isize> for Float
source§impl SubFromRound<u128> for Float
impl SubFromRound<u128> for Float
source§impl SubFromRound<u16> for Float
impl SubFromRound<u16> for Float
source§impl SubFromRound<u32> for Float
impl SubFromRound<u32> for Float
source§impl SubFromRound<u64> for Float
impl SubFromRound<u64> for Float
source§impl SubFromRound<u8> for Float
impl SubFromRound<u8> for Float
source§impl SubFromRound<usize> for Float
impl SubFromRound<usize> for Float
source§impl SubFromRound for Float
impl SubFromRound for Float
source§impl ToPrimitive for Float
impl ToPrimitive for Float
source§fn to_i64(&self) -> Option<i64>
fn to_i64(&self) -> Option<i64>
self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned.source§fn to_u64(&self) -> Option<u64>
fn to_u64(&self) -> Option<u64>
self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned.source§fn to_isize(&self) -> Option<isize>
fn to_isize(&self) -> Option<isize>
self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned.source§fn to_i8(&self) -> Option<i8>
fn to_i8(&self) -> Option<i8>
self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned.source§fn to_i16(&self) -> Option<i16>
fn to_i16(&self) -> Option<i16>
self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned.source§fn to_i32(&self) -> Option<i32>
fn to_i32(&self) -> Option<i32>
self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned.source§fn to_i128(&self) -> Option<i128>
fn to_i128(&self) -> Option<i128>
self
to an i128
. If the value cannot be
represented by an i128
(i64
under the default implementation), then
None
is returned. Read moresource§fn to_usize(&self) -> Option<usize>
fn to_usize(&self) -> Option<usize>
self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned.source§fn to_u8(&self) -> Option<u8>
fn to_u8(&self) -> Option<u8>
self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned.source§fn to_u16(&self) -> Option<u16>
fn to_u16(&self) -> Option<u16>
self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned.source§fn to_u32(&self) -> Option<u32>
fn to_u32(&self) -> Option<u32>
self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned.source§fn to_u128(&self) -> Option<u128>
fn to_u128(&self) -> Option<u128>
self
to a u128
. If the value cannot be
represented by a u128
(u64
under the default implementation), then
None
is returned. Read more