Struct rug::float::SmallFloat [−][src]
#[repr(C)]pub struct SmallFloat { /* fields omitted */ }
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
: (if supported by the compiler) 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.
The SmallFloat
type can be coerced to a Float
, as it implements
Deref<Target = Float>
.
Examples
use rug::float::SmallFloat; use rug::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);
Methods
impl SmallFloat
[src]
impl SmallFloat
pub unsafe fn as_nonreallocating_float(&mut self) -> &mut Float
[src]
pub unsafe fn as_nonreallocating_float(&mut self) -> &mut Float
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 behaviour to 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>
pub fn prec(&self) -> u32
[src]
pub fn prec(&self) -> u32
pub fn as_raw(&self) -> *const mpfr_t
[src]
pub fn as_raw(&self) -> *const mpfr_t
Returns a pointer to the inner MPFR floating-point number.
The returned pointer will be valid for as long as self
is
valid.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::mpfr; use rug::Float; fn main() { let f = Float::with_val(53, -14.5); let m_ptr = f.as_raw(); unsafe { let d = mpfr::get_d(m_ptr, mpfr::rnd_t::RNDN); assert_eq!(d, -14.5); } // f is still valid assert_eq!(f, -14.5); }
pub fn to_integer(&self) -> Option<Integer>
[src]
pub fn to_integer(&self) -> Option<Integer>
If the value is a finite number, converts it to
an Integer
rounding to the nearest.
Examples
use rug::Float; let f = Float::with_val(53, 13.7); let i = match f.to_integer() { Some(i) => i, None => unreachable!(), }; assert_eq!(i, 14);
pub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>
[src]
pub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>
If the value is a finite number, converts it to
an Integer
applying the specified rounding method.
Examples
use rug::float::Round; use rug::Float; use std::cmp::Ordering; let f = Float::with_val(53, 13.7); let (i, dir) = match f.to_integer_round(Round::Down) { Some(i_dir) => i_dir, None => unreachable!(), }; assert_eq!(i, 13); assert_eq!(dir, Ordering::Less);
pub fn to_integer_exp(&self) -> Option<(Integer, i32)>
[src]
pub fn to_integer_exp(&self) -> Option<(Integer, i32)>
If the value is a finite number, returns an
Integer
and exponent such that it is exactly equal to the
integer multiplied by two raised to the power of the exponent.
Examples
use rug::float::Special; use rug::{Assign, Float}; let mut float = Float::with_val(16, 6.5); // 6.5 in binary is 110.1 // Since the precision is 16 bits, this becomes // 1101_0000_0000_0000 times two to the power of -12 let (int, exp) = float.to_integer_exp().unwrap(); assert_eq!(int, 0b1101_0000_0000_0000); assert_eq!(exp, -13); float.assign(0); let (zero, _) = float.to_integer_exp().unwrap(); assert_eq!(zero, 0); float.assign(Special::Infinity); assert!(float.to_integer_exp().is_none());
pub fn to_rational(&self) -> Option<Rational>
[src]
pub fn to_rational(&self) -> Option<Rational>
If the value is a finite number, returns a
Rational
number preserving all the precision of the value.
If the compiler supports TryFrom
, this conversion can also
be performed using Rational::try_from(&float)
or
Rational::try_from(float)
.
Examples
use rug::float::Round; use rug::{Float, Rational}; use std::cmp::Ordering; use std::str::FromStr; // Consider the number 123,456,789 / 10,000,000,000. let parse = Float::parse("0.0123456789").unwrap(); let (f, f_rounding) = Float::with_val_round(35, parse, Round::Down); assert_eq!(f_rounding, Ordering::Less); let r = Rational::from_str("123456789/10000000000").unwrap(); // Set fr to the value of f exactly. let fr = f.to_rational().unwrap(); // Since f == fr and f was rounded down, r != fr. assert_ne!(r, fr); let (frf, frf_rounding) = Float::with_val_round(35, &fr, Round::Down); assert_eq!(frf_rounding, Ordering::Equal); assert_eq!(frf, f); assert_eq!(format!("{:.9}", frf), "1.23456789e-2");
In the following example, the Float
values can be
represented exactly.
use rug::Float; let large_f = Float::with_val(16, 6.5); let large_r = large_f.to_rational().unwrap(); let small_f = Float::with_val(16, -0.125); let small_r = small_f.to_rational().unwrap(); assert_eq!(*large_r.numer(), 13); assert_eq!(*large_r.denom(), 2); assert_eq!(*small_r.numer(), -1); assert_eq!(*small_r.denom(), 8);
pub fn to_i32_saturating(&self) -> Option<i32>
[src]
pub fn to_i32_saturating(&self) -> Option<i32>
Converts to an i32
, rounding to the nearest.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::{Assign, Float}; use std::{i32, u32}; let mut f = Float::with_val(53, -13.7); assert_eq!(f.to_i32_saturating(), Some(-14)); f.assign(-1e40); assert_eq!(f.to_i32_saturating(), Some(i32::MIN)); f.assign(u32::MAX); assert_eq!(f.to_i32_saturating(), Some(i32::MAX));
pub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>
[src]
pub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>
Converts to an i32
, applying the specified rounding method.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::float::Round; use rug::Float; let f = Float::with_val(53, -13.7); assert_eq!(f.to_i32_saturating_round(Round::Up), Some(-13));
pub fn to_u32_saturating(&self) -> Option<u32>
[src]
pub fn to_u32_saturating(&self) -> Option<u32>
Converts to a u32
, rounding to the nearest.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::{Assign, Float}; use std::u32; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_u32_saturating(), Some(14)); f.assign(-1); assert_eq!(f.to_u32_saturating(), Some(0)); f.assign(1e40); assert_eq!(f.to_u32_saturating(), Some(u32::MAX));
pub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>
[src]
pub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>
Converts to a u32
, applying the specified rounding method.
If the value is too small or too large for the target type,
the minimum or maximum value allowed is returned.
If the value is a NaN, None
is returned.
Examples
use rug::float::Round; use rug::Float; let f = Float::with_val(53, 13.7); assert_eq!(f.to_u32_saturating_round(Round::Down), Some(13));
pub fn to_f32(&self) -> f32
[src]
pub fn to_f32(&self) -> f32
Converts to an f32
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::{Assign, Float}; use std::f32; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_f32(), 13.7); f.assign(1e300); assert_eq!(f.to_f32(), f32::INFINITY); f.assign(1e-300); assert_eq!(f.to_f32(), 0.0);
pub fn to_f32_round(&self, round: Round) -> f32
[src]
pub fn to_f32_round(&self, round: Round) -> f32
Converts to an f32
, applying the specified rounding
method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; use std::f32; let f = Float::with_val(53, 1.0 + (-50f64).exp2()); assert_eq!(f.to_f32_round(Round::Up), 1.0 + f32::EPSILON);
pub fn to_f64(&self) -> f64
[src]
pub fn to_f64(&self) -> f64
Converts to an f64
, rounding to the nearest.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::{Assign, Float}; use std::f64; let mut f = Float::with_val(53, 13.7); assert_eq!(f.to_f64(), 13.7); f.assign(1e300); f.square_mut(); assert_eq!(f.to_f64(), f64::INFINITY);
pub fn to_f64_round(&self, round: Round) -> f64
[src]
pub fn to_f64_round(&self, round: Round) -> f64
Converts to an f64
, applying the specified rounding
method.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; use std::f64; // (2.0 ^ -90) + 1 let f: Float = Float::with_val(100, -90).exp2() + 1; assert_eq!(f.to_f64_round(Round::Up), 1.0 + f64::EPSILON);
pub fn to_f32_exp(&self) -> (f32, i32)
[src]
pub fn to_f32_exp(&self) -> (f32, i32)
Converts to an f32
and an exponent, rounding to the
nearest.
The returned f32
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::Float; let zero = Float::new(64); let (d0, exp0) = zero.to_f32_exp(); assert_eq!((d0, exp0), (0.0, 0)); let three_eighths = Float::with_val(64, 0.375); let (d3_8, exp3_8) = three_eighths.to_f32_exp(); assert_eq!((d3_8, exp3_8), (0.75, -1));
pub fn to_f32_exp_round(&self, round: Round) -> (f32, i32)
[src]
pub fn to_f32_exp_round(&self, round: Round) -> (f32, i32)
Converts to an f32
and an exponent, applying the specified
rounding method.
The returned f32
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; let frac_10_3 = Float::with_val(64, 10) / 3u32; let (f_down, exp_down) = frac_10_3.to_f32_exp_round(Round::Down); assert_eq!((f_down, exp_down), (0.8333333, 2)); let (f_up, exp_up) = frac_10_3.to_f32_exp_round(Round::Up); assert_eq!((f_up, exp_up), (0.8333334, 2));
pub fn to_f64_exp(&self) -> (f64, i32)
[src]
pub fn to_f64_exp(&self) -> (f64, i32)
Converts to an f64
and an exponent, rounding to the
nearest.
The returned f64
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::Float; let zero = Float::new(64); let (d0, exp0) = zero.to_f64_exp(); assert_eq!((d0, exp0), (0.0, 0)); let three_eighths = Float::with_val(64, 0.375); let (d3_8, exp3_8) = three_eighths.to_f64_exp(); assert_eq!((d3_8, exp3_8), (0.75, -1));
pub fn to_f64_exp_round(&self, round: Round) -> (f64, i32)
[src]
pub fn to_f64_exp_round(&self, round: Round) -> (f64, i32)
Converts to an f64
and an exponent, applying the specified
rounding method.
The returned f64
is in the range 0.5 ≤ x < 1.
If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.
Examples
use rug::float::Round; use rug::Float; let frac_10_3 = Float::with_val(64, 10) / 3u32; let (f_down, exp_down) = frac_10_3.to_f64_exp_round(Round::Down); assert_eq!((f_down, exp_down), (0.8333333333333333, 2)); let (f_up, exp_up) = frac_10_3.to_f64_exp_round(Round::Up); assert_eq!((f_up, exp_up), (0.8333333333333334, 2));
pub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
[src]
pub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
Returns a string representation of self
for the specified
radix
rounding to the nearest.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::float::Special; use rug::Float; let neg_inf = Float::with_val(53, Special::NegInfinity); assert_eq!(neg_inf.to_string_radix(10, None), "-inf"); assert_eq!(neg_inf.to_string_radix(16, None), "-@inf@"); let twentythree = Float::with_val(8, 23); assert_eq!(twentythree.to_string_radix(10, None), "2.300e1"); assert_eq!(twentythree.to_string_radix(16, None), "1.70@1"); assert_eq!(twentythree.to_string_radix(10, Some(2)), "2.3e1"); assert_eq!(twentythree.to_string_radix(16, Some(4)), "1.700@1");
pub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: Round
) -> String
[src]
pub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: Round
) -> String
Returns a string representation of self
for the specified
radix
applying the specified rounding method.
The exponent is encoded in decimal. The output string will have enough precision such that reading it again will give the exact same number.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::float::Round; use rug::Float; let twentythree = Float::with_val(8, 23.3); let down = twentythree.to_string_radix_round(10, Some(2), Round::Down); assert_eq!(down, "2.3e1"); let up = twentythree.to_string_radix_round(10, Some(2), Round::Up); assert_eq!(up, "2.4e1");
pub fn as_neg(&self) -> BorrowFloat
[src]
pub fn as_neg(&self) -> BorrowFloat
Borrows a negated copy of the Float
.
The returned object implements
Deref<Target = Float>
.
This method performs a shallow copy and negates it, and negation does not change the allocated data.
Examples
use rug::Float; let f = Float::with_val(53, 4.2); let neg_f = f.as_neg(); assert_eq!(*neg_f, -4.2); // methods taking &self can be used on the returned object let reneg_f = neg_f.as_neg(); assert_eq!(*reneg_f, 4.2); assert_eq!(*reneg_f, f);
pub fn as_abs(&self) -> BorrowFloat
[src]
pub fn as_abs(&self) -> BorrowFloat
Borrows an absolute copy of the Float
.
The returned object implements
Deref<Target = Float>
.
This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.
Examples
use rug::Float; let f = Float::with_val(53, -4.2); let abs_f = f.as_abs(); assert_eq!(*abs_f, 4.2); // methods taking &self can be used on the returned object let reabs_f = abs_f.as_abs(); assert_eq!(*reabs_f, 4.2); assert_eq!(*reabs_f, *abs_f);
pub fn as_ord(&self) -> &OrdFloat
[src]
pub fn as_ord(&self) -> &OrdFloat
Borrows the Float
as an ordered floating-point number of
type OrdFloat
.
Examples
use rug::float::Special; use rug::Float; use std::cmp::Ordering; let nan_f = Float::with_val(53, Special::Nan); let nan = nan_f.as_ord(); assert_eq!(nan.cmp(nan), Ordering::Equal); let neg_inf_f = Float::with_val(53, Special::NegInfinity); let neg_inf = neg_inf_f.as_ord(); assert_eq!(nan.cmp(neg_inf), Ordering::Less); let zero_f = Float::with_val(53, Special::Zero); let zero = zero_f.as_ord(); let neg_zero_f = Float::with_val(53, Special::NegZero); let neg_zero = neg_zero_f.as_ord(); assert_eq!(zero.cmp(neg_zero), Ordering::Greater);
pub fn is_integer(&self) -> bool
[src]
pub fn is_integer(&self) -> bool
Returns true
if self
is an integer.
Examples
use rug::Float; let mut f = Float::with_val(53, 13.5); assert!(!f.is_integer()); f *= 2; assert!(f.is_integer());
pub fn is_nan(&self) -> bool
[src]
pub fn is_nan(&self) -> bool
Returns true
if self
is not a number.
Examples
use rug::Float; let mut f = Float::with_val(53, 0); assert!(!f.is_nan()); f /= 0; assert!(f.is_nan());
pub fn is_infinite(&self) -> bool
[src]
pub fn is_infinite(&self) -> bool
Returns true
if self
is plus or minus infinity.
Examples
use rug::Float; let mut f = Float::with_val(53, 1); assert!(!f.is_infinite()); f /= 0; assert!(f.is_infinite());
pub fn is_finite(&self) -> bool
[src]
pub fn is_finite(&self) -> bool
Returns true
if self
is a finite number, that is neither
NaN nor infinity.
Examples
use rug::Float; let mut f = Float::with_val(53, 1); assert!(f.is_finite()); f /= 0; assert!(!f.is_finite());
pub fn is_zero(&self) -> bool
[src]
pub fn is_zero(&self) -> bool
Returns true
if self
is plus or minus zero.
Examples
use rug::float::Special; use rug::{Assign, Float}; let mut f = Float::with_val(53, Special::Zero); assert!(f.is_zero()); f.assign(Special::NegZero); assert!(f.is_zero()); f += 1; assert!(!f.is_zero());
pub fn is_normal(&self) -> bool
[src]
pub fn is_normal(&self) -> bool
Returns true
if self
is a normal number, that is neither
NaN, nor infinity, nor zero. Note that Float
cannot be
subnormal.
Examples
use rug::float::Special; use rug::{Assign, Float}; let mut f = Float::with_val(53, Special::Zero); assert!(!f.is_normal()); f += 5.2; assert!(f.is_normal()); f.assign(Special::Infinity); assert!(!f.is_normal()); f.assign(Special::Nan); assert!(!f.is_normal());
pub fn classify(&self) -> FpCategory
[src]
pub fn classify(&self) -> FpCategory
Returns the floating-point category of the number. Note that
Float
cannot be subnormal.
Examples
use rug::float::Special; use rug::Float; use std::num::FpCategory; let nan = Float::with_val(53, Special::Nan); let infinite = Float::with_val(53, Special::Infinity); let zero = Float::with_val(53, Special::Zero); let normal = Float::with_val(53, 2.3); assert_eq!(nan.classify(), FpCategory::Nan); assert_eq!(infinite.classify(), FpCategory::Infinite); assert_eq!(zero.classify(), FpCategory::Zero); assert_eq!(normal.classify(), FpCategory::Normal);
pub fn cmp0(&self) -> Option<Ordering>
[src]
pub fn cmp0(&self) -> Option<Ordering>
Returns the same result as
self.partial_cmp(&0)
, but is faster.
Examples
use rug::float::Special; use rug::{Assign, Float}; use std::cmp::Ordering; let mut f = Float::with_val(53, Special::NegZero); assert_eq!(f.cmp0(), Some(Ordering::Equal)); f += 5.2; assert_eq!(f.cmp0(), Some(Ordering::Greater)); f.assign(Special::NegInfinity); assert_eq!(f.cmp0(), Some(Ordering::Less)); f.assign(Special::Nan); assert_eq!(f.cmp0(), None);
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
[src]
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
Compares the absolute values of self
and other
.
Examples
use rug::Float; use std::cmp::Ordering; let a = Float::with_val(53, -10); let b = Float::with_val(53, 4); assert_eq!(a.partial_cmp(&b), Some(Ordering::Less)); assert_eq!(a.cmp_abs(&b), Some(Ordering::Greater));
pub fn get_exp(&self) -> Option<i32>
[src]
pub fn get_exp(&self) -> Option<i32>
If the value is a normal number, returns its exponent.
The significand is assumed to be in the range 0.5 ≤ x < 1.
Examples
use rug::{Assign, Float}; // -(2.0 ^ 32) == -(0.5 * 2 ^ 33) let mut f = Float::with_val(53, -32f64.exp2()); assert_eq!(f.get_exp(), Some(33)); // 0.8 * 2 ^ -39 f.assign(0.8 * (-39f64).exp2()); assert_eq!(f.get_exp(), Some(-39)); f.assign(0); assert_eq!(f.get_exp(), None);
pub fn get_significand(&self) -> Option<BorrowInteger>
[src]
pub fn get_significand(&self) -> Option<BorrowInteger>
If the value is a normal number, returns a
reference to its significand as an Integer
.
The unwrapped returned object implements
Deref<Target = Integer>
.
The number of significant bits of a
returned significand is at least equal to the
precision, but can be larger. It is usually rounded
up to a multiple of 32 or 64 depending on the implementation;
in this case, the extra least significant bits will be zero.
The value of self
is exactly equal to the returned
Integer
divided by two raised to the power of the number
of significant bits and multiplied by
two raised to the power of the exponent of
self
.
Unlike the to_integer_exp
method which returns an owned
Integer
, this method only performs a shallow copy and does
not allocate any memory.
Examples
use rug::Float; let float = Float::with_val(16, 6.5); // 6.5 in binary is 110.1 = 0.1101 times two to the power of 3 let exp = float.get_exp().unwrap(); assert_eq!(exp, 3); let significand = float.get_significand().unwrap(); let sig_bits = significand.significant_bits(); // sig_bits must be greater or equal to precision assert!(sig_bits >= 16); let (check_int, check_exp) = float.to_integer_exp().unwrap(); assert_eq!(check_int << sig_bits << (check_exp - exp), *significand);
pub fn is_sign_positive(&self) -> bool
[src]
pub fn is_sign_positive(&self) -> bool
Returns true
if the value is positive, +0 or NaN without a
negative sign.
Examples
use rug::Float; let pos = Float::with_val(53, 1.0); let neg = Float::with_val(53, -1.0); assert!(pos.is_sign_positive()); assert!(!neg.is_sign_positive());
pub fn is_sign_negative(&self) -> bool
[src]
pub fn is_sign_negative(&self) -> bool
Returns true
if the value is negative, −0 or NaN with a
negative sign.
Examples
use rug::Float; let neg = Float::with_val(53, -1.0); let pos = Float::with_val(53, 1.0); assert!(neg.is_sign_negative()); assert!(!pos.is_sign_negative());
pub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
[src]
pub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
Multiplies and adds in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_add_ref(&b, &c)
produces the exact same result as
&a * &b + &c
.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let add = Float::with_val(4, 24); // 1.5 * -13 + 24 = 4.5 let ans = Float::with_val(4, mul1.mul_add_ref(&mul2, &add)); assert_eq!(ans, 4.5);
pub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
[src]
pub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
Multiplies and subtracts in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_sub_ref(&b, &c)
produces the exact same result as
&a * &b - &c
.
Examples
use rug::Float; // Use only 4 bits of precision for demonstration purposes. // 1.5 in binary is 1.1. let mul1 = Float::with_val(4, 1.5); // -13 in binary is -1101. let mul2 = Float::with_val(4, -13); // 24 in binary is 11000. let sub = Float::with_val(4, 24); // 1.5 * -13 - 24 = -43.5, rounded to 44 using four bits of precision. let ans = Float::with_val(4, mul1.mul_sub_ref(&mul2, &sub)); assert_eq!(ans, -44);
pub fn mul_add_mul_ref<'a>(
&'a self,
mul: &'a Self,
add_mul1: &'a Self,
add_mul2: &'a Self
) -> MulAddMulIncomplete<'a>
[src]
pub fn mul_add_mul_ref<'a>(
&'a self,
mul: &'a Self,
add_mul1: &'a Self,
add_mul2: &'a Self
) -> MulAddMulIncomplete<'a>
Multiplies two products and adds them in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_add_mul_ref(&b, &c, &d)
produces the exact same result
as &a * &b + &c * &d
.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 + 12 * 2 = 60 let ans = Float::with_val(53, a.mul_add_mul_ref(&b, &c, &d)); assert_eq!(ans, 60);
pub fn mul_sub_mul_ref<'a>(
&'a self,
mul: &'a Self,
sub_mul1: &'a Self,
sub_mul2: &'a Self
) -> MulSubMulIncomplete<'a>
[src]
pub fn mul_sub_mul_ref<'a>(
&'a self,
mul: &'a Self,
sub_mul1: &'a Self,
sub_mul2: &'a Self
) -> MulSubMulIncomplete<'a>
Multiplies two products and subtracts them in one fused operation.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
a.mul_sub_mul_ref(&b, &c, &d)
produces the exact same result
as &a * &b - &c * &d
.
Examples
use rug::Float; let a = Float::with_val(53, 24); let b = Float::with_val(53, 1.5); let c = Float::with_val(53, 12); let d = Float::with_val(53, 2); // 24 * 1.5 - 12 * 2 = 12 let ans = Float::with_val(53, a.mul_sub_mul_ref(&b, &c, &d)); assert_eq!(ans, 12);
pub fn square_ref(&self) -> SquareIncomplete
[src]
pub fn square_ref(&self) -> SquareIncomplete
Computes the square.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 5.0); let r = f.square_ref(); let square = Float::with_val(53, r); assert_eq!(square, 25.0);
pub fn sqrt_ref(&self) -> SqrtIncomplete
[src]
pub fn sqrt_ref(&self) -> SqrtIncomplete
Computes the square root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 25.0); let r = f.sqrt_ref(); let sqrt = Float::with_val(53, r); assert_eq!(sqrt, 5.0);
pub fn recip_sqrt_ref(&self) -> RecipSqrtIncomplete
[src]
pub fn recip_sqrt_ref(&self) -> RecipSqrtIncomplete
Computes the reciprocal square root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 16.0); let r = f.recip_sqrt_ref(); let recip_sqrt = Float::with_val(53, r); assert_eq!(recip_sqrt, 0.25);
pub fn cbrt_ref(&self) -> CbrtIncomplete
[src]
pub fn cbrt_ref(&self) -> CbrtIncomplete
Computes the cube root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 125.0); let r = f.cbrt_ref(); let cbrt = Float::with_val(53, r); assert_eq!(cbrt, 5.0);
pub fn root_ref(&self, k: u32) -> RootIncomplete
[src]
pub fn root_ref(&self, k: u32) -> RootIncomplete
Computes the kth root.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 625.0); let r = f.root_ref(4); let root = Float::with_val(53, r); assert_eq!(root, 5.0);
pub fn abs_ref(&self) -> AbsIncomplete
[src]
pub fn abs_ref(&self) -> AbsIncomplete
Computes the absolute value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let r = f.abs_ref(); let abs = Float::with_val(53, r); assert_eq!(abs, 23.5);
pub fn signum_ref(&self) -> SignumIncomplete
[src]
pub fn signum_ref(&self) -> SignumIncomplete
Computes the signum.
- 1.0 if the value is positive, +0.0 or +∞
- −1.0 if the value is negative, −0.0 or −∞
- NaN if the value is NaN
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -23.5); let r = f.signum_ref(); let signum = Float::with_val(53, r); assert_eq!(signum, -1);
pub fn clamp_ref<'a, Min, Max>(
&'a self,
min: &'a Min,
max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
[src]
pub fn clamp_ref<'a, Min, Max>(
&'a self,
min: &'a Min,
max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
Clamps the value within the specified bounds.
Assign<Src> for Float
and
AssignRound<Src> for Float
are implemented
with the returned incomplete-computation value as
Src
.
Panics
Panics if the maximum value is less than the minimum value, unless assigning any of them to the target produces the same value with the same rounding direction.
Examples
use rug::Float; let min = -1.5; let max = 1.5; let too_small = Float::with_val(53, -2.5); let r1 = too_small.clamp_ref(&min, &max); let clamped1 = Float::with_val(53, r1); assert_eq!(clamped1, -1.5); let in_range = Float::with_val(53, 0.5); let r2 = in_range.clamp_ref(&min, &max); let clamped2 = Float::with_val(53, r2); assert_eq!(clamped2, 0.5);
pub fn recip_ref(&self) -> RecipIncomplete
[src]
pub fn recip_ref(&self) -> RecipIncomplete
Computes the reciprocal.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.25); let r = f.recip_ref(); let recip = Float::with_val(53, r); assert_eq!(recip, -4.0);
pub fn min_ref<'a>(&'a self, other: &'a Self) -> MinIncomplete
[src]
pub fn min_ref<'a>(&'a self, other: &'a Self) -> MinIncomplete
Finds the minimum.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, -2); let r = a.min_ref(&b); let min = Float::with_val(53, r); assert_eq!(min, -2);
pub fn max_ref<'a>(&'a self, other: &'a Self) -> MaxIncomplete
[src]
pub fn max_ref<'a>(&'a self, other: &'a Self) -> MaxIncomplete
Finds the maximum.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let a = Float::with_val(53, 5.2); let b = Float::with_val(53, 12.5); let r = a.max_ref(&b); let max = Float::with_val(53, r); assert_eq!(max, 12.5);
pub fn positive_diff_ref<'a>(
&'a self,
other: &'a Self
) -> PositiveDiffIncomplete
[src]
pub fn positive_diff_ref<'a>(
&'a self,
other: &'a Self
) -> PositiveDiffIncomplete
Computes the positive difference.
The positive difference is self
− other
if self
>
other
, zero if self
≤ other
, or NaN if any operand
is NaN.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let a = Float::with_val(53, 12.5); let b = Float::with_val(53, 7.3); let rab = a.positive_diff_ref(&b); let ab = Float::with_val(53, rab); assert_eq!(ab, 5.2); let rba = b.positive_diff_ref(&a); let ba = Float::with_val(53, rba); assert_eq!(ba, 0);
pub fn ln_ref(&self) -> LnIncomplete
[src]
pub fn ln_ref(&self) -> LnIncomplete
Computes the natural logarithm.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let ln = Float::with_val(53, f.ln_ref()); let expected = 0.4055_f64; assert!((ln - expected).abs() < 0.0001);
pub fn log2_ref(&self) -> Log2Incomplete
[src]
pub fn log2_ref(&self) -> Log2Incomplete
Computes the logarithm to base 2.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log2 = Float::with_val(53, f.log2_ref()); let expected = 0.5850_f64; assert!((log2 - expected).abs() < 0.0001);
pub fn log10_ref(&self) -> Log10Incomplete
[src]
pub fn log10_ref(&self) -> Log10Incomplete
Computes the logarithm to base 10.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let log10 = Float::with_val(53, f.log10_ref()); let expected = 0.1761_f64; assert!((log10 - expected).abs() < 0.0001);
pub fn exp_ref(&self) -> ExpIncomplete
[src]
pub fn exp_ref(&self) -> ExpIncomplete
Computes the exponential.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp = Float::with_val(53, f.exp_ref()); let expected = 4.4817_f64; assert!((exp - expected).abs() < 0.0001);
pub fn exp2_ref(&self) -> Exp2Incomplete
[src]
pub fn exp2_ref(&self) -> Exp2Incomplete
Computes 2 to the power of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp2 = Float::with_val(53, f.exp2_ref()); let expected = 2.8284_f64; assert!((exp2 - expected).abs() < 0.0001);
pub fn exp10_ref(&self) -> Exp10Incomplete
[src]
pub fn exp10_ref(&self) -> Exp10Incomplete
Computes 10 to the power of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.5); let exp10 = Float::with_val(53, f.exp10_ref()); let expected = 31.6228_f64; assert!((exp10 - expected).abs() < 0.0001);
pub fn sin_ref(&self) -> SinIncomplete
[src]
pub fn sin_ref(&self) -> SinIncomplete
Computes the sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sin = Float::with_val(53, f.sin_ref()); let expected = 0.9490_f64; assert!((sin - expected).abs() < 0.0001);
pub fn cos_ref(&self) -> CosIncomplete
[src]
pub fn cos_ref(&self) -> CosIncomplete
Computes the cosine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cos = Float::with_val(53, f.cos_ref()); let expected = 0.3153_f64; assert!((cos - expected).abs() < 0.0001);
pub fn tan_ref(&self) -> TanIncomplete
[src]
pub fn tan_ref(&self) -> TanIncomplete
Computes the tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tan = Float::with_val(53, f.tan_ref()); let expected = 3.0096_f64; assert!((tan - expected).abs() < 0.0001);
pub fn sin_cos_ref(&self) -> SinCosIncomplete
[src]
pub fn sin_cos_ref(&self) -> SinCosIncomplete
Computes the sine and cosine.
Assign<Src> for (Float, Float)
,
Assign<Src> for (&mut Float, &mut Float)
,
AssignRound<Src> for (Float, Float)
and
AssignRound<Src> for (&mut Float, &mut Float)
are implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Float}; use rug::float::Round; use rug::ops::AssignRound; use std::cmp::Ordering; let phase = Float::with_val(53, 1.25); let (mut sin, mut cos) = (Float::new(53), Float::new(53)); let sin_cos = phase.sin_cos_ref(); (&mut sin, &mut cos).assign(sin_cos); let expected_sin = 0.9490_f64; let expected_cos = 0.3153_f64; assert!((sin - expected_sin).abs() < 0.0001); assert!((cos - expected_cos).abs() < 0.0001); // using 4 significant bits: sin = 0.9375 // using 4 significant bits: cos = 0.3125 let (mut sin_4, mut cos_4) = (Float::new(4), Float::new(4)); let sin_cos = phase.sin_cos_ref(); let (dir_sin, dir_cos) = (&mut sin_4, &mut cos_4) .assign_round(sin_cos, Round::Nearest); assert_eq!(sin_4, 0.9375); assert_eq!(dir_sin, Ordering::Less); assert_eq!(cos_4, 0.3125); assert_eq!(dir_cos, Ordering::Less);
pub fn sec_ref(&self) -> SecIncomplete
[src]
pub fn sec_ref(&self) -> SecIncomplete
Computes the secant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sec = Float::with_val(53, f.sec_ref()); let expected = 3.1714_f64; assert!((sec - expected).abs() < 0.0001);
pub fn csc_ref(&self) -> CscIncomplete
[src]
pub fn csc_ref(&self) -> CscIncomplete
Computes the cosecant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csc = Float::with_val(53, f.csc_ref()); let expected = 1.0538_f64; assert!((csc - expected).abs() < 0.0001);
pub fn cot_ref(&self) -> CotIncomplete
[src]
pub fn cot_ref(&self) -> CotIncomplete
Computes the cotangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cot = Float::with_val(53, f.cot_ref()); let expected = 0.3323_f64; assert!((cot - expected).abs() < 0.0001);
pub fn asin_ref(&self) -> AsinIncomplete
[src]
pub fn asin_ref(&self) -> AsinIncomplete
Computes the arc-sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let asin = Float::with_val(53, f.asin_ref()); let expected = -0.8481_f64; assert!((asin - expected).abs() < 0.0001);
pub fn acos_ref(&self) -> AcosIncomplete
[src]
pub fn acos_ref(&self) -> AcosIncomplete
Computes the arc-cosine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let acos = Float::with_val(53, f.acos_ref()); let expected = 2.4189_f64; assert!((acos - expected).abs() < 0.0001);
pub fn atan_ref(&self) -> AtanIncomplete
[src]
pub fn atan_ref(&self) -> AtanIncomplete
Computes the arc-tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, -0.75); let atan = Float::with_val(53, f.atan_ref()); let expected = -0.6435_f64; assert!((atan - expected).abs() < 0.0001);
pub fn atan2_ref<'a>(&'a self, x: &'a Self) -> Atan2Incomplete
[src]
pub fn atan2_ref<'a>(&'a self, x: &'a Self) -> Atan2Incomplete
Computes the arc-tangent.
This is similar to the arc-tangent of self / x
, but
has an output range of 2π rather than π.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let y = Float::with_val(53, 3.0); let x = Float::with_val(53, -4.0); let r = y.atan2_ref(&x); let atan2 = Float::with_val(53, r); let expected = 2.4981_f64; assert!((atan2 - expected).abs() < 0.0001);
pub fn sinh_ref(&self) -> SinhIncomplete
[src]
pub fn sinh_ref(&self) -> SinhIncomplete
Computes the hyperbolic sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sinh = Float::with_val(53, f.sinh_ref()); let expected = 1.6019_f64; assert!((sinh - expected).abs() < 0.0001);
pub fn cosh_ref(&self) -> CoshIncomplete
[src]
pub fn cosh_ref(&self) -> CoshIncomplete
Computes the hyperbolic cosine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let cosh = Float::with_val(53, f.cosh_ref()); let expected = 1.8884_f64; assert!((cosh - expected).abs() < 0.0001);
pub fn tanh_ref(&self) -> TanhIncomplete
[src]
pub fn tanh_ref(&self) -> TanhIncomplete
Computes the hyperbolic tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let tanh = Float::with_val(53, f.tanh_ref()); let expected = 0.8483_f64; assert!((tanh - expected).abs() < 0.0001);
pub fn sinh_cosh_ref(&self) -> SinhCoshIncomplete
[src]
pub fn sinh_cosh_ref(&self) -> SinhCoshIncomplete
Computes the hyperbolic sine and cosine.
Assign<Src> for (Float, Float)
,
Assign<Src> for (&mut Float, &mut Float)
,
AssignRound<Src> for (Float, Float)
and
AssignRound<Src> for (&mut Float, &mut Float)
are implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Float}; use rug::float::Round; use rug::ops::AssignRound; use std::cmp::Ordering; let phase = Float::with_val(53, 1.25); let (mut sinh, mut cosh) = (Float::new(53), Float::new(53)); let sinh_cosh = phase.sinh_cosh_ref(); (&mut sinh, &mut cosh).assign(sinh_cosh); let expected_sinh = 1.6019_f64; let expected_cosh = 1.8884_f64; assert!((sinh - expected_sinh).abs() < 0.0001); assert!((cosh - expected_cosh).abs() < 0.0001); // using 4 significant bits: sin = 1.625 // using 4 significant bits: cos = 1.875 let (mut sinh_4, mut cosh_4) = (Float::new(4), Float::new(4)); let sinh_cosh = phase.sinh_cosh_ref(); let (dir_sinh, dir_cosh) = (&mut sinh_4, &mut cosh_4) .assign_round(sinh_cosh, Round::Nearest); assert_eq!(sinh_4, 1.625); assert_eq!(dir_sinh, Ordering::Greater); assert_eq!(cosh_4, 1.875); assert_eq!(dir_cosh, Ordering::Less);
pub fn sech_ref(&self) -> SechIncomplete
[src]
pub fn sech_ref(&self) -> SechIncomplete
Computes the hyperbolic secant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let sech = Float::with_val(53, f.sech_ref()); let expected = 0.5295_f64; assert!((sech - expected).abs() < 0.0001);
pub fn csch_ref(&self) -> CschIncomplete
[src]
pub fn csch_ref(&self) -> CschIncomplete
Computes the hyperbolic cosecant.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let csch = Float::with_val(53, f.csch_ref()); let expected = 0.6243_f64; assert!((csch - expected).abs() < 0.0001);
pub fn coth_ref(&self) -> CothIncomplete
[src]
pub fn coth_ref(&self) -> CothIncomplete
Computes the hyperbolic cotangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let coth = Float::with_val(53, f.coth_ref()); let expected = 1.1789_f64; assert!((coth - expected).abs() < 0.0001);
pub fn asinh_ref(&self) -> AsinhIncomplete
[src]
pub fn asinh_ref(&self) -> AsinhIncomplete
Computes the inverse hyperbolic sine.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let asinh = Float::with_val(53, f.asinh_ref()); let expected = 1.0476_f64; assert!((asinh - expected).abs() < 0.0001);
pub fn acosh_ref(&self) -> AcoshIncomplete
[src]
pub fn acosh_ref(&self) -> AcoshIncomplete
Computes the inverse hyperbolic cosine
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let acosh = Float::with_val(53, f.acosh_ref()); let expected = 0.6931_f64; assert!((acosh - expected).abs() < 0.0001);
pub fn atanh_ref(&self) -> AtanhIncomplete
[src]
pub fn atanh_ref(&self) -> AtanhIncomplete
Computes the inverse hyperbolic tangent.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 0.75); let atanh = Float::with_val(53, f.atanh_ref()); let expected = 0.9730_f64; assert!((atanh - expected).abs() < 0.0001);
pub fn ln_1p_ref(&self) -> Ln1pIncomplete
[src]
pub fn ln_1p_ref(&self) -> Ln1pIncomplete
Computes the natural logorithm of one plus the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let ln_1p = Float::with_val(53, f.ln_1p_ref()); let expected = 1.4989_f64 * two_to_m10; assert!((ln_1p - expected).abs() < 0.0001 * two_to_m10);
pub fn exp_m1_ref(&self) -> ExpM1Incomplete
[src]
pub fn exp_m1_ref(&self) -> ExpM1Incomplete
Computes one less than the exponential of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let two_to_m10 = (-10f64).exp2(); let f = Float::with_val(53, 1.5 * two_to_m10); let exp_m1 = Float::with_val(53, f.exp_m1_ref()); let expected = 1.5011_f64 * two_to_m10; assert!((exp_m1 - expected).abs() < 0.0001 * two_to_m10);
pub fn eint_ref(&self) -> EintIncomplete
[src]
pub fn eint_ref(&self) -> EintIncomplete
Computes the exponential integral.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let eint = Float::with_val(53, f.eint_ref()); let expected = 2.5810_f64; assert!((eint - expected).abs() < 0.0001);
pub fn li2_ref(&self) -> Li2Incomplete
[src]
pub fn li2_ref(&self) -> Li2Incomplete
Computes the real part of the dilogarithm of the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let li2 = Float::with_val(53, f.li2_ref()); let expected = 2.1902_f64; assert!((li2 - expected).abs() < 0.0001);
pub fn gamma_ref(&self) -> GammaIncomplete
[src]
pub fn gamma_ref(&self) -> GammaIncomplete
Computes the gamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let gamma = Float::with_val(53, f.gamma_ref()); let expected = 0.9064_f64; assert!((gamma - expected).abs() < 0.0001);
pub fn gamma_inc_ref<'a>(&'a self, x: &'a Self) -> GammaIncIncomplete
[src]
pub fn gamma_inc_ref<'a>(&'a self, x: &'a Self) -> GammaIncIncomplete
Computes the upper incomplete gamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let x = Float::with_val(53, 2.5); let gamma_inc = Float::with_val(53, f.gamma_inc_ref(&x)); let expected = 0.1116_f64; assert!((gamma_inc - expected).abs() < 0.0001);
pub fn ln_gamma_ref(&self) -> LnGammaIncomplete
[src]
pub fn ln_gamma_ref(&self) -> LnGammaIncomplete
Computes the logarithm of the gamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ln_gamma = Float::with_val(53, f.ln_gamma_ref()); let expected = -0.0983_f64; assert!((ln_gamma - expected).abs() < 0.0001);
pub fn ln_abs_gamma_ref(&self) -> LnAbsGammaIncomplete
[src]
pub fn ln_abs_gamma_ref(&self) -> LnAbsGammaIncomplete
Computes the logarithm of the absolute value of the gamma
function on val
.
Assign<Src> for (Float, Ordering)
,
Assign<Src> for (&mut Float, &mut Ordering)
,
AssignRound<Src> for (Float, Ordering)
and
AssignRound<Src> for (&mut Float, &mut Ordering)
are implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::float::Constant; use rug::{Assign, Float}; use std::cmp::Ordering; let neg1_2 = Float::with_val(53, -0.5); // gamma of -1/2 is -2 * sqrt(pi) let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32; let ln_gamma_64 = abs_gamma_64.ln(); // Assign rounds to the nearest let r = neg1_2.ln_abs_gamma_ref(); let (mut f, mut sign) = (Float::new(53), Ordering::Equal); (&mut f, &mut sign).assign(r); // gamma of -1/2 is negative assert_eq!(sign, Ordering::Less); // check to 53 significant bits assert_eq!(f, Float::with_val(53, &ln_gamma_64));
pub fn digamma_ref(&self) -> DigammaIncomplete
[src]
pub fn digamma_ref(&self) -> DigammaIncomplete
Computes the Digamma function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let digamma = Float::with_val(53, f.digamma_ref()); let expected = -0.2275_f64; assert!((digamma - expected).abs() < 0.0001);
pub fn zeta_ref(&self) -> ZetaIncomplete
[src]
pub fn zeta_ref(&self) -> ZetaIncomplete
Computes the Riemann Zeta function on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let zeta = Float::with_val(53, f.zeta_ref()); let expected = 4.5951_f64; assert!((zeta - expected).abs() < 0.0001);
pub fn erf_ref(&self) -> ErfIncomplete
[src]
pub fn erf_ref(&self) -> ErfIncomplete
Computes the error function.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let erf = Float::with_val(53, f.erf_ref()); let expected = 0.9229_f64; assert!((erf - expected).abs() < 0.0001);
pub fn erfc_ref(&self) -> ErfcIncomplete
[src]
pub fn erfc_ref(&self) -> ErfcIncomplete
Computes the complementary error function.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let erfc = Float::with_val(53, f.erfc_ref()); let expected = 0.0771_f64; assert!((erfc - expected).abs() < 0.0001);
pub fn j0_ref(&self) -> J0Incomplete
[src]
pub fn j0_ref(&self) -> J0Incomplete
Computes the first kind Bessel function of order 0.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j0 = Float::with_val(53, f.j0_ref()); let expected = 0.6459_f64; assert!((j0 - expected).abs() < 0.0001);
pub fn j1_ref(&self) -> J1Incomplete
[src]
pub fn j1_ref(&self) -> J1Incomplete
Computes the first kind Bessel function of order 1.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j1 = Float::with_val(53, f.j1_ref()); let expected = 0.5106_f64; assert!((j1 - expected).abs() < 0.0001);
pub fn jn_ref(&self, n: i32) -> JnIncomplete
[src]
pub fn jn_ref(&self, n: i32) -> JnIncomplete
Computes the first kind Bessel function of order n.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let j2 = Float::with_val(53, f.jn_ref(2)); let expected = 0.1711_f64; assert!((j2 - expected).abs() < 0.0001);
pub fn y0_ref(&self) -> Y0Incomplete
[src]
pub fn y0_ref(&self) -> Y0Incomplete
Computes the second kind Bessel function of order 0.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y0 = Float::with_val(53, f.y0_ref()); let expected = 0.2582_f64; assert!((y0 - expected).abs() < 0.0001);
pub fn y1_ref(&self) -> Y1Incomplete
[src]
pub fn y1_ref(&self) -> Y1Incomplete
Computes the second kind Bessel function of order 1.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y1 = Float::with_val(53, f.y1_ref()); let expected = -0.5844_f64; assert!((y1 - expected).abs() < 0.0001);
pub fn yn_ref(&self, n: i32) -> YnIncomplete
[src]
pub fn yn_ref(&self, n: i32) -> YnIncomplete
Computes the second kind Bessel function of order n.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let y2 = Float::with_val(53, f.yn_ref(2)); let expected = -1.1932_f64; assert!((y2 - expected).abs() < 0.0001);
pub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete
[src]
pub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete
Computes the arithmetic-geometric mean.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); let agm = Float::with_val(53, f.agm_ref(&g)); let expected = 2.3295_f64; assert!((agm - expected).abs() < 0.0001);
pub fn hypot_ref<'a>(&'a self, other: &'a Self) -> HypotIncomplete
[src]
pub fn hypot_ref<'a>(&'a self, other: &'a Self) -> HypotIncomplete
Computes the Euclidean norm.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let g = Float::with_val(53, 3.75); let hypot = Float::with_val(53, f.hypot_ref(&g)); let expected = 3.9528_f64; assert!((hypot - expected).abs() < 0.0001);
pub fn ai_ref(&self) -> AiIncomplete
[src]
pub fn ai_ref(&self) -> AiIncomplete
Computes the Airy function Ai on the value.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f = Float::with_val(53, 1.25); let ai = Float::with_val(53, f.ai_ref()); let expected = 0.0996_f64; assert!((ai - expected).abs() < 0.0001);
pub fn ceil_ref(&self) -> CeilIncomplete
[src]
pub fn ceil_ref(&self) -> CeilIncomplete
Rounds up to the next higher integer. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let ceil1 = Float::with_val(53, f1.ceil_ref()); assert_eq!(ceil1, -23); let f2 = Float::with_val(53, 23.75); let ceil2 = Float::with_val(53, f2.ceil_ref()); assert_eq!(ceil2, 24);
pub fn floor_ref(&self) -> FloorIncomplete
[src]
pub fn floor_ref(&self) -> FloorIncomplete
Rounds down to the next lower integer. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let floor1 = Float::with_val(53, f1.floor_ref()); assert_eq!(floor1, -24); let f2 = Float::with_val(53, 23.75); let floor2 = Float::with_val(53, f2.floor_ref()); assert_eq!(floor2, 23);
pub fn round_ref(&self) -> RoundIncomplete
[src]
pub fn round_ref(&self) -> RoundIncomplete
Rounds to the nearest integer, rounding half-way cases away from zero. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let round1 = Float::with_val(53, f1.round_ref()); assert_eq!(round1, -24); let f2 = Float::with_val(53, 23.75); let round2 = Float::with_val(53, f2.round_ref()); assert_eq!(round2, 24);
Double rounding may happen when assigning to a target with a precision less than the number of significant bits for the truncated integer.
use rug::Float; use rug::float::Round; use rug::ops::AssignRound; let f = Float::with_val(53, 6.5); // 6.5 (binary 110.1) is rounded to 7 (binary 111) let r = f.round_ref(); // use only 2 bits of precision in destination let mut dst = Float::new(2); // 7 (binary 111) is rounded to 8 (binary 1000) by // round-even rule in order to store in 2-bit Float, even // though 6 (binary 110) is closer to original 6.5). dst.assign_round(r, Round::Nearest); assert_eq!(dst, 8);
pub fn round_even_ref(&self) -> RoundEvenIncomplete
[src]
pub fn round_even_ref(&self) -> RoundEvenIncomplete
Rounds to the nearest integer, rounding half-way cases to even. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, 23.5); let round1 = Float::with_val(53, f1.round_even_ref()); assert_eq!(round1, 24); let f2 = Float::with_val(53, 24.5); let round2 = Float::with_val(53, f2.round_even_ref()); assert_eq!(round2, 24);
pub fn trunc_ref(&self) -> TruncIncomplete
[src]
pub fn trunc_ref(&self) -> TruncIncomplete
Rounds to the next integer towards zero. The result may be rounded again when assigned to the target.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let trunc1 = Float::with_val(53, f1.trunc_ref()); assert_eq!(trunc1, -23); let f2 = Float::with_val(53, 23.75); let trunc2 = Float::with_val(53, f2.trunc_ref()); assert_eq!(trunc2, 23);
pub fn fract_ref(&self) -> FractIncomplete
[src]
pub fn fract_ref(&self) -> FractIncomplete
Gets the fractional part of the number.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Float; let f1 = Float::with_val(53, -23.75); let fract1 = Float::with_val(53, f1.fract_ref()); assert_eq!(fract1, -0.75); let f2 = Float::with_val(53, 23.75); let fract2 = Float::with_val(53, f2.fract_ref()); assert_eq!(fract2, 0.75);
pub fn trunc_fract_ref(&self) -> TruncFractIncomplete
[src]
pub fn trunc_fract_ref(&self) -> TruncFractIncomplete
Gets the integer and fractional parts of the number.
Assign<Src> for Float
and
AssignRound<Src> for Float
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Float}; let f1 = Float::with_val(53, -23.75); let r1 = f1.trunc_fract_ref(); let (mut trunc1, mut fract1) = (Float::new(53), Float::new(53)); (&mut trunc1, &mut fract1).assign(r1); assert_eq!(trunc1, -23); assert_eq!(fract1, -0.75); let f2 = Float::with_val(53, -23.75); let r2 = f2.trunc_fract_ref(); let (mut trunc2, mut fract2) = (Float::new(53), Float::new(53)); (&mut trunc2, &mut fract2).assign(r2); assert_eq!(trunc2, -23); assert_eq!(fract2, -0.75);
Trait Implementations
impl Clone for SmallFloat
[src]
impl Clone for SmallFloat
fn clone(&self) -> SmallFloat
[src]
fn clone(&self) -> SmallFloat
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl Deref for SmallFloat
[src]
impl Deref for SmallFloat
type Target = Float
The resulting type after dereferencing.
fn deref(&self) -> &Float
[src]
fn deref(&self) -> &Float
Dereferences the value.
impl Assign<i8> for SmallFloat
[src]
impl Assign<i8> for SmallFloat
impl From<i8> for SmallFloat
[src]
impl From<i8> for SmallFloat
impl Assign<i16> for SmallFloat
[src]
impl Assign<i16> for SmallFloat
impl From<i16> for SmallFloat
[src]
impl From<i16> for SmallFloat
impl Assign<i32> for SmallFloat
[src]
impl Assign<i32> for SmallFloat
impl From<i32> for SmallFloat
[src]
impl From<i32> for SmallFloat
impl Assign<i64> for SmallFloat
[src]
impl Assign<i64> for SmallFloat
impl From<i64> for SmallFloat
[src]
impl From<i64> for SmallFloat
impl Assign<i128> for SmallFloat
[src]
impl Assign<i128> for SmallFloat
impl From<i128> for SmallFloat
[src]
impl From<i128> for SmallFloat
impl Assign<isize> for SmallFloat
[src]
impl Assign<isize> for SmallFloat
impl From<isize> for SmallFloat
[src]
impl From<isize> for SmallFloat
impl Assign<u8> for SmallFloat
[src]
impl Assign<u8> for SmallFloat
impl From<u8> for SmallFloat
[src]
impl From<u8> for SmallFloat
impl Assign<u16> for SmallFloat
[src]
impl Assign<u16> for SmallFloat
impl From<u16> for SmallFloat
[src]
impl From<u16> for SmallFloat
impl Assign<u32> for SmallFloat
[src]
impl Assign<u32> for SmallFloat
impl From<u32> for SmallFloat
[src]
impl From<u32> for SmallFloat
impl Assign<u64> for SmallFloat
[src]
impl Assign<u64> for SmallFloat
impl From<u64> for SmallFloat
[src]
impl From<u64> for SmallFloat
impl Assign<u128> for SmallFloat
[src]
impl Assign<u128> for SmallFloat
impl From<u128> for SmallFloat
[src]
impl From<u128> for SmallFloat
impl Assign<usize> for SmallFloat
[src]
impl Assign<usize> for SmallFloat
impl From<usize> for SmallFloat
[src]
impl From<usize> for SmallFloat
impl Assign<f32> for SmallFloat
[src]
impl Assign<f32> for SmallFloat
impl From<f32> for SmallFloat
[src]
impl From<f32> for SmallFloat
impl Assign<f64> for SmallFloat
[src]
impl Assign<f64> for SmallFloat
impl From<f64> for SmallFloat
[src]
impl From<f64> for SmallFloat
impl<'a> Assign<&'a Self> for SmallFloat
[src]
impl<'a> Assign<&'a Self> for SmallFloat
impl Assign for SmallFloat
[src]
impl Assign for SmallFloat
Auto Trait Implementations
impl Send for SmallFloat
impl Send for SmallFloat
impl Sync for SmallFloat
impl Sync for SmallFloat