Struct rug::float::SmallFloat [−][src]
pub struct SmallFloat { /* fields omitted */ }
Expand description
A small float that does not require any memory allocation.
This can be useful when you have a primitive number type but need a reference to
a Float
. The SmallFloat
will have a precision according to the type of the
primitive used to set its value.
i8
,u8
: theSmallFloat
will have eight bits of precision.i16
,u16
: theSmallFloat
will have 16 bits of precision.i32
,u32
: theSmallFloat
will have 32 bits of precision.i64
,u64
: theSmallFloat
will have 64 bits of precision.i128
,u128
: theSmallFloat
will have 128 bits of precision.isize
,usize
: theSmallFloat
will have 32 or 64 bits of precision, depending on the platform.f32
: theSmallFloat
will have 24 bits of precision.f64
: theSmallFloat
will have 53 bits of precision.Special
: theSmallFloat
will have the minimum possible precision.
The SmallFloat
type can be coerced to a Float
, as it implements
Deref<Target = Float>
.
Examples
use rug::{float::SmallFloat, Float}; // `a` requires a heap allocation, has 53-bit precision let mut a = Float::with_val(53, 250); // `b` can reside on the stack let b = SmallFloat::from(-100f64); a += &*b; assert_eq!(a, 150); // another computation: a *= &*b; assert_eq!(a, -15000);
Implementations
Creates a SmallFloat
with value 0 and the minimum possible
precision.
Examples
use rug::float::SmallFloat; let f = SmallFloat::new(); // Borrow f as if it were Float. assert_eq!(*f, 0);
Returns a mutable reference to a Float
for simple operations that do
not need to change the precision of the number.
Safety
It is undefined behavior modify the precision of the referenced
Float
or to swap it with another number.
Examples
use rug::float::SmallFloat; let mut f = SmallFloat::from(1.0f32); // addition does not change the precision unsafe { *f.as_nonreallocating_float() += 2.0; } assert_eq!(*f, 3.0);
Methods from Deref<Target = Float>
Returns a pointer to the inner MPFR floating-point number.
The returned pointer will be valid for as long as self
is valid.
Examples
use gmp_mpfr_sys::mpfr::{self, rnd_t}; use rug::Float; let f = Float::with_val(53, -14.5); let m_ptr = f.as_raw(); unsafe { let d = mpfr::get_d(m_ptr, rnd_t::RNDN); assert_eq!(d, -14.5); } // f is still valid assert_eq!(f, -14.5);
If the value is a finite number, converts it to an
Integer
rounding to the nearest.
This conversion can also be performed using
(&float).checked_as::<Integer>()
float.borrow().checked_as::<Integer>()
Examples
use rug::Float; let f = Float::with_val(53, 13.7); let i = match f.to_integer() { Some(i) => i, None => unreachable!(), }; assert_eq!(i, 14);
If the value is a finite number, converts it to an
Integer
applying the specified rounding method.
Examples
use core::cmp::Ordering; use rug::{float::Round, Float}; let f = Float::with_val(53, 13.7); let (i, dir) = match f.to_integer_round(Round::Down) { Some(i_dir) => i_dir, None => unreachable!(), }; assert_eq!(i, 13); assert_eq!(dir, Ordering::Less);
If the value is a finite number, returns an
Integer
and exponent such that it is exactly equal to the integer
multiplied by two raised to the power of the exponent.
Examples
use rug::{float::Special, Assign, Float}; let mut float = Float::with_val(16, 6.5); // 6.5 in binary is 110.1 // Since the precision is 16 bits, this becomes // 1101_0000_0000_0000 times two to the power of −12 let (int, exp) = float.to_integer_exp().unwrap(); assert_eq!(int, 0b1101_0000_0000_0000); assert_eq!(exp, -13); float.assign(0); let (zero, _) = float.to_integer_exp().unwrap(); assert_eq!(zero, 0); float.assign(Special::Infinity); assert!(float.to_integer_exp().is_none());
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>()
Examples
use core::{cmp::Ordering, str::FromStr}; use rug::{float::Round, 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);
Converts to an i32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
Examples
use core::{i32, u32}; use rug::{Assign, Float}; let mut f = Float::with_val(53, -13.7); assert_eq!(f.to_i32_saturating(), Some(-14)); f.assign(-1e40); assert_eq!(f.to_i32_saturating(), Some(i32::MIN)); f.assign(u32::MAX); assert_eq!(f.to_i32_saturating(), Some(i32::MAX));
Converts to an i32
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
Examples
use rug::{float::Round, Float}; let f = Float::with_val(53, -13.7); assert_eq!(f.to_i32_saturating_round(Round::Up), Some(-13));
Converts to a u32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
Examples
use core::u32; use rug::{Assign, Float}; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_u32_saturating(), Some(14)); f.assign(-1); assert_eq!(f.to_u32_saturating(), Some(0)); f.assign(1e40); assert_eq!(f.to_u32_saturating(), Some(u32::MAX));
Converts to a u32
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum
or maximum value allowed is returned. If the value is a NaN, None
is
returned.
Examples
use rug::{float::Round, Float}; let f = Float::with_val(53, 13.7); assert_eq!(f.to_u32_saturating_round(Round::Down), Some(13));
Converts to an f32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use core::f32; use rug::{Assign, Float}; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_f32(), 13.7); f.assign(1e300); assert_eq!(f.to_f32(), f32::INFINITY); f.assign(1e-300); assert_eq!(f.to_f32(), 0.0);
Converts to an f32
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use core::f32; use rug::{float::Round, Float}; let f = Float::with_val(53, 1.0 + (-50f64).exp2()); assert_eq!(f.to_f32_round(Round::Up), 1.0 + f32::EPSILON);
Converts to an f64
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use core::f64; use rug::{Assign, Float}; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_f64(), 13.7); f.assign(1e300); f.square_mut(); assert_eq!(f.to_f64(), f64::INFINITY);
Converts to an f64
, applying the specified rounding method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use core::f64; use rug::{float::Round, Float}; // (2.0 ^ −90) + 1 let f: Float = Float::with_val(100, -90).exp2() + 1; assert_eq!(f.to_f64_round(Round::Up), 1.0 + f64::EPSILON);
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));
Converts to an f32
and an exponent, applying the specified rounding
method.
The returned f32
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::{float::Round, Float}; let frac_10_3 = Float::with_val(64, 10) / 3u32; let (f_down, exp_down) = frac_10_3.to_f32_exp_round(Round::Down); assert_eq!((f_down, exp_down), (0.8333333, 2)); let (f_up, exp_up) = frac_10_3.to_f32_exp_round(Round::Up); assert_eq!((f_up, exp_up), (0.8333334, 2));
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));
Converts to an f64
and an exponent, applying the specified rounding
method.
The returned f64
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::{float::Round, Float}; let frac_10_3 = Float::with_val(64, 10) / 3u32; let (f_down, exp_down) = frac_10_3.to_f64_exp_round(Round::Down); assert_eq!((f_down, exp_down), (0.8333333333333333, 2)); let (f_up, exp_up) = frac_10_3.to_f64_exp_round(Round::Up); assert_eq!((f_up, exp_up), (0.8333333333333334, 2));
Returns a string representation of self
for the specified radix
rounding to the nearest.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{float::Special, Float}; let neg_inf = Float::with_val(53, Special::NegInfinity); assert_eq!(neg_inf.to_string_radix(10, None), "-inf"); assert_eq!(neg_inf.to_string_radix(16, None), "-@inf@"); let twentythree = Float::with_val(8, 23); assert_eq!(twentythree.to_string_radix(10, None), "23.00"); assert_eq!(twentythree.to_string_radix(16, None), "17.0"); assert_eq!(twentythree.to_string_radix(10, Some(2)), "23"); assert_eq!(twentythree.to_string_radix(16, Some(4)), "17.00"); // 2 raised to the power of 80 in hex is 1 followed by 20 zeros let two_to_80 = Float::with_val(53, 80f64.exp2()); assert_eq!(two_to_80.to_string_radix(10, Some(3)), "1.21e24"); assert_eq!(two_to_80.to_string_radix(16, Some(3)), "1.00@20");
Returns a string representation of self
for the specified radix
applying the specified rounding method.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{float::Round, Float}; let twentythree = Float::with_val(8, 23.3); let down = twentythree.to_string_radix_round(10, Some(2), Round::Down); assert_eq!(down, "23"); let up = twentythree.to_string_radix_round(10, Some(2), Round::Up); assert_eq!(up, "24");
Returns a string representation of self
together with a sign and an
exponent for the specified radix
, rounding to the nearest.
The returned exponent is None
if the Float
is zero, infinite or
NaN, that is if the value is not normal.
For normal values, the returned string has an implicit radix point before the first digit. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{float::Special, Float}; let inf = Float::with_val(53, Special::Infinity); let (sign, s, exp) = inf.to_sign_string_exp(10, None); assert_eq!((sign, &*s, exp), (false, "inf", None)); let (sign, s, exp) = (-inf).to_sign_string_exp(16, None); assert_eq!((sign, &*s, exp), (true, "@inf@", None)); let (sign, s, exp) = Float::with_val(8, -0.0625).to_sign_string_exp(10, None); assert_eq!((sign, &*s, exp), (true, "6250", Some(-1))); let (sign, s, exp) = Float::with_val(8, -0.625).to_sign_string_exp(10, None); assert_eq!((sign, &*s, exp), (true, "6250", Some(0))); let (sign, s, exp) = Float::with_val(8, -6.25).to_sign_string_exp(10, None); assert_eq!((sign, &*s, exp), (true, "6250", Some(1))); // −4.8e4 = 48_000, which is rounded to 48_128 using 8 bits of precision let (sign, s, exp) = Float::with_val(8, -4.8e4).to_sign_string_exp(10, None); assert_eq!((sign, &*s, exp), (true, "4813", Some(5)));
Returns a string representation of self
together with a sign and an
exponent for the specified radix
, applying the specified rounding
method.
The returned exponent is None
if the Float
is zero, infinite or
NaN, that is if the value is not normal.
For normal values, the returned string has an implicit radix point before the first digit. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{float::Round, Float}; let val = Float::with_val(53, -0.0625); // rounding −0.0625 to two significant digits towards −∞ gives −0.063 let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Down); assert_eq!((sign, &*s, exp), (true, "63", Some(-1))); // rounding −0.0625 to two significant digits towards +∞ gives −0.062 let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Up); assert_eq!((sign, &*s, exp), (true, "62", Some(-1))); let val = Float::with_val(53, 6.25e4); // rounding 6.25e4 to two significant digits towards −∞ gives 6.2e4 let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Down); assert_eq!((sign, &*s, exp), (false, "62", Some(5))); // rounding 6.25e4 to two significant digits towards +∞ gives 6.3e4 let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Up); assert_eq!((sign, &*s, exp), (false, "63", Some(5)));
Borrows a negated copy of the Float
.
The returned object implements Deref<Target =
Float>
.
This method performs a shallow copy and negates it, and negation does not change the allocated data.
Examples
use rug::Float; let f = Float::with_val(53, 4.2); let neg_f = f.as_neg(); assert_eq!(*neg_f, -4.2); // methods taking &self can be used on the returned object let reneg_f = neg_f.as_neg(); assert_eq!(*reneg_f, 4.2); assert_eq!(*reneg_f, f);
Borrows an absolute copy of the Float
.
The returned object implements Deref<Target =
Float>
.
This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.
Examples
use rug::Float; let f = Float::with_val(53, -4.2); let abs_f = f.as_abs(); assert_eq!(*abs_f, 4.2); // methods taking &self can be used on the returned object let reabs_f = abs_f.as_abs(); assert_eq!(*reabs_f, 4.2); assert_eq!(*reabs_f, *abs_f);
Borrows the Float
as an ordered floating-point number of type
OrdFloat
.
The same result can be obtained using the implementation of
AsRef<OrdFloat>
which is provided for Float
.
Examples
use core::cmp::Ordering; use rug::{float::Special, Float}; let nan_f = Float::with_val(53, Special::Nan); let nan = nan_f.as_ord(); assert_eq!(nan.cmp(nan), Ordering::Equal); let neg_inf_f = Float::with_val(53, Special::NegInfinity); let neg_inf = neg_inf_f.as_ord(); assert_eq!(nan.cmp(neg_inf), Ordering::Less); let zero_f = Float::with_val(53, Special::Zero); let zero = zero_f.as_ord(); let neg_zero_f = Float::with_val(53, Special::NegZero); let neg_zero = neg_zero_f.as_ord(); assert_eq!(zero.cmp(neg_zero), Ordering::Greater);
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));
Returns true
if self
is a normal number, that is neither NaN, nor
infinity, nor zero. Note that Float
cannot be subnormal.
Examples
use rug::{float::Special, Assign, Float}; let mut f = Float::with_val(53, Special::Zero); assert!(!f.is_normal()); f += 5.2; assert!(f.is_normal()); f.assign(Special::Infinity); assert!(!f.is_normal()); f.assign(Special::Nan); assert!(!f.is_normal());
Returns the floating-point category of the number. Note that Float
cannot be subnormal.
Examples
use core::num::FpCategory; use rug::{float::Special, Float}; let nan = Float::with_val(53, Special::Nan); let infinite = Float::with_val(53, Special::Infinity); let zero = Float::with_val(53, Special::Zero); let normal = Float::with_val(53, 2.3); assert_eq!(nan.classify(), FpCategory::Nan); assert_eq!(infinite.classify(), FpCategory::Infinite); assert_eq!(zero.classify(), FpCategory::Zero); assert_eq!(normal.classify(), FpCategory::Normal);
Returns the same result as
self.partial_cmp(&0)
, but is
faster.
Examples
use core::cmp::Ordering; use rug::{float::Special, Assign, Float}; let mut f = Float::with_val(53, Special::NegZero); assert_eq!(f.cmp0(), Some(Ordering::Equal)); f += 5.2; assert_eq!(f.cmp0(), Some(Ordering::Greater)); f.assign(Special::NegInfinity); assert_eq!(f.cmp0(), Some(Ordering::Less)); f.assign(Special::Nan); assert_eq!(f.cmp0(), None);
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));
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);
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);
Computes the remainder.
The remainder is the value of self
− n × divisor
, where
n is the integer quotient of self
/ divisor
rounded to the
nearest integer (ties rounded to even). This is different from the
remainder obtained using the %
operator or the Rem
trait, where n is truncated instead of rounded to the nearest.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 589.4); let g = Float::with_val(53, 100); let remainder = Float::with_val(53, f.remainder_ref(&g)); let expected = -10.6_f64; assert!((remainder - expected).abs() < 0.0001); // compare to % operator let f = Float::with_val(53, 589.4); let g = Float::with_val(53, 100); let rem_op = Float::with_val(53, &f % &g); let expected = 89.4_f64; assert!((rem_op - expected).abs() < 0.0001);
Multiplies and adds in one fused operation.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
a.mul_add_ref(&b, &c)
produces the exact same result as &a * &b + &c
.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // −13 in binary is −1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let add = Float::with_val(4, 24); // 1.5 × −13 + 24 = 4.5 let ans = Float::with_val(4, mul1.mul_add_ref(&mul2, &add)); assert_eq!(ans, 4.5);
Multiplies and subtracts in one fused operation.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
a.mul_sub_ref(&b, &c)
produces the exact same result as &a * &b - &c
.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // −13 in binary is −1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let sub = Float::with_val(4, 24); // 1.5 × −13 − 24 = −43.5, rounded to 44 using four bits of precision. let ans = Float::with_val(4, mul1.mul_sub_ref(&mul2, &sub)); assert_eq!(ans, -44);
pub fn mul_add_mul_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
a.mul_add_mul_ref(&b, &c, &d)
produces the exact same result
as &a * &b + &c * &d
.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 × 1.5 + 12 × 2 = 60 let ans = Float::with_val(53, a.mul_add_mul_ref(&b, &c, &d)); assert_eq!(ans, 60);
pub fn mul_sub_mul_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
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);
Computes the square.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 5.0); let r = f.square_ref(); let square = Float::with_val(53, r); assert_eq!(square, 25.0);
Computes the square root.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 25.0); let r = f.sqrt_ref(); let sqrt = Float::with_val(53, r); assert_eq!(sqrt, 5.0);
Computes the reciprocal square root.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 16.0); let r = f.recip_sqrt_ref(); let recip_sqrt = Float::with_val(53, r); assert_eq!(recip_sqrt, 0.25);
Computes the cube root.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 125.0); let r = f.cbrt_ref(); let cbrt = Float::with_val(53, r); assert_eq!(cbrt, 5.0);
Computes the kth root.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 625.0); let r = f.root_ref(4); let root = Float::with_val(53, r); assert_eq!(root, 5.0);
Computes the absolute value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let r = f.abs_ref(); let abs = Float::with_val(53, r); assert_eq!(abs, 23.5);
Computes the signum.
- 1.0 if the value is positive, +0.0 or +∞
- −1.0 if the value is negative, −0.0 or −∞
- NaN if the value is NaN
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let r = f.signum_ref(); let signum = Float::with_val(53, r); assert_eq!(signum, -1);
Computes a number with the magnitude of self
and the sign of y
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let x = Float::with_val(53, 23.0); let y = Float::with_val(53, -1.0); let r = x.copysign_ref(&y); let copysign = Float::with_val(53, r); assert_eq!(copysign, -23.0);
pub fn clamp_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
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);
Computes the reciprocal.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, -0.25); let r = f.recip_ref(); let recip = Float::with_val(53, r); assert_eq!(recip, -4.0);
Finds the minimum.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, -2); let r = a.min_ref(&b); let min = Float::with_val(53, r); assert_eq!(min, -2);
Finds the maximum.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, 12.5); let r = a.max_ref(&b); let max = Float::with_val(53, r); assert_eq!(max, 12.5);
Computes the positive difference.
The positive difference is self
− other
if self
> other
, zero if
self
≤ other
, or NaN if any operand is NaN.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let a = Float::with_val(53, 12.5); let b = Float::with_val(53, 7.3); let rab = a.positive_diff_ref(&b); let ab = Float::with_val(53, rab); assert_eq!(ab, 5.2); let rba = b.positive_diff_ref(&a); let ba = Float::with_val(53, rba); assert_eq!(ba, 0);
Computes the natural logarithm.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let ln = Float::with_val(53, f.ln_ref()); let expected = 0.4055_f64; assert!((ln - expected).abs() < 0.0001);
Computes the logarithm to base 2.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log2 = Float::with_val(53, f.log2_ref()); let expected = 0.5850_f64; assert!((log2 - expected).abs() < 0.0001);
Computes the logarithm to base 10.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log10 = Float::with_val(53, f.log10_ref()); let expected = 0.1761_f64; assert!((log10 - expected).abs() < 0.0001);
Computes the exponential.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp = Float::with_val(53, f.exp_ref()); let expected = 4.4817_f64; assert!((exp - expected).abs() < 0.0001);
Computes 2 to the power of the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp2 = Float::with_val(53, f.exp2_ref()); let expected = 2.8284_f64; assert!((exp2 - expected).abs() < 0.0001);
Computes 10 to the power of the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp10 = Float::with_val(53, f.exp10_ref()); let expected = 31.6228_f64; assert!((exp10 - expected).abs() < 0.0001);
Computes the sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sin = Float::with_val(53, f.sin_ref()); let expected = 0.9490_f64; assert!((sin - expected).abs() < 0.0001);
Computes the cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cos = Float::with_val(53, f.cos_ref()); let expected = 0.3153_f64; assert!((cos - expected).abs() < 0.0001);
Computes the tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tan = Float::with_val(53, f.tan_ref()); let expected = 3.0096_f64; assert!((tan - expected).abs() < 0.0001);
Computes the sine and cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Float, Float)
Assign<Src> for (&mut Float, &mut Float)
AssignRound<Src> for (Float, Float)
AssignRound<Src> for (&mut Float, &mut Float)
Examples
use core::cmp::Ordering; use rug::{float::Round, ops::AssignRound, Assign, Float}; let phase = Float::with_val(53, 1.25); let (mut sin, mut cos) = (Float::new(53), Float::new(53)); let sin_cos = phase.sin_cos_ref(); (&mut sin, &mut cos).assign(sin_cos); let expected_sin = 0.9490_f64; let expected_cos = 0.3153_f64; assert!((sin - expected_sin).abs() < 0.0001); assert!((cos - expected_cos).abs() < 0.0001); // using 4 significant bits: sin = 0.9375 // using 4 significant bits: cos = 0.3125 let (mut sin_4, mut cos_4) = (Float::new(4), Float::new(4)); let sin_cos = phase.sin_cos_ref(); let (dir_sin, dir_cos) = (&mut sin_4, &mut cos_4) .assign_round(sin_cos, Round::Nearest); assert_eq!(sin_4, 0.9375); assert_eq!(dir_sin, Ordering::Less); assert_eq!(cos_4, 0.3125); assert_eq!(dir_cos, Ordering::Less);
Computes the secant.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sec = Float::with_val(53, f.sec_ref()); let expected = 3.1714_f64; assert!((sec - expected).abs() < 0.0001);
Computes the cosecant.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csc = Float::with_val(53, f.csc_ref()); let expected = 1.0538_f64; assert!((csc - expected).abs() < 0.0001);
Computes the cotangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cot = Float::with_val(53, f.cot_ref()); let expected = 0.3323_f64; assert!((cot - expected).abs() < 0.0001);
Computes the arc-sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let asin = Float::with_val(53, f.asin_ref()); let expected = -0.8481_f64; assert!((asin - expected).abs() < 0.0001);
Computes the arc-cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let acos = Float::with_val(53, f.acos_ref()); let expected = 2.4189_f64; assert!((acos - expected).abs() < 0.0001);
Computes the arc-tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let atan = Float::with_val(53, f.atan_ref()); let expected = -0.6435_f64; assert!((atan - expected).abs() < 0.0001);
Computes the arc-tangent.
This is similar to the arc-tangent of self / x
, but has an output
range of 2π rather than π.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let y = Float::with_val(53, 3.0); let x = Float::with_val(53, -4.0); let r = y.atan2_ref(&x); let atan2 = Float::with_val(53, r); let expected = 2.4981_f64; assert!((atan2 - expected).abs() < 0.0001);
Computes the hyperbolic sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sinh = Float::with_val(53, f.sinh_ref()); let expected = 1.6019_f64; assert!((sinh - expected).abs() < 0.0001);
Computes the hyperbolic cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cosh = Float::with_val(53, f.cosh_ref()); let expected = 1.8884_f64; assert!((cosh - expected).abs() < 0.0001);
Computes the hyperbolic tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tanh = Float::with_val(53, f.tanh_ref()); let expected = 0.8483_f64; assert!((tanh - expected).abs() < 0.0001);
Computes the hyperbolic sine and cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Float, Float)
Assign<Src> for (&mut Float, &mut Float)
AssignRound<Src> for (Float, Float)
AssignRound<Src> for (&mut Float, &mut Float)
Examples
use core::cmp::Ordering; use rug::{float::Round, ops::AssignRound, Assign, Float}; let phase = Float::with_val(53, 1.25); let (mut sinh, mut cosh) = (Float::new(53), Float::new(53)); let sinh_cosh = phase.sinh_cosh_ref(); (&mut sinh, &mut cosh).assign(sinh_cosh); let expected_sinh = 1.6019_f64; let expected_cosh = 1.8884_f64; assert!((sinh - expected_sinh).abs() < 0.0001); assert!((cosh - expected_cosh).abs() < 0.0001); // using 4 significant bits: sin = 1.625 // using 4 significant bits: cos = 1.875 let (mut sinh_4, mut cosh_4) = (Float::new(4), Float::new(4)); let sinh_cosh = phase.sinh_cosh_ref(); let (dir_sinh, dir_cosh) = (&mut sinh_4, &mut cosh_4) .assign_round(sinh_cosh, Round::Nearest); assert_eq!(sinh_4, 1.625); assert_eq!(dir_sinh, Ordering::Greater); assert_eq!(cosh_4, 1.875); assert_eq!(dir_cosh, Ordering::Less);
Computes the hyperbolic secant.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sech = Float::with_val(53, f.sech_ref()); let expected = 0.5295_f64; assert!((sech - expected).abs() < 0.0001);
Computes the hyperbolic cosecant.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csch = Float::with_val(53, f.csch_ref()); let expected = 0.6243_f64; assert!((csch - expected).abs() < 0.0001);
Computes the hyperbolic cotangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let coth = Float::with_val(53, f.coth_ref()); let expected = 1.1789_f64; assert!((coth - expected).abs() < 0.0001);
Computes the inverse hyperbolic sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let asinh = Float::with_val(53, f.asinh_ref()); let expected = 1.0476_f64; assert!((asinh - expected).abs() < 0.0001);
Computes the inverse hyperbolic cosine
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let acosh = Float::with_val(53, f.acosh_ref()); let expected = 0.6931_f64; assert!((acosh - expected).abs() < 0.0001);
Computes the inverse hyperbolic tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 0.75); let atanh = Float::with_val(53, f.atanh_ref()); let expected = 0.9730_f64; assert!((atanh - expected).abs() < 0.0001);
Computes the natural logorithm of one plus the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let ln_1p = Float::with_val(53, f.ln_1p_ref()); let expected = 1.4989_f64 * two_to_m10; assert!((ln_1p - expected).abs() < 0.0001 * two_to_m10);
Computes one less than the exponential of the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let exp_m1 = Float::with_val(53, f.exp_m1_ref()); let expected = 1.5011_f64 * two_to_m10; assert!((exp_m1 - expected).abs() < 0.0001 * two_to_m10);
Computes the exponential integral.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let eint = Float::with_val(53, f.eint_ref()); let expected = 2.5810_f64; assert!((eint - expected).abs() < 0.0001);
Computes the real part of the dilogarithm of the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let li2 = Float::with_val(53, f.li2_ref()); let expected = 2.1902_f64; assert!((li2 - expected).abs() < 0.0001);
Computes the gamma function on the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let gamma = Float::with_val(53, f.gamma_ref()); let expected = 0.9064_f64; assert!((gamma - expected).abs() < 0.0001);
Computes the upper incomplete gamma function on the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let x = Float::with_val(53, 2.5); let gamma_inc = Float::with_val(53, f.gamma_inc_ref(&x)); let expected = 0.1116_f64; assert!((gamma_inc - expected).abs() < 0.0001);
Computes the logarithm of the gamma function on the value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ln_gamma = Float::with_val(53, f.ln_gamma_ref()); let expected = -0.0983_f64; assert!((ln_gamma - expected).abs() < 0.0001);
Computes the logarithm of the absolute value of the gamma function on
val
.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Float, Ordering)
Assign<Src> for (&mut Float, &mut Ordering)
AssignRound<Src> for (Float, Ordering)
AssignRound<Src> for (&mut Float, &mut Ordering)
Examples
use core::cmp::Ordering; use rug::{float::Constant, Assign, Float}; let neg1_2 = Float::with_val(53, -0.5); // gamma of −1/2 is −2√π let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32; let ln_gamma_64 = abs_gamma_64.ln(); // Assign rounds to the nearest let r = neg1_2.ln_abs_gamma_ref(); let (mut f, mut sign) = (Float::new(53), Ordering::Equal); (&mut f, &mut sign).assign(r); // gamma of −1/2 is negative assert_eq!(sign, Ordering::Less); // check to 53 significant bits assert_eq!(f, Float::with_val(53, &ln_gamma_64));
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
Rounds to the nearest integer, rounding half-way cases away from zero. The result may be rounded again when assigned to the target.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
AssignRound<Src> for Float
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let round1 = Float::with_val(53, f1.round_ref()); assert_eq!(round1, -24); let f2 = Float::with_val(53, 23.75); let round2 = Float::with_val(53, f2.round_ref()); assert_eq!(round2, 24);
Double rounding may happen when assigning to a target with a precision less than the number of significant bits for the truncated integer.
use rug::{float::Round, Float}; use rug::ops::AssignRound; let f = Float::with_val(53, 6.5); // 6.5 (binary 110.1) is rounded to 7 (binary 111) let r = f.round_ref(); // use only 2 bits of precision in destination let mut dst = Float::new(2); // 7 (binary 111) is rounded to 8 (binary 1000) by // round-even rule in order to store in 2-bit Float, even // though 6 (binary 110) is closer to original 6.5). dst.assign_round(r, Round::Nearest); assert_eq!(dst, 8);
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);
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);
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);
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);
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for SmallFloat
impl !Sync for SmallFloat
impl Unpin for SmallFloat
impl UnwindSafe for SmallFloat
Blanket Implementations
Mutably borrows from an owned value. Read more
Casts the value.
Casts the value.
Casts the value.
Casts the value.
Casts the value.