std_dev::regression::arbitrary_linear_algebra

Struct FloatWrapper

source 
pub struct FloatWrapper(pub Float);
Available on crate features regression and arbitrary-precision only.
Expand description

A wrapper around rug::Float to implement traits for.

Tuple Fields§

§0: Float

Methods from Deref<Target = Float>§

source

pub fn prec(&self) -> u32

Returns the precision.

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

pub fn prec_64(&self) -> u64

Returns the precision.

§Examples
use rug::Float;
let f = Float::new_64(53);
assert_eq!(f.prec_64(), 53);
source

pub fn as_raw(&self) -> *const mpfr_t

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

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

§Examples
use gmp_mpfr_sys::mpfr;
use gmp_mpfr_sys::mpfr::rnd_t;
use rug::Float;
let f = Float::with_val(53, -14.5);
let m_ptr = f.as_raw();
unsafe {
    let d = mpfr::get_d(m_ptr, rnd_t::RNDN);
    assert_eq!(d, -14.5);
}
// f is still valid
assert_eq!(f, -14.5);
source

pub fn to_integer(&self) -> Option<Integer>

Available on crate feature integer only.

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

This conversion can also be performed using

§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);
source

pub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>

Available on crate feature integer only.

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

§Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::Float;
let f = Float::with_val(53, 13.7);
let (i, dir) = match f.to_integer_round(Round::Down) {
    Some(i_dir) => i_dir,
    None => unreachable!(),
};
assert_eq!(i, 13);
assert_eq!(dir, Ordering::Less);
source

pub fn to_integer_exp(&self) -> Option<(Integer, i32)>

Available on crate feature integer only.

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

Going back from the returned Integer and exponent to the original can be done by assigning the Integer and shifting to the left by the exponent.

use rug::{Assign, Float};
let orig = Float::with_val(16, 6.5);
let (int, exp) = orig.to_integer_exp().unwrap();
let mut float = Float::new(16);
float.assign(&int);
float <<= exp;
assert_eq!(float, orig);
source

pub fn to_rational(&self) -> Option<Rational>

Available on crate feature rational only.

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

§Examples
use core::cmp::Ordering;
use core::str::FromStr;
use rug::float::Round;
use rug::{Float, Rational};

// Consider the number 123,456,789 / 10,000,000,000.
let parse = Float::parse("0.0123456789").unwrap();
let (f, f_rounding) = Float::with_val_round(35, parse, Round::Down);
assert_eq!(f_rounding, Ordering::Less);
let r = Rational::from_str("123456789/10000000000").unwrap();
// Set fr to the value of f exactly.
let fr = f.to_rational().unwrap();
// Since f == fr and f was rounded down, r != fr.
assert_ne!(r, fr);
let (frf, frf_rounding) = Float::with_val_round(35, &fr, Round::Down);
assert_eq!(frf_rounding, Ordering::Equal);
assert_eq!(frf, f);
assert_eq!(format!("{:.9}", frf), "1.23456789e-2");

In the following example, the Float values can be represented exactly.

use rug::Float;

let large_f = Float::with_val(16, 6.5);
let large_r = large_f.to_rational().unwrap();
let small_f = Float::with_val(16, -0.125);
let small_r = small_f.to_rational().unwrap();

assert_eq!(*large_r.numer(), 13);
assert_eq!(*large_r.denom(), 2);
assert_eq!(*small_r.numer(), -1);
assert_eq!(*small_r.denom(), 8);
source

pub fn to_i32_saturating(&self) -> Option<i32>

Converts to an i32, rounding to the nearest.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

§Examples
use rug::{Assign, Float};
let mut f = Float::with_val(53, -13.7);
assert_eq!(f.to_i32_saturating(), Some(-14));
f.assign(-1e40);
assert_eq!(f.to_i32_saturating(), Some(i32::MIN));
f.assign(u32::MAX);
assert_eq!(f.to_i32_saturating(), Some(i32::MAX));
source

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

pub fn to_u32_saturating(&self) -> Option<u32>

Converts to a u32, rounding to the nearest.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

§Examples
use rug::{Assign, Float};
let mut f = Float::with_val(53, 13.7);
assert_eq!(f.to_u32_saturating(), Some(14));
f.assign(-1);
assert_eq!(f.to_u32_saturating(), Some(0));
f.assign(1e40);
assert_eq!(f.to_u32_saturating(), Some(u32::MAX));
source

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

pub fn to_f32(&self) -> f32

Converts to an f32, rounding to the nearest.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

§Examples
use rug::{Assign, Float};
let mut f = Float::with_val(53, 13.7);
assert_eq!(f.to_f32(), 13.7);
f.assign(1e300);
assert_eq!(f.to_f32(), f32::INFINITY);
f.assign(1e-300);
assert_eq!(f.to_f32(), 0.0);
source

pub fn to_f32_round(&self, round: Round) -> f32

Converts to an f32, applying the specified rounding method.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

§Examples
use rug::float::Round;
use rug::Float;
let f = Float::with_val(53, 1.0 + (-50f64).exp2());
assert_eq!(f.to_f32_round(Round::Up), 1.0 + f32::EPSILON);
source

pub fn to_f64(&self) -> f64

Converts to an f64, rounding to the nearest.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

§Examples
use rug::{Assign, Float};
let mut f = Float::with_val(53, 13.7);
assert_eq!(f.to_f64(), 13.7);
f.assign(1e300);
f.square_mut();
assert_eq!(f.to_f64(), f64::INFINITY);
source

pub fn to_f64_round(&self, round: Round) -> f64

Converts to an f64, applying the specified rounding method.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

§Examples
use rug::float::Round;
use rug::Float;
// (2.0 ^ -90) + 1
let f: Float = Float::with_val(100, -90).exp2() + 1;
assert_eq!(f.to_f64_round(Round::Up), 1.0 + f64::EPSILON);
source

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

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

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

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

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

Available on crate feature std only.

Returns a string representation of self for the specified radix rounding to the nearest.

The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.

§Panics

Panics if radix is less than 2 or greater than 36.

§Examples
use rug::float::Special;
use rug::Float;
let neg_inf = Float::with_val(53, Special::NegInfinity);
assert_eq!(neg_inf.to_string_radix(10, None), "-inf");
assert_eq!(neg_inf.to_string_radix(16, None), "-@inf@");
let twentythree = Float::with_val(8, 23);
assert_eq!(twentythree.to_string_radix(10, None), "23.00");
assert_eq!(twentythree.to_string_radix(16, None), "17.0");
assert_eq!(twentythree.to_string_radix(10, Some(2)), "23");
assert_eq!(twentythree.to_string_radix(16, Some(4)), "17.00");
// 2 raised to the power of 80 in hex is 1 followed by 20 zeros
let two_to_80 = Float::with_val(53, 80f64.exp2());
assert_eq!(two_to_80.to_string_radix(10, Some(3)), "1.21e24");
assert_eq!(two_to_80.to_string_radix(16, Some(3)), "1.00@20");
source

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

Available on crate feature std only.

Returns a string representation of self for the specified radix applying the specified rounding method.

The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.

§Panics

Panics if radix is less than 2 or greater than 36.

§Examples
use rug::float::Round;
use rug::Float;
let twentythree = Float::with_val(8, 23.3);
let down = twentythree.to_string_radix_round(10, Some(2), Round::Down);
assert_eq!(down, "23");
let up = twentythree.to_string_radix_round(10, Some(2), Round::Up);
assert_eq!(up, "24");
source

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

Available on crate feature std only.

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

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

For normal values, the returned string has an implicit radix point before the first digit. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.

§Panics

Panics if radix is less than 2 or greater than 36.

§Examples
use rug::float::Special;
use rug::Float;
let inf = Float::with_val(53, Special::Infinity);
let (sign, s, exp) = inf.to_sign_string_exp(10, None);
assert_eq!((sign, &*s, exp), (false, "inf", None));
let (sign, s, exp) = (-inf).to_sign_string_exp(16, None);
assert_eq!((sign, &*s, exp), (true, "@inf@", None));

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

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

Available on crate feature std only.

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

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

For normal values, the returned string has an implicit radix point before the first digit. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.

§Panics

Panics if radix is less than 2 or greater than 36.

§Examples
use rug::float::Round;
use rug::Float;
let val = Float::with_val(53, -0.0625);
// rounding -0.0625 to two significant digits towards -∞ gives -0.063
let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Down);
assert_eq!((sign, &*s, exp), (true, "63", Some(-1)));
// rounding -0.0625 to two significant digits towards +∞ gives -0.062
let (sign, s, exp) = val.to_sign_string_exp_round(10, Some(2), Round::Up);
assert_eq!((sign, &*s, exp), (true, "62", Some(-1)));

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

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.

Unlike the other negation methods (the - operator, Neg::neg, etc.), this method does not set the MPFR NaN flag if a NaN is encountered.

§Examples
use rug::Float;
let f = Float::with_val(53, 4.2);
let neg_f = f.as_neg();
assert_eq!(*neg_f, -4.2);
// methods taking &self can be used on the returned object
let reneg_f = neg_f.as_neg();
assert_eq!(*reneg_f, 4.2);
assert_eq!(*reneg_f, f);
source

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.

Unlike the other absolute value methods (abs, abs_mut, etc.), this method does not set the MPFR NaN flag if a NaN is encountered.

§Examples
use rug::Float;
let f = Float::with_val(53, -4.2);
let abs_f = f.as_abs();
assert_eq!(*abs_f, 4.2);
// methods taking &self can be used on the returned object
let reabs_f = abs_f.as_abs();
assert_eq!(*reabs_f, 4.2);
assert_eq!(*reabs_f, *abs_f);
source

pub fn as_ord(&self) -> &OrdFloat

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

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

§Examples
use core::cmp::Ordering;
use rug::float::Special;
use rug::Float;

let nan_f = Float::with_val(53, Special::Nan);
let nan = nan_f.as_ord();
let neg_nan_f = nan_f.as_neg();
let neg_nan = neg_nan_f.as_ord();
assert_eq!(nan.cmp(nan), Ordering::Equal);
assert_eq!(neg_nan.cmp(nan), Ordering::Less);

let inf_f = Float::with_val(53, Special::Infinity);
let inf = inf_f.as_ord();
let neg_inf_f = Float::with_val(53, Special::NegInfinity);
let neg_inf = neg_inf_f.as_ord();
assert_eq!(nan.cmp(inf), Ordering::Greater);
assert_eq!(neg_nan.cmp(neg_inf), Ordering::Less);

let zero_f = Float::with_val(53, Special::Zero);
let zero = zero_f.as_ord();
let neg_zero_f = Float::with_val(53, Special::NegZero);
let neg_zero = neg_zero_f.as_ord();
assert_eq!(zero.cmp(neg_zero), Ordering::Greater);
source

pub fn as_complex(&self) -> BorrowComplex<'_>

Available on crate feature complex only.

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

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());
source

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());
source

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());
source

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());
source

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());
source

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());
source

pub fn classify(&self) -> FpCategory

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

§Examples
use core::num::FpCategory;
use rug::float::Special;
use rug::Float;
let nan = Float::with_val(53, Special::Nan);
let infinite = Float::with_val(53, Special::Infinity);
let zero = Float::with_val(53, Special::Zero);
let normal = Float::with_val(53, 2.3);
assert_eq!(nan.classify(), FpCategory::Nan);
assert_eq!(infinite.classify(), FpCategory::Infinite);
assert_eq!(zero.classify(), FpCategory::Zero);
assert_eq!(normal.classify(), FpCategory::Normal);
source

pub fn cmp0(&self) -> Option<Ordering>

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

§Examples
use core::cmp::Ordering;
use rug::float::Special;
use rug::{Assign, Float};
let mut f = Float::with_val(53, Special::NegZero);
assert_eq!(f.cmp0(), Some(Ordering::Equal));
f += 5.2;
assert_eq!(f.cmp0(), Some(Ordering::Greater));
f.assign(Special::NegInfinity);
assert_eq!(f.cmp0(), Some(Ordering::Less));
f.assign(Special::Nan);
assert_eq!(f.cmp0(), None);
source

pub fn cmp_abs(&self, other: &Float) -> Option<Ordering>

Compares the absolute values of self and other.

§Examples
use core::cmp::Ordering;
use rug::Float;
let a = Float::with_val(53, -10);
let b = Float::with_val(53, 4);
assert_eq!(a.partial_cmp(&b), Some(Ordering::Less));
assert_eq!(a.cmp_abs(&b), Some(Ordering::Greater));
source

pub fn total_cmp(&self, other: &Float) -> Ordering

Returns the total ordering between self and other.

Negative zero is ordered as less than positive zero. Negative NaN is ordered as less than negative infinity, while positive NaN is ordered as greater than positive infinity. Comparing two negative NaNs or two positive NaNs produces equality.

§Examples
use rug::float::Special;
use rug::Float;
let mut values = vec![
    Float::with_val(53, Special::Zero),
    Float::with_val(53, Special::NegZero),
    Float::with_val(53, Special::Infinity),
    Float::with_val(53, Special::NegInfinity),
    Float::with_val(53, Special::Nan),
    -Float::with_val(53, Special::Nan),
];

values.sort_by(Float::total_cmp);

// NaN with negative sign
assert!(values[0].is_nan() && values[0].is_sign_negative());
// -∞
assert!(values[1].is_infinite() && values[1].is_sign_negative());
// -0
assert!(values[2].is_zero() && values[2].is_sign_negative());
// +0
assert!(values[3].is_zero() && values[3].is_sign_positive());
// +∞
assert!(values[4].is_infinite() && values[4].is_sign_positive());
// NaN with positive sign
assert!(values[5].is_nan() && values[5].is_sign_positive());
source

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

pub fn get_significand(&self) -> Option<BorrowInteger<'_>>

Available on crate feature integer only.

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

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());
source

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());
source

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

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:

§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);
source

pub fn mul_add_ref<'a>( &'a self, mul: &'a Float, add: &'a Float, ) -> AddMulIncomplete<'a>

Multiplies and adds in one fused operation.

The following 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);
source

pub fn mul_sub_ref<'a>( &'a self, mul: &'a Float, sub: &'a Float, ) -> SubMulFromIncomplete<'a>

Multiplies and subtracts in one fused operation.

The following 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);
source

pub fn mul_add_mul_ref<'a>( &'a self, mul: &'a Float, add_mul1: &'a Float, add_mul2: &'a Float, ) -> MulAddMulIncomplete<'a>

Multiplies two products and adds them in one fused operation.

The following 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);
source

pub fn mul_sub_mul_ref<'a>( &'a self, mul: &'a Float, sub_mul1: &'a Float, sub_mul2: &'a Float, ) -> MulSubMulIncomplete<'a>

Multiplies two products and subtracts them in one fused operation.

The following 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);
source

pub fn square_ref(&self) -> SquareIncomplete<'_>

Computes the square.

The following 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);
source

pub fn sqrt_ref(&self) -> SqrtIncomplete<'_>

Computes the square root.

The following 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);
source

pub fn recip_sqrt_ref(&self) -> RecipSqrtIncomplete<'_>

Computes the reciprocal square root.

The following 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);
source

pub fn cbrt_ref(&self) -> CbrtIncomplete<'_>

Computes the cube root.

The following 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);
source

pub fn root_ref(&self, k: u32) -> RootIncomplete<'_>

Computes the kth root.

The following 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);
source

pub fn root_i_ref(&self, k: i32) -> RootIIncomplete<'_>

Computes the kth root.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 625.0);
let r = f.root_i_ref(-4);
let root_i = Float::with_val(53, r);
let expected = 0.2000_f64;
assert!((root_i - expected).abs() < 0.0001);
source

pub fn abs_ref(&self) -> AbsIncomplete<'_>

Computes the absolute value.

The following 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);
source

pub fn signum_ref(&self) -> SignumIncomplete<'_>

Computes the signum.

  • 1.0 if the value is positive, +0.0 or +∞
  • −1.0 if the value is negative, −0.0 or −∞
  • NaN if the value is NaN

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

§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);
source

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

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:

§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);
source

pub fn clamp_ref<'min, 'max, Min, Max>( &self, min: &'min Min, max: &'max Max, ) -> ClampIncomplete<'_, 'min, 'max, Min, Max>
where Float: PartialOrd<Min> + PartialOrd<Max> + for<'a> AssignRound<&'a Min, Round = Round, Ordering = Ordering, Round = Round, Ordering = Ordering> + for<'a> AssignRound<&'a Max>,

Clamps the value within the specified bounds.

The following 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);
source

pub fn recip_ref(&self) -> RecipIncomplete<'_>

Computes the reciprocal.

The following 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);
source

pub fn min_ref<'a>(&'a self, other: &'a Float) -> MinIncomplete<'a>

Finds the minimum.

The following 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);
source

pub fn max_ref<'a>(&'a self, other: &'a Float) -> MaxIncomplete<'a>

Finds the maximum.

The following 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);
source

pub fn positive_diff_ref<'a>( &'a self, other: &'a Float, ) -> PositiveDiffIncomplete<'a>

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:

§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);
source

pub fn ln_ref(&self) -> LnIncomplete<'_>

Computes the natural logarithm.

The following 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);
source

pub fn log2_ref(&self) -> Log2Incomplete<'_>

Computes the logarithm to base 2.

The following 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);
source

pub fn log10_ref(&self) -> Log10Incomplete<'_>

Computes the logarithm to base 10.

The following 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);
source

pub fn exp_ref(&self) -> ExpIncomplete<'_>

Computes the exponential.

The following 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);
source

pub fn exp2_ref(&self) -> Exp2Incomplete<'_>

Computes 2 to the power of the value.

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

§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);
source

pub fn exp10_ref(&self) -> Exp10Incomplete<'_>

Computes 10 to the power of the value.

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

§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);
source

pub fn sin_ref(&self) -> SinIncomplete<'_>

Computes the sine.

The following 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);
source

pub fn cos_ref(&self) -> CosIncomplete<'_>

Computes the cosine.

The following 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);
source

pub fn tan_ref(&self) -> TanIncomplete<'_>

Computes the tangent.

The following 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);
source

pub fn sin_cos_ref(&self) -> SinCosIncomplete<'_>

Computes the sine and cosine.

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

§Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::ops::AssignRound;
use rug::{Assign, Float};
let phase = Float::with_val(53, 1.25);

let (mut sin, mut cos) = (Float::new(53), Float::new(53));
let sin_cos = phase.sin_cos_ref();
(&mut sin, &mut cos).assign(sin_cos);
let expected_sin = 0.9490_f64;
let expected_cos = 0.3153_f64;
assert!((sin - expected_sin).abs() < 0.0001);
assert!((cos - expected_cos).abs() < 0.0001);

// using 4 significant bits: sin = 0.9375
// using 4 significant bits: cos = 0.3125
let (mut sin_4, mut cos_4) = (Float::new(4), Float::new(4));
let sin_cos = phase.sin_cos_ref();
let (dir_sin, dir_cos) = (&mut sin_4, &mut cos_4)
    .assign_round(sin_cos, Round::Nearest);
assert_eq!(sin_4, 0.9375);
assert_eq!(dir_sin, Ordering::Less);
assert_eq!(cos_4, 0.3125);
assert_eq!(dir_cos, Ordering::Less);
source

pub fn sin_u_ref(&self, u: u32) -> SinUIncomplete<'_>

Computes the sine of (2π/u) × self.

For example, if u = 360, then this is the sine for self in degrees.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 60);
let sin = Float::with_val(53, f.sin_u_ref(360));
let expected = 0.75_f64.sqrt();
assert!((sin - expected).abs() < 0.0001);
source

pub fn cos_u_ref(&self, u: u32) -> CosUIncomplete<'_>

Computes the cosine of (2π/u) × self.

For example, if u = 360, then this is the cosine for self in degrees.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 30);
let cos = Float::with_val(53, f.cos_u_ref(360));
let expected = 0.75_f64.sqrt();
assert!((cos - expected).abs() < 0.0001);
source

pub fn tan_u_ref(&self, u: u32) -> TanUIncomplete<'_>

Computes the tangent of (2π/u) × self.

For example, if u = 360, then this is the tangent for self in degrees.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 60);
let tan = Float::with_val(53, f.tan_u_ref(360));
let expected = 3_f64.sqrt();
assert!((tan - expected).abs() < 0.0001);
source

pub fn sin_pi_ref(&self) -> SinPiIncomplete<'_>

Computes the sine of π × self.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 0.25);
let sin = Float::with_val(53, f.sin_pi_ref());
let expected = 0.5_f64.sqrt();
assert!((sin - expected).abs() < 0.0001);
source

pub fn cos_pi_ref(&self) -> CosPiIncomplete<'_>

Computes the cosine of π × self.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 0.25);
let cos = Float::with_val(53, f.cos_pi_ref());
let expected = 0.5_f64.sqrt();
assert!((cos - expected).abs() < 0.0001);
source

pub fn tan_pi_ref(&self) -> TanPiIncomplete<'_>

Computes the tangent of π × self.

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

§Examples
use rug::Float;
let f = Float::with_val(53, 0.125);
let tan = Float::with_val(53, f.tan_pi_ref());
let expected = 0.4142_f64;
assert!((tan - expected).abs() < 0.0001);
source

pub fn sec_ref(&self) -> SecIncomplete<'_>

Computes the secant.

The following 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);
source

pub fn csc_ref(&self) -> CscIncomplete<'_>

Computes the cosecant.

The following 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);
source

pub fn cot_ref(&self) -> CotIncomplete<'_>

Computes the cotangent.

The following 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);
source

pub fn asin_ref(&self) -> AsinIncomplete<'_>

Computes the arc-sine.

The following 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);
source

pub fn acos_ref(&self) -> AcosIncomplete<'_>

Computes the arc-cosine.

The following 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);
source

pub fn atan_ref(&self) -> AtanIncomplete<'_>

Computes the arc-tangent.

The following 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);
source

pub fn atan2_ref<'a>(&'a self, x: &'a Float) -> Atan2Incomplete<'a>

Computes the arc-tangent2.

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

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

§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);
source

pub fn asin_u_ref(&self, u: u32) -> AsinUIncomplete<'_>

Computes the arc-sine then divides by 2π/u.

For example, if u = 360, then this is the arc-sine in degrees.

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

§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = Float::with_val(53, f.asin_u_ref(360));
let expected = -48.5904_f64;
assert!((asin - expected).abs() < 0.0001);
source

pub fn acos_u_ref(&self, u: u32) -> AcosUIncomplete<'_>

Computes the arc-cosine then divides by 2π/u.

For example, if u = 360, then this is the arc-cosine in degrees.

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

§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = Float::with_val(53, f.acos_u_ref(360));
let expected = 138.5904_f64;
assert!((acos - expected).abs() < 0.0001);
source

pub fn atan_u_ref(&self, u: u32) -> AtanUIncomplete<'_>

Computes the arc-tangent then divides by 2π/u.

For example, if u = 360, then this is the arc-tangent in degrees.

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

§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = Float::with_val(53, f.atan_u_ref(360));
let expected = -36.8699_f64;
assert!((atan - expected).abs() < 0.0001);
source

pub fn atan2_u_ref<'a>(&'a self, x: &'a Float, u: u32) -> Atan2UIncomplete<'a>

Computes the arc-tangent2 then divides by 2π/u.

For example, if u = 360, then this is the arc-tangent in degrees.

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

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

§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let r = y.atan2_u_ref(&x, 360);
let atan2 = Float::with_val(53, r);
let expected = 143.1301_f64;
assert!((atan2 - expected).abs() < 0.0001);
source

pub fn asin_pi_ref(&self) -> AsinPiIncomplete<'_>

Computes the arc-sine then divides by π.

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

§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let asin = Float::with_val(53, f.asin_pi_ref());
let expected = -0.2699_f64;
assert!((asin - expected).abs() < 0.0001);
source

pub fn acos_pi_ref(&self) -> AcosPiIncomplete<'_>

Computes the arc-cosine then divides by π.

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

§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let acos = Float::with_val(53, f.acos_pi_ref());
let expected = 0.7699_f64;
assert!((acos - expected).abs() < 0.0001);
source

pub fn atan_pi_ref(&self) -> AtanPiIncomplete<'_>

Computes the arc-tangent then divides by π.

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

§Examples
use rug::Float;
let f = Float::with_val(53, -0.75);
let atan = Float::with_val(53, f.atan_pi_ref());
let expected = -0.2048_f64;
assert!((atan - expected).abs() < 0.0001);
source

pub fn atan2_pi_ref<'a>(&'a self, x: &'a Float) -> Atan2PiIncomplete<'a>

Computes the arc-tangent2 then divides by π.

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

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

§Examples
use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let r = y.atan2_pi_ref(&x);
let atan2 = Float::with_val(53, r);
let expected = 0.7952_f64;
assert!((atan2 - expected).abs() < 0.0001);
source

pub fn sinh_ref(&self) -> SinhIncomplete<'_>

Computes the hyperbolic sine.

The following 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);
source

pub fn cosh_ref(&self) -> CoshIncomplete<'_>

Computes the hyperbolic cosine.

The following 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);
source

pub fn tanh_ref(&self) -> TanhIncomplete<'_>

Computes the hyperbolic tangent.

The following 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);
source

pub fn sinh_cosh_ref(&self) -> SinhCoshIncomplete<'_>

Computes the hyperbolic sine and cosine.

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

§Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::ops::AssignRound;
use rug::{Assign, Float};
let phase = Float::with_val(53, 1.25);

let (mut sinh, mut cosh) = (Float::new(53), Float::new(53));
let sinh_cosh = phase.sinh_cosh_ref();
(&mut sinh, &mut cosh).assign(sinh_cosh);
let expected_sinh = 1.6019_f64;
let expected_cosh = 1.8884_f64;
assert!((sinh - expected_sinh).abs() < 0.0001);
assert!((cosh - expected_cosh).abs() < 0.0001);

// using 4 significant bits: sin = 1.625
// using 4 significant bits: cos = 1.875
let (mut sinh_4, mut cosh_4) = (Float::new(4), Float::new(4));
let sinh_cosh = phase.sinh_cosh_ref();
let (dir_sinh, dir_cosh) = (&mut sinh_4, &mut cosh_4)
    .assign_round(sinh_cosh, Round::Nearest);
assert_eq!(sinh_4, 1.625);
assert_eq!(dir_sinh, Ordering::Greater);
assert_eq!(cosh_4, 1.875);
assert_eq!(dir_cosh, Ordering::Less);
source

pub fn sech_ref(&self) -> SechIncomplete<'_>

Computes the hyperbolic secant.

The following 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);
source

pub fn csch_ref(&self) -> CschIncomplete<'_>

Computes the hyperbolic cosecant.

The following 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);
source

pub fn coth_ref(&self) -> CothIncomplete<'_>

Computes the hyperbolic cotangent.

The following 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);
source

pub fn asinh_ref(&self) -> AsinhIncomplete<'_>

Computes the inverse hyperbolic sine.

The following 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);
source

pub fn acosh_ref(&self) -> AcoshIncomplete<'_>

Computes the inverse hyperbolic cosine

The following 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);
source

pub fn atanh_ref(&self) -> AtanhIncomplete<'_>

Computes the inverse hyperbolic tangent.

The following 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);
source

pub fn ln_1p_ref(&self) -> Ln1pIncomplete<'_>

Computes the natural logorithm of one plus the value.

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

§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);
source

pub fn log2_1p_ref(&self) -> LogTwo1pIncomplete<'_>

Computes the logorithm to base 2 of one plus the value.

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

§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let log2_1p = Float::with_val(53, f.log2_1p_ref());
let expected = 2.1625_f64 * two_to_m10;
assert!((log2_1p - expected).abs() < 0.0001 * two_to_m10);
source

pub fn log10_1p_ref(&self) -> LogTen1pIncomplete<'_>

Computes the logorithm to base 10 of one plus the value.

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

§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let log10_1p = Float::with_val(53, f.log10_1p_ref());
let expected = 0.6510_f64 * two_to_m10;
assert!((log10_1p - expected).abs() < 0.0001 * two_to_m10);
source

pub fn exp_m1_ref(&self) -> ExpM1Incomplete<'_>

Computes one less than the exponential of the value.

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

§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);
source

pub fn exp2_m1_ref(&self) -> Exp2M1Incomplete<'_>

Computes one less than 2 to the power of the value.

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

§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let exp2_m1 = Float::with_val(53, f.exp2_m1_ref());
let expected = 1.0402_f64 * two_to_m10;
assert!((exp2_m1 - expected).abs() < 0.0001 * two_to_m10);
source

pub fn exp10_m1_ref(&self) -> Exp10M1Incomplete<'_>

Computes one less than 10 to the power of the value.

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

§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let exp10_m1 = Float::with_val(53, f.exp10_m1_ref());
let expected = 3.4597_f64 * two_to_m10;
assert!((exp10_m1 - expected).abs() < 0.0001 * two_to_m10);
source

pub fn compound_i_ref(&self, n: i32) -> CompoundIIncomplete<'_>

Computes (1 + self) to the power of n.

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

§Examples
use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let compound = Float::with_val(53, f.compound_i_ref(100));
let expected = 1.1576_f64;
assert!((compound - expected).abs() < 0.0001);
source

pub fn eint_ref(&self) -> EintIncomplete<'_>

Computes the exponential integral.

The following 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);
source

pub fn li2_ref(&self) -> Li2Incomplete<'_>

Computes the real part of the dilogarithm of the value.

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

§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);
source

pub fn gamma_ref(&self) -> GammaIncomplete<'_>

Computes the gamma function on the value.

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

§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);
source

pub fn gamma_inc_ref<'a>(&'a self, x: &'a Float) -> GammaIncIncomplete<'a>

Computes the upper incomplete gamma function on the value.

The following 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);
source

pub fn ln_gamma_ref(&self) -> LnGammaIncomplete<'_>

Computes the logarithm of the gamma function on the value.

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

§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);
source

pub fn ln_abs_gamma_ref(&self) -> LnAbsGammaIncomplete<'_>

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

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

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

let neg1_2 = Float::with_val(53, -0.5);
// gamma of -1/2 is -2√π
let abs_gamma_64 = Float::with_val(64, Constant::Pi).sqrt() * 2u32;
let ln_gamma_64 = abs_gamma_64.ln();

// Assign rounds to the nearest
let r = neg1_2.ln_abs_gamma_ref();
let (mut f, mut sign) = (Float::new(53), Ordering::Equal);
(&mut f, &mut sign).assign(r);
// gamma of -1/2 is negative
assert_eq!(sign, Ordering::Less);
// check to 53 significant bits
assert_eq!(f, Float::with_val(53, &ln_gamma_64));
source

pub fn digamma_ref(&self) -> DigammaIncomplete<'_>

Computes the Digamma function on the value.

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

§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);
source

pub fn zeta_ref(&self) -> ZetaIncomplete<'_>

Computes the Riemann Zeta function on the value.

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

§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);
source

pub fn erf_ref(&self) -> ErfIncomplete<'_>

Computes the error function.

The following 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);
source

pub fn erfc_ref(&self) -> ErfcIncomplete<'_>

Computes the complementary error function.

The following 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);
source

pub fn j0_ref(&self) -> J0Incomplete<'_>

Computes the first kind Bessel function of order 0.

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

§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);
source

pub fn j1_ref(&self) -> J1Incomplete<'_>

Computes the first kind Bessel function of order 1.

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

§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);
source

pub fn jn_ref(&self, n: i32) -> JnIncomplete<'_>

Computes the first kind Bessel function of order n.

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

§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);
source

pub fn y0_ref(&self) -> Y0Incomplete<'_>

Computes the second kind Bessel function of order 0.

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

§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);
source

pub fn y1_ref(&self) -> Y1Incomplete<'_>

Computes the second kind Bessel function of order 1.

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

§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);
source

pub fn yn_ref(&self, n: i32) -> YnIncomplete<'_>

Computes the second kind Bessel function of order n.

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

§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);
source

pub fn agm_ref<'a>(&'a self, other: &'a Float) -> AgmIncomplete<'a>

Computes the arithmetic-geometric mean.

The following 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);
source

pub fn hypot_ref<'a>(&'a self, other: &'a Float) -> HypotIncomplete<'a>

Computes the Euclidean norm.

The following 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);
source

pub fn ai_ref(&self) -> AiIncomplete<'_>

Computes the Airy function Ai on the value.

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

§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);
source

pub fn ceil_ref(&self) -> CeilIncomplete<'_>

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

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

§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);
source

pub fn floor_ref(&self) -> FloorIncomplete<'_>

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

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

§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);
source

pub fn round_ref(&self) -> RoundIncomplete<'_>

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

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

§Examples
use rug::Float;
let f1 = Float::with_val(53, -23.75);
let round1 = Float::with_val(53, f1.round_ref());
assert_eq!(round1, -24);
let f2 = Float::with_val(53, 23.75);
let round2 = Float::with_val(53, f2.round_ref());
assert_eq!(round2, 24);

Double rounding may happen when assigning to a target with a precision less than the number of significant bits for the truncated integer.

use rug::float::Round;
use rug::Float;
use rug::ops::AssignRound;
let f = Float::with_val(53, 6.5);
// 6.5 (binary 110.1) is rounded to 7 (binary 111)
let r = f.round_ref();
// use only 2 bits of precision in destination
let mut dst = Float::new(2);
// 7 (binary 111) is rounded to 8 (binary 1000) by
// round-even rule in order to store in 2-bit Float, even
// though 6 (binary 110) is closer to original 6.5).
dst.assign_round(r, Round::Nearest);
assert_eq!(dst, 8);
source

pub fn round_even_ref(&self) -> RoundEvenIncomplete<'_>

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

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

§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);
source

pub fn trunc_ref(&self) -> TruncIncomplete<'_>

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

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

§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);
source

pub fn fract_ref(&self) -> FractIncomplete<'_>

Gets the fractional part of the number.

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

§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);
source

pub fn trunc_fract_ref(&self) -> TruncFractIncomplete<'_>

Gets the integer and fractional parts of the number.

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

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

source§

impl AbsDiffEq for FloatWrapper

source§

type Epsilon = FloatWrapper

Used for specifying relative comparisons.
source§

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together. Read more
source§

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.
§

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].
source§

impl Add for FloatWrapper

source§

type Output = FloatWrapper

The resulting type after applying the + operator.
source§

fn add(self, rhs: Self) -> Self::Output

Performs the + operation. Read more
source§

impl AddAssign for FloatWrapper

source§

fn add_assign(&mut self, rhs: Self)

Performs the += operation. Read more
source§

impl Clone for FloatWrapper

source§

fn clone(&self) -> FloatWrapper

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl ComplexField for FloatWrapper

source§

type RealField = FloatWrapper

source§

fn from_real(re: Self::RealField) -> Self

Builds a pure-real complex number from the given value.
source§

fn real(self) -> Self::RealField

The real part of this complex number.
source§

fn imaginary(self) -> Self::RealField

The imaginary part of this complex number.
source§

fn modulus(self) -> Self::RealField

The modulus of this complex number.
source§

fn modulus_squared(self) -> Self::RealField

The squared modulus of this complex number.
source§

fn argument(self) -> Self::RealField

The argument of this complex number.
source§

fn norm1(self) -> Self::RealField

The sum of the absolute value of this complex number’s real and imaginary part.
source§

fn scale(self, factor: Self::RealField) -> Self

Multiplies this complex number by factor.
source§

fn unscale(self, factor: Self::RealField) -> Self

Divides this complex number by factor.
source§

fn floor(self) -> Self

source§

fn ceil(self) -> Self

source§

fn round(self) -> Self

source§

fn trunc(self) -> Self

source§

fn fract(self) -> Self

source§

fn mul_add(self, _a: Self, _b: Self) -> Self

source§

fn abs(self) -> Self::RealField

The absolute value of this complex number: self / self.signum(). Read more
source§

fn hypot(self, other: Self) -> Self::RealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()
source§

fn recip(self) -> Self

source§

fn conjugate(self) -> Self

source§

fn sin(self) -> Self

source§

fn cos(self) -> Self

source§

fn sin_cos(self) -> (Self, Self)

source§

fn tan(self) -> Self

source§

fn asin(self) -> Self

source§

fn acos(self) -> Self

source§

fn atan(self) -> Self

source§

fn sinh(self) -> Self

source§

fn cosh(self) -> Self

source§

fn tanh(self) -> Self

source§

fn asinh(self) -> Self

source§

fn acosh(self) -> Self

source§

fn atanh(self) -> Self

source§

fn log(self, _base: Self::RealField) -> Self

source§

fn log2(self) -> Self

source§

fn log10(self) -> Self

source§

fn ln(self) -> Self

source§

fn ln_1p(self) -> Self

source§

fn sqrt(self) -> Self

source§

fn exp(self) -> Self

source§

fn exp2(self) -> Self

source§

fn exp_m1(self) -> Self

source§

fn powi(self, _n: i32) -> Self

source§

fn powf(self, _n: Self::RealField) -> Self

source§

fn powc(self, _n: Self) -> Self

source§

fn cbrt(self) -> Self

source§

fn try_sqrt(self) -> Option<Self>

source§

fn is_finite(&self) -> bool

§

fn to_polar(self) -> (Self::RealField, Self::RealField)

The polar form of this complex number: (modulus, arg)
§

fn to_exp(self) -> (Self::RealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})
§

fn signum(self) -> Self

The exponential part of this complex number: self / self.modulus()
§

fn sinh_cosh(self) -> (Self, Self)

§

fn sinc(self) -> Self

Cardinal sine
§

fn sinhc(self) -> Self

§

fn cosc(self) -> Self

Cardinal cos
§

fn coshc(self) -> Self

source§

impl Debug for FloatWrapper

source§

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

Formats the value using the given formatter. Read more
source§

impl Deref for FloatWrapper

source§

type Target = Float

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl Display for FloatWrapper

source§

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

Formats the value using the given formatter. Read more
source§

impl Div for FloatWrapper

source§

type Output = FloatWrapper

The resulting type after applying the / operator.
source§

fn div(self, rhs: Self) -> Self::Output

Performs the / operation. Read more
source§

impl DivAssign for FloatWrapper

source§

fn div_assign(&mut self, rhs: Self)

Performs the /= operation. Read more
source§

impl From<Float> for FloatWrapper

source§

fn from(f: Float) -> Self

Converts to this type from the input type.
source§

impl FromPrimitive for FloatWrapper

source§

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned. Read more
source§

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned. Read more
source§

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.
source§

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned. Read more
source§

impl Mul for FloatWrapper

source§

type Output = FloatWrapper

The resulting type after applying the * operator.
source§

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation. Read more
source§

impl MulAssign for FloatWrapper

source§

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation. Read more
source§

impl Neg for FloatWrapper

source§

type Output = FloatWrapper

The resulting type after applying the - operator.
source§

fn neg(self) -> Self::Output

Performs the unary - operation. Read more
source§

impl Num for FloatWrapper

source§

type FromStrRadixErr = ParseFloatError

source§

fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36). Read more
source§

impl One for FloatWrapper

source§

fn one() -> Self

Returns the multiplicative identity element of Self, 1. Read more
source§

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.
source§

fn is_one(&self) -> bool
where Self: PartialEq,

Returns true if self is equal to the multiplicative identity. Read more
source§

impl PartialEq for FloatWrapper

source§

fn eq(&self, other: &FloatWrapper) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd for FloatWrapper

source§

fn partial_cmp(&self, other: &FloatWrapper) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl RealField for FloatWrapper

source§

fn is_sign_positive(&self) -> bool

Is the sign of this real number positive?
source§

fn is_sign_negative(&self) -> bool

Is the sign of this real number negative?
source§

fn copysign(self, _sign: Self) -> Self

Copies the sign of sign to self. Read more
source§

fn max(self, _other: Self) -> Self

source§

fn min(self, _other: Self) -> Self

source§

fn clamp(self, _min: Self, _max: Self) -> Self

source§

fn atan2(self, _other: Self) -> Self

source§

fn min_value() -> Option<Self>

The smallest finite positive value representable using this type.
source§

fn max_value() -> Option<Self>

The largest finite positive value representable using this type.
source§

fn pi() -> Self

source§

fn two_pi() -> Self

source§

fn frac_pi_2() -> Self

source§

fn frac_pi_3() -> Self

source§

fn frac_pi_4() -> Self

source§

fn frac_pi_6() -> Self

source§

fn frac_pi_8() -> Self

source§

fn frac_1_pi() -> Self

source§

fn frac_2_pi() -> Self

source§

fn frac_2_sqrt_pi() -> Self

source§

fn e() -> Self

source§

fn log2_e() -> Self

source§

fn log10_e() -> Self

source§

fn ln_2() -> Self

source§

fn ln_10() -> Self

source§

impl RelativeEq for FloatWrapper

source§

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart. Read more
source§

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.
§

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of [RelativeEq::relative_eq].
source§

impl Rem for FloatWrapper

source§

type Output = FloatWrapper

The resulting type after applying the % operator.
source§

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation. Read more
source§

impl RemAssign for FloatWrapper

source§

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation. Read more
source§

impl Signed for FloatWrapper

source§

fn abs(&self) -> Self

Computes the absolute value. Read more
source§

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers. Read more
source§

fn signum(&self) -> Self

Returns the sign of the number. Read more
source§

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.
source§

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.
source§

impl SimdValue for FloatWrapper

source§

const LANES: usize = 1usize

The number of lanes of this SIMD value.
source§

type Element = FloatWrapper

The type of the elements of each lane of this SIMD value.
source§

type SimdBool = bool

Type of the result of comparing two SIMD values like self.
source§

fn splat(val: Self::Element) -> Self

Initializes an SIMD value with each lanes set to val.
source§

fn extract(&self, _: usize) -> Self::Element

Extracts the i-th lane of self. Read more
source§

unsafe fn extract_unchecked(&self, _: usize) -> Self::Element

Extracts the i-th lane of self without bound-checking. Read more
source§

fn replace(&mut self, _: usize, val: Self::Element)

Replaces the i-th lane of self by val. Read more
source§

unsafe fn replace_unchecked(&mut self, _: usize, val: Self::Element)

Replaces the i-th lane of self by val without bound-checking. Read more
source§

fn select(self, cond: Self::SimdBool, other: Self) -> Self

Merges self and other depending on the lanes of cond. Read more
§

fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self
where Self: Clone,

Applies a function to each lane of self. Read more
§

fn zip_map_lanes( self, b: Self, f: impl Fn(Self::Element, Self::Element) -> Self::Element, ) -> Self
where Self: Clone,

Applies a function to each lane of self paired with the corresponding lane of b. Read more
source§

impl Sub for FloatWrapper

source§

type Output = FloatWrapper

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation. Read more
source§

impl SubAssign for FloatWrapper

source§

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation. Read more
source§

impl SubsetOf<FloatWrapper> for FloatWrapper

source§

fn to_superset(&self) -> Self

The inclusion map: converts self to the equivalent element of its superset.
source§

fn from_superset_unchecked(element: &Self) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.
source§

fn is_in_subset(_element: &Self) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).
§

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
source§

impl SupersetOf<f32> for FloatWrapper

source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
source§

fn to_subset(&self) -> Option<f32>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
source§

fn to_subset_unchecked(&self) -> f32

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
source§

fn from_subset(element: &f32) -> Self

The inclusion map: converts self to the equivalent element of its superset.
source§

impl SupersetOf<f64> for FloatWrapper

source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
source§

fn to_subset(&self) -> Option<f64>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
source§

fn to_subset_unchecked(&self) -> f64

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
source§

fn from_subset(element: &f64) -> Self

The inclusion map: converts self to the equivalent element of its superset.
source§

impl UlpsEq for FloatWrapper

source§

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart. Read more
source§

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, _max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.
§

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of [UlpsEq::ulps_eq].
source§

impl Zero for FloatWrapper

source§

fn zero() -> Self

Returns the additive identity element of Self, 0. Read more
source§

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.
source§

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.
source§

impl Field for FloatWrapper

source§

impl StructuralPartialEq for FloatWrapper

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Az for T

source§

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

Casts the value.
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

source§

fn cast_from(src: Src) -> Dst

Casts the value.
source§

impl<T> CheckedAs for T

source§

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

Casts the value.
source§

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

source§

fn checked_cast_from(src: Src) -> Option<Dst>

Casts the value.
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> OverflowingAs for T

source§

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

Casts the value.
source§

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

source§

fn overflowing_cast_from(src: Src) -> (Dst, bool)

Casts the value.
source§

impl<T> PercentileResolve for T
where T: Add<Output = T> + Div<Output = T> + One,

source§

fn mean(a: T, b: T) -> T

source§

fn compute(percentile: MeanValue<Self>) -> Self

source§

impl<T> Same for T

source§

type Output = T

Should always be Self
source§

impl<T> SaturatingAs for T

source§

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

Casts the value.
source§

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,

source§

fn saturating_cast_from(src: Src) -> Dst

Casts the value.
§

impl<T> SimdComplexField for T
where T: ComplexField,

§

type SimdRealField = <T as ComplexField>::RealField

Type of the coefficients of a complex number.
§

fn from_simd_real(re: <T as SimdComplexField>::SimdRealField) -> T

Builds a pure-real complex number from the given value.
§

fn simd_real(self) -> <T as SimdComplexField>::SimdRealField

The real part of this complex number.
§

fn simd_imaginary(self) -> <T as SimdComplexField>::SimdRealField

The imaginary part of this complex number.
§

fn simd_modulus(self) -> <T as SimdComplexField>::SimdRealField

The modulus of this complex number.
§

fn simd_modulus_squared(self) -> <T as SimdComplexField>::SimdRealField

The squared modulus of this complex number.
§

fn simd_argument(self) -> <T as SimdComplexField>::SimdRealField

The argument of this complex number.
§

fn simd_norm1(self) -> <T as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.
§

fn simd_scale(self, factor: <T as SimdComplexField>::SimdRealField) -> T

Multiplies this complex number by factor.
§

fn simd_unscale(self, factor: <T as SimdComplexField>::SimdRealField) -> T

Divides this complex number by factor.
§

fn simd_to_polar( self, ) -> (<T as SimdComplexField>::SimdRealField, <T as SimdComplexField>::SimdRealField)

The polar form of this complex number: (modulus, arg)
§

fn simd_to_exp(self) -> (<T as SimdComplexField>::SimdRealField, T)

The exponential form of this complex number: (modulus, e^{i arg})
§

fn simd_signum(self) -> T

The exponential part of this complex number: self / self.modulus()
§

fn simd_floor(self) -> T

§

fn simd_ceil(self) -> T

§

fn simd_round(self) -> T

§

fn simd_trunc(self) -> T

§

fn simd_fract(self) -> T

§

fn simd_mul_add(self, a: T, b: T) -> T

§

fn simd_abs(self) -> <T as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum(). Read more
§

fn simd_hypot(self, other: T) -> <T as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()
§

fn simd_recip(self) -> T

§

fn simd_conjugate(self) -> T

§

fn simd_sin(self) -> T

§

fn simd_cos(self) -> T

§

fn simd_sin_cos(self) -> (T, T)

§

fn simd_sinh_cosh(self) -> (T, T)

§

fn simd_tan(self) -> T

§

fn simd_asin(self) -> T

§

fn simd_acos(self) -> T

§

fn simd_atan(self) -> T

§

fn simd_sinh(self) -> T

§

fn simd_cosh(self) -> T

§

fn simd_tanh(self) -> T

§

fn simd_asinh(self) -> T

§

fn simd_acosh(self) -> T

§

fn simd_atanh(self) -> T

§

fn simd_sinc(self) -> T

Cardinal sine
§

fn simd_sinhc(self) -> T

§

fn simd_cosc(self) -> T

Cardinal cos
§

fn simd_coshc(self) -> T

§

fn simd_log(self, base: <T as SimdComplexField>::SimdRealField) -> T

§

fn simd_log2(self) -> T

§

fn simd_log10(self) -> T

§

fn simd_ln(self) -> T

§

fn simd_ln_1p(self) -> T

§

fn simd_sqrt(self) -> T

§

fn simd_exp(self) -> T

§

fn simd_exp2(self) -> T

§

fn simd_exp_m1(self) -> T

§

fn simd_powi(self, n: i32) -> T

§

fn simd_powf(self, n: <T as SimdComplexField>::SimdRealField) -> T

§

fn simd_powc(self, n: T) -> T

§

fn simd_cbrt(self) -> T

§

fn simd_horizontal_sum(self) -> <T as SimdValue>::Element

Computes the sum of all the lanes of self.
§

fn simd_horizontal_product(self) -> <T as SimdValue>::Element

Computes the product of all the lanes of self.
§

impl<T> SimdPartialOrd for T
where T: SimdValue<Element = T, SimdBool = bool> + PartialOrd,

§

fn simd_gt(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise greater than > comparison.
§

fn simd_lt(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise less than < comparison.
§

fn simd_ge(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise greater or equal >= comparison.
§

fn simd_le(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise less or equal <= comparison.
§

fn simd_eq(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise equal == comparison.
§

fn simd_ne(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise not equal != comparison.
§

fn simd_max(self, other: T) -> T

Lanewise max value.
§

fn simd_min(self, other: T) -> T

Lanewise min value.
§

fn simd_clamp(self, min: T, max: T) -> T

Clamps each lane of self between the corresponding lane of min and max.
§

fn simd_horizontal_min(self) -> <T as SimdValue>::Element

The min value among all lanes of self.
§

fn simd_horizontal_max(self) -> <T as SimdValue>::Element

The max value among all lanes of self.
§

impl<T> SimdRealField for T
where T: RealField,

§

fn simd_atan2(self, other: T) -> T

§

fn simd_default_epsilon() -> T

§

fn simd_copysign(self, sign: T) -> T

Copies the sign of sign to self. Read more
§

fn simd_pi() -> T

§

fn simd_two_pi() -> T

§

fn simd_frac_pi_2() -> T

§

fn simd_frac_pi_3() -> T

§

fn simd_frac_pi_4() -> T

§

fn simd_frac_pi_6() -> T

§

fn simd_frac_pi_8() -> T

§

fn simd_frac_1_pi() -> T

§

fn simd_frac_2_pi() -> T

§

fn simd_frac_2_sqrt_pi() -> T

§

fn simd_e() -> T

§

fn simd_log2_e() -> T

§

fn simd_log10_e() -> T

§

fn simd_ln_2() -> T

§

fn simd_ln_10() -> T

§

impl<T> SimdSigned for T
where T: Signed + SimdValue<SimdBool = bool>,

§

fn simd_abs(&self) -> T

The absolute value of each lane of self.
§

fn simd_abs_sub(&self, other: &T) -> T

The absolute difference of each lane of self. Read more
§

fn simd_signum(&self) -> T

The signum of each lane of Self.
§

fn is_simd_positive(&self) -> <T as SimdValue>::SimdBool

Tests which lane is positive.
§

fn is_simd_negative(&self) -> <T as SimdValue>::SimdBool

Tests which lane is negative.
§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> UnwrappedAs for T

source§

fn unwrapped_as<Dst>(self) -> Dst
where T: UnwrappedCast<Dst>,

Casts the value.
source§

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst
where Src: UnwrappedCast<Dst>,

source§

fn unwrapped_cast_from(src: Src) -> Dst

Casts the value.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

source§

impl<T> WrappingAs for T

source§

fn wrapping_as<Dst>(self) -> Dst
where T: WrappingCast<Dst>,

Casts the value.
source§

impl<Src, Dst> WrappingCastFrom<Src> for Dst
where Src: WrappingCast<Dst>,

source§

fn wrapping_cast_from(src: Src) -> Dst

Casts the value.
§

impl<T, Right> ClosedAdd<Right> for T
where T: Add<Right, Output = T> + AddAssign<Right>,

§

impl<T, Right> ClosedAddAssign<Right> for T
where T: ClosedAdd<Right> + AddAssign<Right>,

§

impl<T, Right> ClosedDiv<Right> for T
where T: Div<Right, Output = T> + DivAssign<Right>,

§

impl<T, Right> ClosedDivAssign<Right> for T
where T: ClosedDiv<Right> + DivAssign<Right>,

§

impl<T, Right> ClosedMul<Right> for T
where T: Mul<Right, Output = T> + MulAssign<Right>,

§

impl<T, Right> ClosedMulAssign<Right> for T
where T: ClosedMul<Right> + MulAssign<Right>,

§

impl<T> ClosedNeg for T
where T: Neg<Output = T>,

§

impl<T, Right> ClosedSub<Right> for T
where T: Sub<Right, Output = T> +