Struct rug::Float

pub struct Float { /* fields omitted */ }

A multi-precision floating-point number with arbitrarily large precision and correct rounding

The precision has to be set during construction. The rounding method of the required operations can be specified, and the direction of the rounding is returned.

Examples

use rug::Float;
use rug::float::Round;
use rug::ops::DivAssignRound;
use std::cmp::Ordering;
// A precision of 32 significant bits is specified here.
// (The primitive `f32` has a precision of 24 and
// `f64` has a precision of 53.)
let mut two_thirds_down = Float::with_val(32, 2.0);
let dir = two_thirds_down.div_assign_round(3.0, Round::Down);
// since we rounded down, direction is Ordering::Less
assert_eq!(dir, Ordering::Less);
let mut two_thirds_up = Float::with_val(32, 2.0);
let dir = two_thirds_up.div_assign_round(3.0, Round::Up);
// since we rounded up, direction is Ordering::Greater
assert_eq!(dir, Ordering::Greater);
let diff_expected = 2.0_f64.powi(-32);
let diff = two_thirds_up - two_thirds_down;
assert_eq!(diff, diff_expected);

Operations on two borrowed Float numbers result in an intermediate value that has to be assigned to a new Float value.

use rug::Float;
let a = Float::with_val(53, 10.5);
let b = Float::with_val(53, -1.25);
let a_b_ref = &a + &b;
let a_b = Float::with_val(53, a_b_ref);
assert_eq!(a_b, 9.25);

As a special case, when an intermediate value is obtained from multiplying two Float references, it can be added to or subtracted from another Float (or reference). This will result in a fused multiply-accumulate operation, with only one rounding operation taking place.

use rug::Float;
// Use only 4 bits of precision for demonstration purposes.
// 24 in binary is 11000.
let a = Float::with_val(4, 24);
// 1.5 in binary is 1.1.
let mul1 = Float::with_val(4, 1.5);
// -13 in binary is -1101.
let mul2 = Float::with_val(4, -13);
// 24 + 1.5 * -13 = 4.5
let add = Float::with_val(4, &a + &mul1 * &mul2);
assert_eq!(add, 4.5);
// 24 - 1.5 * -13 = 43.5, rounded to 44 using four bits of precision.
let sub = a - &mul1 * &mul2;
assert_eq!(sub, 44);

// With separate addition and multiplication:
let a = Float::with_val(4, 24);
// No borrows, so multiplication is computed immediately.
// 1.5 * -13 = -19.5 (binary -10011.1), rounded to -20.
let separate_add = a + mul1 * mul2;
assert_eq!(separate_add, 4);

The Float type supports various functions. Most methods have four versions:

1. The first method consumes the operand and rounds the returned Float to the nearest representable value.
2. The second method has a _mut suffix, mutates the operand and rounds it the nearest representable value.
3. The third method has a _round suffix, mutates the operand, applies the specified rounding method, and returns the rounding direction:
   • Ordering::Less if the stored value is less than the exact result,
   • Ordering::Equal if the stored value is equal to the exact result,
   • Ordering::Greater if the stored value is greater than the exact result.
4. The fourth method has a _ref suffix and borrows the operand. The returned item can be assigned to a Float, and the rounding method is selected during the assignment.

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let expected = 0.9490_f64;

// 1. consume the operand, round to nearest
let a = Float::with_val(53, 1.25);
let sin_a = a.sin();
assert!((sin_a - expected).abs() < 0.0001);

// 2. mutate the operand, round to nearest
let mut b = Float::with_val(53, 1.25);
b.sin_mut();
assert!((b - expected).abs() < 0.0001);

// 3. mutate the operand, apply specified rounding
let mut c = Float::with_val(4, 1.25);
// using 4 significant bits, 0.9490 is rounded down to 0.9375
let dir = c.sin_round(Round::Nearest);
assert_eq!(c, 0.9375);
assert_eq!(dir, Ordering::Less);

// 4. borrow the operand
let d = Float::with_val(53, 1.25);
let r = d.sin_ref();
let sin_d = Float::with_val(53, r);
assert!((sin_d - expected).abs() < 0.0001);
// d was not consumed
assert_eq!(d, 1.25);

The following example is a translation of the MPFR sample found on the MPFR website. The program computes a lower bound on 1 + 1/1! + 1/2! + … + 1/100! using 200-bit precision. The program writes:

Sum is 2.7182818284590452353602874713526624977572470936999595749669131

extern crate rug;
use rug::Float;
use rug::float::{AssignRound, Round};
use rug::ops::{AddAssignRound, MulAssignRound};

fn main() {
    let mut t = Float::with_val(200, 1.0);
    let mut s = Float::with_val(200, 1.0);
    let mut u = Float::new(200);
    for i in 1..101_u32 {
        // multiply t by i in place, round towards plus infinity
        t.mul_assign_round(i, Round::Up);
        // set u to 1/t, round towards minus infinity
        u.assign_round(t.recip_ref(), Round::Down);
        // increase s by u in place, round towards minus infinity
        s.add_assign_round(&u, Round::Down);
    }
    // `None` means the number of printed digits depends on the precision
    let sr = s.to_string_radix_round(10, None, Round::Down);
    println!("Sum is {}", sr);
}

Methods

impl Float

fn new(prec: u32) -> Float

Create a new floating-point number with the specified precision and with value 0.

Examples

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

Panics

Panics if prec is out of the allowed range.

fn with_val<T>(prec: u32, val: T) -> Float where
    Float: Assign<T>, 

Create a new floating-point number with the specified precision and with the given value, rounding to the nearest.

Examples

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

Panics

Panics if prec is out of the allowed range.

fn with_val_round<T>(prec: u32, val: T, round: Round) -> (Float, Ordering) where
    Float: AssignRound<T, Round = Round, Ordering = Ordering>, 

Create a new floating-point number with the specified precision and with the given value, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let (f1, dir) = Float::with_val_round(4, 3.3, Round::Nearest);
// 3.3 with precision 4 is rounded down to 3.25
assert_eq!(f1.prec(), 4);
assert_eq!(f1, 3.25);
assert_eq!(dir, Ordering::Less);
let (f2, dir) = Float::with_val_round(4, 3.3, Round::Up);
// 3.3 rounded up to 3.5
assert_eq!(f2.prec(), 4);
assert_eq!(f2, 3.5);
assert_eq!(dir, Ordering::Greater);

Panics

Panics if prec is out of the allowed range.

fn prec(&self) -> u32

Returns the precision.

Examples

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

fn set_prec(&mut self, prec: u32)

Sets the precision, rounding to the nearest.

Examples

use rug::Float;
// 16.25 has seven significant bits (binary 10000.01)
let mut f = Float::with_val(53, 16.25);
f.set_prec(5);
assert_eq!(f, 16);
assert_eq!(f.prec(), 5);

Panics

Panics if prec is out of the allowed range.

fn set_prec_round(&mut self, prec: u32, round: Round) -> Ordering

Sets the precision, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 16.25 has seven significant bits (binary 10000.01)
let mut f = Float::with_val(53, 16.25);
let dir = f.set_prec_round(5, Round::Up);
assert_eq!(f, 17);
assert_eq!(dir, Ordering::Greater);
assert_eq!(f.prec(), 5);

Panics

Panics if prec is out of the allowed range.

fn from_str(src: &str, prec: u32) -> Result<Float, ParseFloatError>

Parses a Float with the specified precision, rounding to the nearest.

Examples

use rug::Float;
let f = match Float::from_str("12.5e2", 53) {
    Ok(f) => f,
    Err(_) => unreachable!(),
};
assert_eq!(f, 12.5e2);
let err_ret = Float::from_str("bad", 53);
assert!(err_ret.is_err());

fn from_str_round(
    src: &str,
    prec: u32,
    round: Round
) -> Result<(Float, Ordering), ParseFloatError>

Parses a Float with the specified precision, applying the specified rounding.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let (f, dir) = match Float::from_str_round("14.1", 4, Round::Down) {
    Ok(f_dir) => f_dir,
    Err(_) => unreachable!(),
};
assert_eq!(f, 14);
assert_eq!(dir, Ordering::Less);

fn from_str_radix(
    src: &str,
    radix: i32,
    prec: u32
) -> Result<Float, ParseFloatError>

Parses a Float with the specified radix and precision, rounding to the nearest.

Examples

use rug::Float;
let f = match Float::from_str_radix("f.f", 16, 53) {
    Ok(f) => f,
    Err(_) => unreachable!(),
};
assert_eq!(f, 15.9375);

Panics

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

fn from_str_radix_round(
    src: &str,
    radix: i32,
    prec: u32,
    round: Round
) -> Result<(Float, Ordering), ParseFloatError>

Parses a Float with the specified radix and precision, applying the specified rounding.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let (f, dir) =
    match Float::from_str_radix_round("e.c", 16, 4, Round::Up) {
        Ok(f_dir) => f_dir,
        Err(_) => unreachable!(),
    };
assert_eq!(f, 15);
assert_eq!(dir, Ordering::Greater);

Panics

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

fn valid_str_radix(src: &str, radix: i32) -> Result<ValidFloat, ParseFloatError>

Checks if a Float can be parsed.

If this method does not return an error, neither will any other function that parses a Float. If this method returns an error, the other functions will return the same error.

The string can start with an optional minus or plus sign. Whitespace is not allowed anywhere in the string, including in the beginning and end.

Examples

use rug::Float;

let valid1 = Float::valid_str_radix("12.23e-4", 4);
let f1 = Float::with_val(53, valid1.unwrap());
assert_eq!(f1, (2.0 + 4.0 * 1.0 + 0.25 * (2.0 + 0.25 * 3.0)) / 256.0);
let valid2 = Float::valid_str_radix("12.yz@2", 36);
let f2 = Float::with_val(53, valid2.unwrap());
assert_eq!(f2, 35 + 36 * (34 + 36 * (2 + 36 * 1)));

let invalid = Float::valid_str_radix("ffe-2", 16);
let invalid_f = Float::from_str_radix("ffe-2", 16, 53);
assert_eq!(invalid.unwrap_err(), invalid_f.unwrap_err());

Panics

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

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

Converts to an integer, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 13.7);
let i = match f.to_integer() {
    Some(i) => i,
    None => unreachable!(),
};
assert_eq!(i, 14);

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

Converts to an integer, applying the specified rounding method.

Examples

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

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

If the value is a finite number, returns an Integer and exponent such that self is exactly equal to the integer multiplied by two raised to the power of the exponent.

Examples

use rug::{Assign, Float};
use rug::float::Special;
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());

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

If the value is a finite number, returns a Rational number preserving all the precision of the value.

Examples

use rug::{Float, Rational};
use rug::float::Round;
use std::str::FromStr;
use std::cmp::Ordering;

// Consider the number 123,456,789 / 10,000,000,000.
let res = Float::from_str_round("0.0123456789", 35, Round::Down);
let (f, f_rounding) = res.unwrap();
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);

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

Converts to an i32, rounding to the nearest.

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

Examples

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

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;
use rug::float::Round;
let f = Float::with_val(53, -13.7);
assert_eq!(f.to_i32_saturating_round(Round::Up), Some(-13));

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

Converts to a u32, rounding to the nearest.

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

Examples

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

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;
use rug::float::Round;
let f = Float::with_val(53, 13.7);
assert_eq!(f.to_u32_saturating_round(Round::Down), Some(13));

fn to_f32(&self) -> f32

Converts to an f32, rounding to the nearest.

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

Examples

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

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;
use rug::float::Round;
use std::f32;
let f = Float::with_val(53, 1.0 + (-50f64).exp2());
assert_eq!(f.to_f32_round(Round::Up), 1.0 + f32::EPSILON);

fn to_f64(&self) -> f64

Converts to an f64, rounding to the nearest.

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

Examples

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

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;
use rug::float::Round;
use std::f64;
// (2.0 ^ -90) + 1
let f: Float = Float::with_val(100, -90).exp2() + 1;
assert_eq!(f.to_f64_round(Round::Up), 1.0 + f64::EPSILON);

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

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;
use rug::float::Round;
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));

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

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;
use rug::float::Round;
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));

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

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

The exponent is encoded in decimal. The output string will have enough precision such that reading it again will give the exact same number.

Examples

use rug::Float;
use rug::float::Special;
let neg_inf = Float::with_val(53, Special::NegInfinity);
assert_eq!(neg_inf.to_string_radix(10, None), "-inf");
assert_eq!(neg_inf.to_string_radix(16, None), "-@inf@");
let twentythree = Float::with_val(8, 23);
assert_eq!(twentythree.to_string_radix(10, None), "2.300e1");
assert_eq!(twentythree.to_string_radix(16, None), "1.70@1");
assert_eq!(twentythree.to_string_radix(10, Some(2)), "2.3e1");
assert_eq!(twentythree.to_string_radix(16, Some(4)), "1.700@1");

Panics

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

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

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

The exponent is encoded in decimal. The output string will have enough precision such that reading it again will give the exact same number.

Examples

use rug::Float;
use rug::float::Round;
let twentythree = Float::with_val(8, 23.3);
let down = twentythree.to_string_radix_round(10, Some(2), Round::Down);
assert_eq!(down, "2.3e1");
let up = twentythree.to_string_radix_round(10, Some(2), Round::Up);
assert_eq!(up, "2.4e1");

Panics

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

fn assign_str(&mut self, src: &str) -> Result<(), ParseFloatError>

Parses a Float from a string, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::new(53);
let ok_ret = f.assign_str("12.5e2");
assert!(ok_ret.is_ok());
assert_eq!(f, 12.5e2);
let err_ret = f.assign_str("bad");
assert!(err_ret.is_err());

fn assign_str_round(
    &mut self,
    src: &str,
    round: Round
) -> Result<Ordering, ParseFloatError>

Parses a Float from a string, applying the specified rounding.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let mut f = Float::new(4);
let dir = match f.assign_str_round("14.1", Round::Down) {
    Ok(dir) => dir,
    Err(_) => unreachable!(),
};
assert_eq!(f, 14);
assert_eq!(dir, Ordering::Less);

fn assign_str_radix(
    &mut self,
    src: &str,
    radix: i32
) -> Result<(), ParseFloatError>

Parses a Float from a string with the specified radix, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::new(53);
let ok_ret = f.assign_str_radix("f.f", 16);
assert!(ok_ret.is_ok());
assert_eq!(f, 15.9375);

Panics

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

fn assign_str_radix_round(
    &mut self,
    src: &str,
    radix: i32,
    round: Round
) -> Result<Ordering, ParseFloatError>

Parses a Float from a string with the specified radix, applying the specified rounding.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let mut f = Float::new(4);
let dir = match f.assign_str_radix_round("e.c", 16, Round::Up) {
    Ok(dir) => dir,
    Err(_) => unreachable!(),
};
assert_eq!(f, 15);
assert_eq!(dir, Ordering::Greater);

Panics

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

fn as_neg(&self) -> BorrowFloat

Borrows a negated copy of the Float.

The returned object implements Deref with a Float target. This method performs a shallow copy and negates it, and negation does not change the allocated data.

Examples

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

fn as_abs(&self) -> BorrowFloat

Borrows an absolute copy of the Float.

The returned object implements Deref with a Float target. This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.

Examples

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

fn as_ord(&self) -> &OrdFloat

Borrows the Float as an ordered float of type OrdFloat.

Examples

use rug::Float;
use rug::float::Special;
use std::cmp::Ordering;

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

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

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

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

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

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

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

fn is_zero(&self) -> bool

Returns true if self is plus or minus zero.

Examples

use rug::{Assign, Float};
use rug::float::Special;
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());

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::{Assign, Float};
use rug::float::Special;
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());

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

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

Examples

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

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

Compares the absolute values of self and other.

Examples

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

fn get_exp(&self) -> Option<i32>

Returns the exponent of self if self is a normal number, otherwise None.

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

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

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

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

Emulate subnormal numbers, rounding to the nearest.

Subnormalization is only performed for precisions corresponding to IEEE 754 half precision (11), single precision (24), double precision (53), quadruple precision (113) and octuple precision (237).

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

Examples

use rug::Float;
use std::f32;
let single_min_subnormal = (-149f64).exp2();
assert_eq!(single_min_subnormal, single_min_subnormal as f32 as f64);
let single_cannot = single_min_subnormal * 1.25;
assert_eq!(single_min_subnormal, single_cannot as f32 as f64);
let mut f = Float::with_val(24, single_cannot);
assert_eq!(f.to_f64(), single_cannot);
f.subnormalize();
assert_eq!(f.to_f64(), single_min_subnormal);

fn subnormalize_round(
    &mut self,
    prev_rounding: Ordering,
    round: Round
) -> Ordering

Emulate subnormal numbers, applying the specified rounding method.

Subnormalization is only performed for precisions corresponding to IEEE 754 half precision (11), single precision (24), double precision (53), quadruple precision (113) and octuple precision (237).

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
use std::f32;
let single_min_subnormal = (-149f64).exp2();
assert_eq!(single_min_subnormal, single_min_subnormal as f32 as f64);
let single_cannot = single_min_subnormal * 1.25;
assert_eq!(single_min_subnormal, single_cannot as f32 as f64);
let mut f = Float::with_val(24, single_cannot);
assert_eq!(f.to_f64(), single_cannot);
let dir = f.subnormalize_round(Ordering::Equal, Round::Up);
assert_eq!(f.to_f64(), single_min_subnormal * 2.0);
assert_eq!(dir, Ordering::Greater);

fn square(self) -> Float

Computes the square, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 5.0);
let square = f.square();
assert_eq!(square, 25.0);

fn square_mut(&mut self)

Computes the square, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 5.0);
f.square_mut();
assert_eq!(f, 25.0);

fn square_round(&mut self, round: Round) -> Ordering

Computes the square, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 5 in binary is 101
let mut f = Float::with_val(3, 5.0);
// 25 in binary is 11001 (more than 3 bits of precision).
// 25 (11001) is rounded up to 28 (11100).
let dir = f.square_round(Round::Up);
assert_eq!(f, 28.0);
assert_eq!(dir, Ordering::Greater);

fn square_ref(&self) -> SquareRef

Computes the square.

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

fn sqrt(self) -> Float

Computes the square root, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 25.0);
let sqrt = f.sqrt();
assert_eq!(sqrt, 5.0);

fn sqrt_mut(&mut self)

Computes the square root, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 25.0);
f.sqrt_mut();
assert_eq!(f, 5.0);

fn sqrt_round(&mut self, round: Round) -> Ordering

Computes the square root, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 5 in binary is 101
let mut f = Float::with_val(4, 5.0);
// sqrt(5) in binary is 10.00111100...
// sqrt(5) is rounded to 2.25 (10.01).
let dir = f.sqrt_round(Round::Nearest);
assert_eq!(f, 2.25);
assert_eq!(dir, Ordering::Greater);

fn sqrt_ref(&self) -> SqrtRef

Computes the square root.

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

fn assign_sqrt_u(&mut self, u: u32)

Sets self to the square root of u, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::new(53);
f.assign_sqrt_u(25);
assert_eq!(f, 5.0);

fn assign_sqrt_u_round(&mut self, u: u32, round: Round) -> Ordering

Sets self to the square root of u, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 4 bits of precision
let mut f = Float::new(4);
// sqrt(5) in binary is 10.00111100...
// sqrt(5) is rounded to 2.25 (10.01).
let dir = f.assign_sqrt_u_round(5, Round::Nearest);
assert_eq!(f, 2.25);
assert_eq!(dir, Ordering::Greater);

fn recip_sqrt(self) -> Float

Computes the reciprocal square root, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 16.0);
let recip_sqrt = f.recip_sqrt();
assert_eq!(recip_sqrt, 0.25);

fn recip_sqrt_mut(&mut self)

Computes the reciprocal square root, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 16.0);
f.recip_sqrt_mut();
assert_eq!(f, 0.25);

fn recip_sqrt_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 5 in binary is 101
let mut f = Float::with_val(4, 5.0);
// 1/sqrt(5) in binary is 0.01110010...
// 1/sqrt(5) is rounded to 0.4375 (0.01110).
let dir = f.recip_sqrt_round(Round::Nearest);
assert_eq!(f, 0.4375);
assert_eq!(dir, Ordering::Less);

fn recip_sqrt_ref(&self) -> RecipSqrtRef

Computes the reciprocal square root.

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

fn cbrt(self) -> Float

Computes the cube root, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 125.0);
let cbrt = f.cbrt();
assert_eq!(cbrt, 5.0);

fn cbrt_mut(&mut self)

Computes the cube root, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 125.0);
f.cbrt_mut();
assert_eq!(f, 5.0);

fn cbrt_round(&mut self, round: Round) -> Ordering

Computes the cube root, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 5 in binary is 101
let mut f = Float::with_val(4, 5.0);
// cbrt(5) in binary is 1.101101...
// cbrt(5) is rounded to 1.75 (1.110).
let dir = f.cbrt_round(Round::Nearest);
assert_eq!(f, 1.75);
assert_eq!(dir, Ordering::Greater);

fn cbrt_ref(&self) -> CbrtRef

Computes the cube root.

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

fn root(self, k: u32) -> Float

Computes the kth root, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 625.0);
let root = f.root(4);
assert_eq!(root, 5.0);

fn root_mut(&mut self, k: u32)

Computes the kth root, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 625.0);
f.root_mut(4);
assert_eq!(f, 5.0);

fn root_round(&mut self, k: u32, round: Round) -> Ordering

Computes the kth root, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 5 in binary is 101
let mut f = Float::with_val(4, 5.0);
// fourth root of 5 in binary is 1.01111...
// fourth root of 5 is rounded to 1.5 (1.100).
let dir = f.root_round(4, Round::Nearest);
assert_eq!(f, 1.5);
assert_eq!(dir, Ordering::Greater);

fn root_ref(&self, k: u32) -> RootRef

Computes the kth root.

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

fn abs(self) -> Float

Computes the absolute value.

Examples

use rug::Float;
let f = Float::with_val(53, -23.5);
let abs = f.abs();
assert_eq!(abs, 23.5);

fn abs_mut(&mut self)

Computes the absolute value.

Examples

use rug::Float;
let mut f = Float::with_val(53, -23.5);
f.abs_mut();
assert_eq!(f, 23.5);

fn abs_ref(&self) -> AbsRef

Computes the absolute value.

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

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

Clamps the value within the specified bounds, rounding to the nearest.

Examples

use rug::Float;
let min = -1.5;
let max = 1.5;
let too_small = Float::with_val(53, -2.5);
let clamped1 = too_small.clamp(&min, &max);
assert_eq!(clamped1, -1.5);
let in_range = Float::with_val(53, 0.5);
let clamped2 = in_range.clamp(&min, &max);
assert_eq!(clamped2, 0.5);

Panics

Panics if the maximum value is less than the minimum value.

fn clamp_mut<'a, Min, Max>(&mut self, min: &'a Min, max: &'a Max) where
    Float: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>, 

Clamps the value within the specified bounds, rounding to the nearest.

Examples

use rug::Float;
let min = -1.5;
let max = 1.5;
let mut too_small = Float::with_val(53, -2.5);
too_small.clamp_mut(&min, &max);
assert_eq!(too_small, -1.5);
let mut in_range = Float::with_val(53, 0.5);
in_range.clamp_mut(&min, &max);
assert_eq!(in_range, 0.5);

Panics

Panics if the maximum value is less than the minimum value.

fn clamp_round<'a, Min, Max>(
    &mut self,
    min: &'a Min,
    max: &'a Max,
    round: Round
) -> Ordering where
    Float: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>, 

Clamps the value within the specified bounds, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let min = Float::with_val(53, -1.5);
let max = Float::with_val(53, 1.5);
let mut too_small = Float::with_val(53, -2.5);
let dir1 = too_small.clamp_round(&min, &max, Round::Nearest);
assert_eq!(too_small, -1.5);
assert_eq!(dir1, Ordering::Equal);
let mut in_range = Float::with_val(53, 0.5);
let dir2 = in_range.clamp_round(&min, &max, Round::Nearest);
assert_eq!(in_range, 0.5);
assert_eq!(dir2, Ordering::Equal);

Panics

Panics if the maximum value is less than the minimum value.

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

Clamps the value within the specified bounds.

The returned reference is self if the value is within the bounds, min if the value is less than the minimum, and max if the value is larger than the maximum.

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

Panics

Panics if the maximum value is less than the minimum value.

fn recip(self) -> Float

Computes the reciprocal, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, -0.25);
let recip = f.recip();
assert_eq!(recip, -4.0);

fn recip_mut(&mut self)

Computes the reciprocal, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, -0.25);
f.recip_mut();
assert_eq!(f, -4.0);

fn recip_round(&mut self, round: Round) -> Ordering

Computes the reciprocal, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 5 in binary is 101
let mut f = Float::with_val(4, -5.0);
// 1/5 in binary is 0.00110011...
// 1/5 is rounded to 0.203125 (0.001101).
let dir = f.recip_round(Round::Nearest);
assert_eq!(f, -0.203125);
assert_eq!(dir, Ordering::Less);

fn recip_ref(&self) -> RecipRef

Computes the reciprocal.

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

fn min(self, other: &Float) -> Float

Finds the minimum, rounding to the nearest.

Examples

use rug::Float;
let a = Float::with_val(53, 5.2);
let b = Float::with_val(53, -2);
let min = a.min(&b);
assert_eq!(min, -2);

fn min_mut(&mut self, other: &Float)

Finds the minimum, rounding to the nearest.

Examples

use rug::Float;
let mut a = Float::with_val(53, 5.2);
let b = Float::with_val(53, -2);
a.min_mut(&b);
assert_eq!(a, -2);

fn min_round(&mut self, other: &Float, round: Round) -> Ordering

Finds the minimum, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let mut a = Float::with_val(53, 5.2);
let b = Float::with_val(53, -2);
let dir = a.min_round(&b, Round::Nearest);
assert_eq!(a, -2);
assert_eq!(dir, Ordering::Equal);

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

Finds the minimum.

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

fn max(self, other: &Float) -> Float

Finds the maximum, rounding to the nearest.

Examples

use rug::Float;
let a = Float::with_val(53, 5.2);
let b = Float::with_val(53, 12.5);
let max = a.max(&b);
assert_eq!(max, 12.5);

fn max_mut(&mut self, other: &Float)

Finds the maximum, rounding to the nearest.

Examples

use rug::Float;
let mut a = Float::with_val(53, 5.2);
let b = Float::with_val(53, 12.5);
a.max_mut(&b);
assert_eq!(a, 12.5);

fn max_round(&mut self, other: &Float, round: Round) -> Ordering

Finds the maximum, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let mut a = Float::with_val(53, 5.2);
let b = Float::with_val(53, 12.5);
let dir = a.max_round(&b, Round::Nearest);
assert_eq!(a, 12.5);
assert_eq!(dir, Ordering::Equal);

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

Finds the maximum.

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

fn positive_diff(self, other: &Float) -> Float

Computes the positive difference between self and other, rounding to the nearest.

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

Examples

use rug::Float;
let a = Float::with_val(53, 12.5);
let b = Float::with_val(53, 7.3);
let diff1 = a.positive_diff(&b);
assert_eq!(diff1, 5.2);
let diff2 = diff1.positive_diff(&b);
assert_eq!(diff2, 0);

fn positive_diff_mut(&mut self, other: &Float)

Computes the positive difference between self and other, rounding to the nearest.

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

Examples

use rug::Float;
let mut a = Float::with_val(53, 12.5);
let b = Float::with_val(53, 7.3);
a.positive_diff_mut(&b);
assert_eq!(a, 5.2);
a.positive_diff_mut(&b);
assert_eq!(a, 0);

fn positive_diff_round(&mut self, other: &Float, round: Round) -> Ordering

Computes the positive difference between self and other, applying the specified rounding method.

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let mut a = Float::with_val(53, 12.5);
let b = Float::with_val(53, 7.3);
let dir = a.positive_diff_round(&b, Round::Nearest);
assert_eq!(a, 5.2);
assert_eq!(dir, Ordering::Equal);
let dir = a.positive_diff_round(&b, Round::Nearest);
assert_eq!(a, 0);
assert_eq!(dir, Ordering::Equal);

fn positive_diff_ref<'a>(&'a self, other: &'a Float) -> PositiveDiffRef<'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.

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

fn ln(self) -> Float

Computes the natural logarithm, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.5);
let ln = f.ln();
let expected = 0.4055_f64;
assert!((ln - expected).abs() < 0.0001);

fn ln_mut(&mut self)

Computes the natural logarithm, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.5);
f.ln_mut();
let expected = 0.4055_f64;
assert!((f - expected).abs() < 0.0001);

fn ln_round(&mut self, round: Round) -> Ordering

Computes the natural logarithm, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5);
// ln(1.5) = 0.4055
// using 4 significant bits: 0.40625
let dir = f.ln_round(Round::Nearest);
assert_eq!(f, 0.40625);
assert_eq!(dir, Ordering::Greater);

fn ln_ref(&self) -> LnRef

Computes the natural logarithm.

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

fn log2(self) -> Float

Computes the logarithm to base 2, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.5);
let log2 = f.log2();
let expected = 0.5850_f64;
assert!((log2 - expected).abs() < 0.0001);

fn log2_mut(&mut self)

Computes the logarithm to base 2, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.5);
f.log2_mut();
let expected = 0.5850_f64;
assert!((f - expected).abs() < 0.0001);

fn log2_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5);
// log2(1.5) = 0.5850
// using 4 significant bits: 0.5625
let dir = f.log2_round(Round::Nearest);
assert_eq!(f, 0.5625);
assert_eq!(dir, Ordering::Less);

fn log2_ref(&self) -> Log2Ref

Computes the logarithm to base 2.

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

fn log10(self) -> Float

Computes the logarithm to base 10, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.5);
let log10 = f.log10();
let expected = 0.1761_f64;
assert!((log10 - expected).abs() < 0.0001);

fn log10_mut(&mut self)

Computes the logarithm to base 10, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.5);
f.log10_mut();
let expected = 0.1761_f64;
assert!((f - expected).abs() < 0.0001);

fn log10_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5);
// log10(1.5) = 0.1761
// using 4 significant bits: 0.171875
let dir = f.log10_round(Round::Nearest);
assert_eq!(f, 0.171875);
assert_eq!(dir, Ordering::Less);

fn log10_ref(&self) -> Log10Ref

Computes the logarithm to base 10.

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

fn exp(self) -> Float

Computes the exponential, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.5);
let exp = f.exp();
let expected = 4.4817_f64;
assert!((exp - expected).abs() < 0.0001);

fn exp_mut(&mut self)

Computes the exponential, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.5);
f.exp_mut();
let expected = 4.4817_f64;
assert!((f - expected).abs() < 0.0001);

fn exp_round(&mut self, round: Round) -> Ordering

Computes the exponential, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5);
// exp(1.5) = 4.4817
// using 4 significant bits: 4.5
let dir = f.exp_round(Round::Nearest);
assert_eq!(f, 4.5);
assert_eq!(dir, Ordering::Greater);

fn exp_ref(&self) -> ExpRef

Computes the exponential.

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

fn exp2(self) -> Float

Computes 2 to the power of self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.5);
let exp2 = f.exp2();
let expected = 2.8284_f64;
assert!((exp2 - expected).abs() < 0.0001);

fn exp2_mut(&mut self)

Computes 2 to the power of self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.5);
f.exp2_mut();
let expected = 2.8284_f64;
assert!((f - expected).abs() < 0.0001);

fn exp2_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5);
// exp2(1.5) = 2.8284
// using 4 significant bits: 2.75
let dir = f.exp2_round(Round::Nearest);
assert_eq!(f, 2.75);
assert_eq!(dir, Ordering::Less);

fn exp2_ref(&self) -> Exp2Ref

Computes 2 to the power of the value.

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

fn exp10(self) -> Float

Computes 10 to the power of self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.5);
let exp10 = f.exp10();
let expected = 31.6228_f64;
assert!((exp10 - expected).abs() < 0.0001);

fn exp10_mut(&mut self)

Computes 10 to the power of self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.5);
f.exp10_mut();
let expected = 31.6228_f64;
assert!((f - expected).abs() < 0.0001);

fn exp10_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5);
// exp10(1.5) = 31.6228
// using 4 significant bits: 32
let dir = f.exp10_round(Round::Nearest);
assert_eq!(f, 32);
assert_eq!(dir, Ordering::Greater);

fn exp10_ref(&self) -> Exp10Ref

Computes 10 to the power of the value.

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

fn sin(self) -> Float

Computes the sine, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let sin = f.sin();
let expected = 0.9490_f64;
assert!((sin - expected).abs() < 0.0001);

fn sin_mut(&mut self)

Computes the sine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.sin_mut();
let expected = 0.9490_f64;
assert!((f - expected).abs() < 0.0001);

fn sin_round(&mut self, round: Round) -> Ordering

Computes the sine, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// sin(1.25) = 0.9490
// using 4 significant bits: 0.9375
let dir = f.sin_round(Round::Nearest);
assert_eq!(f, 0.9375);
assert_eq!(dir, Ordering::Less);

fn sin_ref(&self) -> SinRef

Computes the sine.

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

fn cos(self) -> Float

Computes the cosine, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let cos = f.cos();
let expected = 0.3153_f64;
assert!((cos - expected).abs() < 0.0001);

fn cos_mut(&mut self)

Computes the cosine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.cos_mut();
let expected = 0.3153_f64;
assert!((f - expected).abs() < 0.0001);

fn cos_round(&mut self, round: Round) -> Ordering

Computes the cosine, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// cos(1.25) = 0.3153
// using 4 significant bits: 0.3125
let dir = f.cos_round(Round::Nearest);
assert_eq!(f, 0.3125);
assert_eq!(dir, Ordering::Less);

fn cos_ref(&self) -> CosRef

Computes the cosine.

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

fn tan(self) -> Float

Computes the tangent, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let tan = f.tan();
let expected = 3.0096_f64;
assert!((tan - expected).abs() < 0.0001);

fn tan_mut(&mut self)

Computes the tangent, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.tan_mut();
let expected = 3.0096_f64;
assert!((f - expected).abs() < 0.0001);

fn tan_round(&mut self, round: Round) -> Ordering

Computes the tangent, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// tan(1.25) = 3.0096
// using 4 significant bits: 3.0
let dir = f.tan_round(Round::Nearest);
assert_eq!(f, 3.0);
assert_eq!(dir, Ordering::Less);

fn tan_ref(&self) -> TanRef

Computes the tangent.

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

fn sin_cos(self, cos: Float) -> (Float, Float)

Computes the sine and cosine of self, rounding to the nearest.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let (sin, cos) = f.sin_cos(Float::new(53));
let expected_sin = 0.9490_f64;
let expected_cos = 0.3153_f64;
assert!((sin - expected_sin).abs() < 0.0001);
assert!((cos - expected_cos).abs() < 0.0001);

fn sin_cos_mut(&mut self, cos: &mut Float)

Computes the sine and cosine of self, rounding to the nearest.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Float;
let mut sin = Float::with_val(53, 1.25);
let mut cos = Float::new(53);
sin.sin_cos_mut(&mut cos);
let expected_sin = 0.9490_f64;
let expected_cos = 0.3153_f64;
assert!((sin - expected_sin).abs() < 0.0001);
assert!((cos - expected_cos).abs() < 0.0001);

fn sin_cos_round(
    &mut self,
    cos: &mut Float,
    round: Round
) -> (Ordering, Ordering)

Computes the sine and cosine of self, applying the specified rounding method.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut sin = Float::with_val(4, 1.25);
let mut cos = Float::new(4);
// sin(1.25) = 0.9490, using 4 significant bits: 0.9375
// cos(1.25) = 0.3153, using 4 significant bits: 0.3125
let (dir_sin, dir_cos) =
    sin.sin_cos_round(&mut cos, Round::Nearest);
assert_eq!(sin, 0.9375);
assert_eq!(dir_sin, Ordering::Less);
assert_eq!(cos, 0.3125);
assert_eq!(dir_cos, Ordering::Less);

fn sin_cos_ref(&self) -> SinCosRef

Computes the sine and cosine.

Examples

use rug::{Assign, Float};
use rug::float::{AssignRound, Round};
use std::cmp::Ordering;
let phase = Float::with_val(53, 1.25);
let sin_cos = phase.sin_cos_ref();

let (mut sin, mut cos) = (Float::new(53), Float::new(53));
(&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 (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);

fn sec(self) -> Float

Computes the secant, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let sec = f.sec();
let expected = 3.1714_f64;
assert!((sec - expected).abs() < 0.0001);

fn sec_mut(&mut self)

Computes the secant, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.sec_mut();
let expected = 3.1714_f64;
assert!((f - expected).abs() < 0.0001);

fn sec_round(&mut self, round: Round) -> Ordering

Computes the secant, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// sec(1.25) = 3.1714
// using 4 significant bits: 3.25
let dir = f.sec_round(Round::Nearest);
assert_eq!(f, 3.25);
assert_eq!(dir, Ordering::Greater);

fn sec_ref(&self) -> SecRef

Computes the secant.

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

fn csc(self) -> Float

Computes the cosecant, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let csc = f.csc();
let expected = 1.0538_f64;
assert!((csc - expected).abs() < 0.0001);

fn csc_mut(&mut self)

Computes the cosecant, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.csc_mut();
let expected = 1.0538_f64;
assert!((f - expected).abs() < 0.0001);

fn csc_round(&mut self, round: Round) -> Ordering

Computes the cosecant, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// csc(1.25) = 1.0538
// using 4 significant bits: 1.0
let dir = f.csc_round(Round::Nearest);
assert_eq!(f, 1.0);
assert_eq!(dir, Ordering::Less);

fn csc_ref(&self) -> CscRef

Computes the cosecant.

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

fn cot(self) -> Float

Computes the cotangent, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let cot = f.cot();
let expected = 0.3323_f64;
assert!((cot - expected).abs() < 0.0001);

fn cot_mut(&mut self)

Computes the cotangent, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.cot_mut();
let expected = 0.3323_f64;
assert!((f - expected).abs() < 0.0001);

fn cot_round(&mut self, round: Round) -> Ordering

Computes the cotangent, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// cot(1.25) = 0.3323
// using 4 significant bits: 0.34375
let dir = f.cot_round(Round::Nearest);
assert_eq!(f, 0.34375);
assert_eq!(dir, Ordering::Greater);

fn cot_ref(&self) -> CotRef

Computes the cotangent.

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

fn asin(self) -> Float

Computes the arc-sine, rounding to the nearest.

Examples

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

fn asin_mut(&mut self)

Computes the arc-sine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.asin_mut();
let expected = -0.8481_f64;
assert!((f - expected).abs() < 0.0001);

fn asin_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, -0.75);
// asin(-0.75) = -0.8481
// using 4 significant bits: -0.875
let dir = f.asin_round(Round::Nearest);
assert_eq!(f, -0.875);
assert_eq!(dir, Ordering::Less);

fn asin_ref(&self) -> AsinRef

Computes the arc-sine.

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

fn acos(self) -> Float

Computes the arc-cosine, rounding to the nearest.

Examples

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

fn acos_mut(&mut self)

Computes the arc-cosine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.acos_mut();
let expected = 2.4189_f64;
assert!((f - expected).abs() < 0.0001);

fn acos_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, -0.75);
// acos(-0.75) = 2.4189
// using 4 significant bits: 2.5
let dir = f.acos_round(Round::Nearest);
assert_eq!(f, 2.5);
assert_eq!(dir, Ordering::Greater);

fn acos_ref(&self) -> AcosRef

Computes the arc-cosine.

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

fn atan(self) -> Float

Computes the arc-tangent, rounding to the nearest.

Examples

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

fn atan_mut(&mut self)

Computes the arc-tangent, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, -0.75);
f.atan_mut();
let expected = -0.6435_f64;
assert!((f - expected).abs() < 0.0001);

fn atan_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, -0.75);
// atan(-0.75) = -0.6435
// using 4 significant bits: -0.625
let dir = f.atan_round(Round::Nearest);
assert_eq!(f, -0.625);
assert_eq!(dir, Ordering::Greater);

fn atan_ref(&self) -> AtanRef

Computes the arc-tangent.

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

fn atan2(self, x: &Float) -> Float

Computes the arc-tangent2 of self and x, rounding to the nearest.

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

Examples

use rug::Float;
let y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
let atan2 = y.atan2(&x);
let expected = 2.4981_f64;
assert!((atan2 - expected).abs() < 0.0001);

fn atan2_mut(&mut self, x: &Float)

Computes the arc-tangent2 of self and x, rounding to the nearest.

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

Examples

use rug::Float;
let mut y = Float::with_val(53, 3.0);
let x = Float::with_val(53, -4.0);
y.atan2_mut(&x);
let expected = 2.4981_f64;
assert!((y - expected).abs() < 0.0001);

fn atan2_round(&mut self, x: &Float, round: Round) -> Ordering

Computes the arc-tangent2 of self and x, applying the specified rounding method.

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut y = Float::with_val(4, 3.0);
let x = Float::with_val(4, -4.0);
// atan2(3.0, -4.0) = 2.4981
// using 4 significant bits: 2.5
let dir = y.atan2_round(&x, Round::Nearest);
assert_eq!(y, 2.5);
assert_eq!(dir, Ordering::Greater);

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

Computes the arc-tangent.

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

Examples

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

fn sinh(self) -> Float

Computes the hyperbolic sine, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let sinh = f.sinh();
let expected = 1.6019_f64;
assert!((sinh - expected).abs() < 0.0001);

fn sinh_mut(&mut self)

Computes the hyperbolic sine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.sinh_mut();
let expected = 1.6019_f64;
assert!((f - expected).abs() < 0.0001);

fn sinh_round(&mut self, round: Round) -> Ordering

Computes the hyperbolic sine, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// sinh(1.25) = 1.6019
// using 4 significant bits: 1.625
let dir = f.sinh_round(Round::Nearest);
assert_eq!(f, 1.625);
assert_eq!(dir, Ordering::Greater);

fn sinh_ref(&self) -> SinhRef

Computes the hyperbolic sine.

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

fn cosh(self) -> Float

Computes the hyperbolic cosine, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let cosh = f.cosh();
let expected = 1.8884_f64;
assert!((cosh - expected).abs() < 0.0001);

fn cosh_mut(&mut self)

Computes the hyperbolic cosine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.cosh_mut();
let expected = 1.8884_f64;
assert!((f - expected).abs() < 0.0001);

fn cosh_round(&mut self, round: Round) -> Ordering

Computes the hyperbolic cosine, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// cosh(1.25) = 1.8884
// using 4 significant bits: 1.875
let dir = f.cosh_round(Round::Nearest);
assert_eq!(f, 1.875);
assert_eq!(dir, Ordering::Less);

fn cosh_ref(&self) -> CoshRef

Computes the hyperbolic cosine.

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

fn tanh(self) -> Float

Computes the hyperbolic tangent, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let tanh = f.tanh();
let expected = 0.8483_f64;
assert!((tanh - expected).abs() < 0.0001);

fn tanh_mut(&mut self)

Computes the hyperbolic tangent, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.tanh_mut();
let expected = 0.8483_f64;
assert!((f - expected).abs() < 0.0001);

fn tanh_round(&mut self, round: Round) -> Ordering

Computes the hyperbolic tangent, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// tanh(1.25) = 0.8483
// using 4 significant bits: 0.875
let dir = f.tanh_round(Round::Nearest);
assert_eq!(f, 0.875);
assert_eq!(dir, Ordering::Greater);

fn tanh_ref(&self) -> TanhRef

Computes the hyperbolic tangent.

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

fn sinh_cosh(self, cos: Float) -> (Float, Float)

Computes the hyperbolic sine and cosine of self, rounding to the nearest.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let (sinh, cosh) = f.sinh_cosh(Float::new(53));
let expected_sinh = 1.6019_f64;
let expected_cosh = 1.8884_f64;
assert!((sinh - expected_sinh).abs() < 0.0001);
assert!((cosh - expected_cosh).abs() < 0.0001);

fn sinh_cosh_mut(&mut self, cos: &mut Float)

Computes the hyperbolic sine and cosine of self, rounding to the nearest.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Float;
let mut sinh = Float::with_val(53, 1.25);
let mut cosh = Float::new(53);
sinh.sinh_cosh_mut(&mut cosh);
let expected_sinh = 1.6019_f64;
let expected_cosh = 1.8884_f64;
assert!((sinh - expected_sinh).abs() < 0.0001);
assert!((cosh - expected_cosh).abs() < 0.0001);

fn sinh_cosh_round(
    &mut self,
    cos: &mut Float,
    round: Round
) -> (Ordering, Ordering)

Computes the hyperbolic sine and cosine of self, applying the specified rounding method.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut sinh = Float::with_val(4, 1.25);
let mut cosh = Float::new(4);
// sinh(1.25) = 1.6019, using 4 significant bits: 1.625
// cosh(1.25) = 1.8884, using 4 significant bits: 1.875
let (dir_sinh, dir_cosh) =
    sinh.sinh_cosh_round(&mut cosh, Round::Nearest);
assert_eq!(sinh, 1.625);
assert_eq!(dir_sinh, Ordering::Greater);
assert_eq!(cosh, 1.875);
assert_eq!(dir_cosh, Ordering::Less);

fn sinh_cosh_ref(&self) -> SinhCoshRef

Computes the hyperbolic sine and cosine.

Examples

use rug::{Assign, Float};
use rug::float::{AssignRound, Round};
use std::cmp::Ordering;
let phase = Float::with_val(53, 1.25);
let sinh_cosh = phase.sinh_cosh_ref();

let (mut sinh, mut cosh) = (Float::new(53), Float::new(53));
(&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 (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);

fn sech(self) -> Float

Computes the hyperbolic secant, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let sech = f.sech();
let expected = 0.5295_f64;
assert!((sech - expected).abs() < 0.0001);

fn sech_mut(&mut self)

Computes the hyperbolic secant, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.sech_mut();
let expected = 0.5295_f64;
assert!((f - expected).abs() < 0.0001);

fn sech_round(&mut self, round: Round) -> Ordering

Computes the hyperbolic secant, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// sech(1.25) = 0.5295
// using 4 significant bits: 0.5
let dir = f.sech_round(Round::Nearest);
assert_eq!(f, 0.5);
assert_eq!(dir, Ordering::Less);

fn sech_ref(&self) -> SechRef

Computes the hyperbolic secant.

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

fn csch(self) -> Float

Computes the hyperbolic cosecant, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let csch = f.csch();
let expected = 0.6243_f64;
assert!((csch - expected).abs() < 0.0001);

fn csch_mut(&mut self)

Computes the hyperbolic cosecant, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.csch_mut();
let expected = 0.6243_f64;
assert!((f - expected).abs() < 0.0001);

fn csch_round(&mut self, round: Round) -> Ordering

Computes the hyperbolic cosecant, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// csch(1.25) = 0.6243
// using 4 significant bits: 0.625
let dir = f.csch_round(Round::Nearest);
assert_eq!(f, 0.625);
assert_eq!(dir, Ordering::Greater);

fn csch_ref(&self) -> CschRef

Computes the hyperbolic cosecant.

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

fn coth(self) -> Float

Computes the hyperbolic cotangent, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let coth = f.coth();
let expected = 1.1789_f64;
assert!((coth - expected).abs() < 0.0001);

fn coth_mut(&mut self)

Computes the hyperbolic cotangent, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.coth_mut();
let expected = 1.1789_f64;
assert!((f - expected).abs() < 0.0001);

fn coth_round(&mut self, round: Round) -> Ordering

Computes the hyperbolic cotangent, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// coth(1.25) = 1.1789
// using 4 significant bits: 1.125
let dir = f.coth_round(Round::Nearest);
assert_eq!(f, 1.125);
assert_eq!(dir, Ordering::Less);

fn coth_ref(&self) -> CothRef

Computes the hyperbolic cotangent.

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

fn asinh(self) -> Float

Computes the inverse hyperbolic sine, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let asinh = f.asinh();
let expected = 1.0476_f64;
assert!((asinh - expected).abs() < 0.0001);

fn asinh_mut(&mut self)

Computes the inverse hyperbolic sine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.asinh_mut();
let expected = 1.0476_f64;
assert!((f - expected).abs() < 0.0001);

fn asinh_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// asinh(1.25) = 1.0476
// using 4 significant bits: 1.0
let dir = f.asinh_round(Round::Nearest);
assert_eq!(f, 1.0);
assert_eq!(dir, Ordering::Less);

fn asinh_ref(&self) -> AsinhRef

Computes the inverse hyperbolic sine.

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

fn acosh(self) -> Float

Computes the inverse hyperbolic cosine, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let acosh = f.acosh();
let expected = 0.6931_f64;
assert!((acosh - expected).abs() < 0.0001);

fn acosh_mut(&mut self)

Computes the inverse hyperbolic cosine, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.acosh_mut();
let expected = 0.6931_f64;
assert!((f - expected).abs() < 0.0001);

fn acosh_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// acosh(1.25) = 0.6931
// using 4 significant bits: 0.6875
let dir = f.acosh_round(Round::Nearest);
assert_eq!(f, 0.6875);
assert_eq!(dir, Ordering::Less);

fn acosh_ref(&self) -> AcoshRef

Computes the inverse hyperbolic cosine

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

fn atanh(self) -> Float

Computes the inverse hyperbolic tangent, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 0.75);
let atanh = f.atanh();
let expected = 0.9730_f64;
assert!((atanh - expected).abs() < 0.0001);

fn atanh_mut(&mut self)

Computes the inverse hyperbolic tangent, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 0.75);
f.atanh_mut();
let expected = 0.9730_f64;
assert!((f - expected).abs() < 0.0001);

fn atanh_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 0.75);
// atanh(0.75) = 0.9730
// using 4 significant bits: 1.0
let dir = f.atanh_round(Round::Nearest);
assert_eq!(f, 1.0);
assert_eq!(dir, Ordering::Greater);

fn atanh_ref(&self) -> AtanhRef

Computes the inverse hyperbolic tangent.

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

fn assign_factorial_u(&mut self, u: u32)

Sets self to the factorial of u, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::new(53);
// 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
f.assign_factorial_u(10);
assert_eq!(f, 3628800.0);

fn assign_factorial_u_round(&mut self, u: u32, round: Round) -> Ordering

Sets self to the factorial of u, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 4 bits of precision
let mut f = Float::new(4);
// 10! is 3628800 (binary 110111...)
// rounded to 3670016 (binary 1110...)
let dir = f.assign_factorial_u_round(10, Round::Nearest);
assert_eq!(f, 3670016.0);
assert_eq!(dir, Ordering::Greater);

fn ln_1p(self) -> Float

Computes the natural logarithm of one plus self, rounding to the nearest.

Examples

use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let ln_1p = f.ln_1p();
let expected = 1.4989_f64 * two_to_m10;
assert!((ln_1p - expected).abs() < 0.0001 * two_to_m10);

fn ln_1p_mut(&mut self)

Computes the natural logarithm of one plus self, rounding to the nearest.

Examples

use rug::Float;
let two_to_m10 = (-10f64).exp2();
let mut f = Float::with_val(53, 1.5 * two_to_m10);
f.ln_1p_mut();
let expected = 1.4989_f64 * two_to_m10;
assert!((f - expected).abs() < 0.0001 * two_to_m10);

fn ln_1p_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let two_to_m10 = (-10f64).exp2();
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5 * two_to_m10);
// ln_1p(1.5 * 2 ^ -10) = 1.4989 * 2 ^ -10
// using 4 significant bits: 1.5 * 2 ^ -10
let dir = f.ln_1p_round(Round::Nearest);
assert_eq!(f, 1.5 * two_to_m10);
assert_eq!(dir, Ordering::Greater);

fn ln_1p_ref(&self) -> Ln1pRef

Computes the natural logorithm of one plus the value.

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

fn exp_m1(self) -> Float

Subtracts one from the exponential of self, rounding to the nearest.

Examples

use rug::Float;
let two_to_m10 = (-10f64).exp2();
let f = Float::with_val(53, 1.5 * two_to_m10);
let exp_m1 = f.exp_m1();
let expected = 1.5011_f64 * two_to_m10;
assert!((exp_m1 - expected).abs() < 0.0001 * two_to_m10);

fn exp_m1_mut(&mut self)

Subtracts one from the exponential of self, rounding to the nearest.

Examples

use rug::Float;
let two_to_m10 = (-10f64).exp2();
let mut f = Float::with_val(53, 1.5 * two_to_m10);
f.exp_m1_mut();
let expected = 1.5011_f64 * two_to_m10;
assert!((f - expected).abs() < 0.0001 * two_to_m10);

fn exp_m1_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
let two_to_m10 = (-10f64).exp2();
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.5 * two_to_m10);
// exp_m1(1.5 * 2 ^ -10) = 1.5011 * 2 ^ -10
// using 4 significant bits: 1.5 * 2 ^ -10
let dir = f.exp_m1_round(Round::Nearest);
assert_eq!(f, 1.5 * two_to_m10);
assert_eq!(dir, Ordering::Less);

fn exp_m1_ref(&self) -> ExpM1Ref

Computes one less than the exponential of the value.

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

fn eint(self) -> Float

Computes the exponential integral, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let eint = f.eint();
let expected = 2.5810_f64;
assert!((eint - expected).abs() < 0.0001);

fn eint_mut(&mut self)

Computes the exponential integral, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.eint_mut();
let expected = 2.5810_f64;
assert!((f - expected).abs() < 0.0001);

fn eint_round(&mut self, round: Round) -> Ordering

Computes the exponential integral, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// eint(1.25) = 2.5810
// using 4 significant bits: 2.5
let dir = f.eint_round(Round::Nearest);
assert_eq!(f, 2.5);
assert_eq!(dir, Ordering::Less);

fn eint_ref(&self) -> EintRef

Computes the exponential integral.

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

fn li2(self) -> Float

Computes the real part of the dilogarithm of self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let li2 = f.li2();
let expected = 2.1902_f64;
assert!((li2 - expected).abs() < 0.0001);

fn li2_mut(&mut self)

Computes the real part of the dilogarithm of self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.li2_mut();
let expected = 2.1902_f64;
assert!((f - expected).abs() < 0.0001);

fn li2_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// li2(1.25) = 2.1902
// using 4 significant bits: 2.25
let dir = f.li2_round(Round::Nearest);
assert_eq!(f, 2.25);
assert_eq!(dir, Ordering::Greater);

fn li2_ref(&self) -> Li2Ref

Computes the real part of the dilogarithm of the value.

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

fn gamma(self) -> Float

Computes the value of the Gamma function on self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let gamma = f.gamma();
let expected = 0.9064_f64;
assert!((gamma - expected).abs() < 0.0001);

fn gamma_mut(&mut self)

Computes the value of the Gamma function on self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.gamma_mut();
let expected = 0.9064_f64;
assert!((f - expected).abs() < 0.0001);

fn gamma_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// gamma(1.25) = 0.9064
// using 4 significant bits: 0.9375
let dir = f.gamma_round(Round::Nearest);
assert_eq!(f, 0.9375);
assert_eq!(dir, Ordering::Greater);

fn gamma_ref(&self) -> GammaRef

Computes the Gamma function on the value.

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

fn ln_gamma(self) -> Float

Computes the logarithm of the Gamma function on self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let ln_gamma = f.ln_gamma();
let expected = -0.0983_f64;
assert!((ln_gamma - expected).abs() < 0.0001);

fn ln_gamma_mut(&mut self)

Computes the logarithm of the Gamma function on self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.ln_gamma_mut();
let expected = -0.0983_f64;
assert!((f - expected).abs() < 0.0001);

fn ln_gamma_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// ln_gamma(1.25) = -0.0983
// using 4 significant bits: -0.1015625
let dir = f.ln_gamma_round(Round::Nearest);
assert_eq!(f, -0.1015625);
assert_eq!(dir, Ordering::Less);

fn ln_gamma_ref(&self) -> LnGammaRef

Computes the logarithm of the Gamma function on the value.

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

fn ln_abs_gamma(self) -> (Float, Ordering)

Computes the logarithm of the absolute value of the Gamma function on self, rounding to the nearest.

Returns Ordering::Less if the Gamma function is negative, or Ordering::Greater if the Gamma function is positive.

Examples

use rug::Float;
use rug::float::Constant;
use std::cmp::Ordering;

// gamma of 1/2 is sqrt(pi)
let ln_gamma_64 = Float::with_val(64, Constant::Pi).sqrt().ln();

let f = Float::with_val(53, 0.5);
let (ln_gamma, sign) = f.ln_abs_gamma();
// gamma of 1/2 is positive
assert_eq!(sign, Ordering::Greater);
// check to 53 significant bits
assert_eq!(ln_gamma, Float::with_val(53, &ln_gamma_64));

If the Gamma function is negative, the sign returned is Ordering::Less.

use rug::Float;
use rug::float::Constant;
use std::cmp::Ordering;

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

let f = Float::with_val(53, -0.5);
let (ln_gamma, sign) = f.ln_abs_gamma();
// gamma of -1/2 is negative
assert_eq!(sign, Ordering::Less);
// check to 53 significant bits
assert_eq!(ln_gamma, Float::with_val(53, &ln_gamma_64));

fn ln_abs_gamma_mut(&mut self) -> Ordering

Computes the logarithm of the absolute value of the Gamma function on self, rounding to the nearest.

Returns Ordering::Less if the Gamma function is negative, or Ordering::Greater if the Gamma function is positive.

Examples

use rug::Float;
use rug::float::Constant;
use std::cmp::Ordering;

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

let mut f = Float::with_val(53, -0.5);
let sign = f.ln_abs_gamma_mut();
// gamma of -1/2 is negative
assert_eq!(sign, Ordering::Less);
// check to 53 significant bits
assert_eq!(f, Float::with_val(53, &ln_gamma_64));

fn ln_abs_gamma_round(&mut self, round: Round) -> (Ordering, Ordering)

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

The returned tuple contains:

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

Examples

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

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

let mut f = Float::with_val(53, -0.5);
let (sign, dir) = f.ln_abs_gamma_round(Round::Nearest);
// gamma of -1/2 is negative
assert_eq!(sign, Ordering::Less);
// check is correct to 53 significant bits
let (check, check_dir) =
    Float::with_val_round(53, &ln_gamma_64, Round::Nearest);
assert_eq!(f, check);
assert_eq!(dir, check_dir);

fn ln_abs_gamma_ref(&self) -> LnAbsGammaRef

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

Examples

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

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

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

fn digamma(self) -> Float

Computes the value of the Digamma function on self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let digamma = f.digamma();
let expected = -0.2275_f64;
assert!((digamma - expected).abs() < 0.0001);

fn digamma_mut(&mut self)

Computes the value of the Digamma function on self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.digamma_mut();
let expected = -0.2275_f64;
assert!((f - expected).abs() < 0.0001);

fn digamma_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// digamma(1.25) = -0.2275
// using 4 significant bits: -0.234375
let dir = f.digamma_round(Round::Nearest);
assert_eq!(f, -0.234375);
assert_eq!(dir, Ordering::Less);

fn digamma_ref(&self) -> DigammaRef

Computes the Digamma function on the value.

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

fn zeta(self) -> Float

Computes the value of the Riemann Zeta function on self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let zeta = f.zeta();
let expected = 4.5951_f64;
assert!((zeta - expected).abs() < 0.0001);

fn zeta_mut(&mut self)

Computes the value of the Riemann Zeta function on self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.zeta_mut();
let expected = 4.5951_f64;
assert!((f - expected).abs() < 0.0001);

fn zeta_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// zeta(1.25) = 4.5951
// using 4 significant bits: 4.5
let dir = f.zeta_round(Round::Nearest);
assert_eq!(f, 4.5);
assert_eq!(dir, Ordering::Less);

fn zeta_ref(&self) -> ZetaRef

Computes the Riemann Zeta function on the value.

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

fn assign_zeta_u(&mut self, u: u32)

Sets self to the value of the Riemann Zeta function on u, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::new(53);
f.assign_zeta_u(3);
let expected = 1.2021_f64;
assert!((f - expected).abs() < 0.0001);

fn assign_zeta_u_round(&mut self, u: u32, round: Round) -> Ordering

Sets self to the value of the Riemann Zeta function on u, applying the specified rounding method.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 4 bits of precision
let mut f = Float::new(4);
// zeta(3) is 1.2021, using 4 significant bits: 1.25
let dir = f.assign_zeta_u_round(3, Round::Nearest);
assert_eq!(f, 1.25);
assert_eq!(dir, Ordering::Greater);

fn erf(self) -> Float

Computes the value of the error function, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let erf = f.erf();
let expected = 0.9229_f64;
assert!((erf - expected).abs() < 0.0001);

fn erf_mut(&mut self)

Computes the value of the error function, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.erf_mut();
let expected = 0.9229_f64;
assert!((f - expected).abs() < 0.0001);

fn erf_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// erf(1.25) = 0.9229
// using 4 significant bits: 0.9375
let dir = f.erf_round(Round::Nearest);
assert_eq!(f, 0.9375);
assert_eq!(dir, Ordering::Greater);

fn erf_ref(&self) -> ErfRef

Computes the error function.

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

fn erfc(self) -> Float

Computes the value of the complementary error function, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let erfc = f.erfc();
let expected = 0.0771_f64;
assert!((erfc - expected).abs() < 0.0001);

fn erfc_mut(&mut self)

Computes the value of the complementary error function, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.erfc_mut();
let expected = 0.0771_f64;
assert!((f - expected).abs() < 0.0001);

fn erfc_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// erfc(1.25) = 0.0771
// using 4 significant bits: 0.078125
let dir = f.erfc_round(Round::Nearest);
assert_eq!(f, 0.078125);
assert_eq!(dir, Ordering::Greater);

fn erfc_ref(&self) -> ErfcRef

Computes the complementary error function.

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

fn j0(self) -> Float

Computes the value of the first kind Bessel function of order 0, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let j0 = f.j0();
let expected = 0.6459_f64;
assert!((j0 - expected).abs() < 0.0001);

fn j0_mut(&mut self)

Computes the value of the first kind Bessel function of order 0, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.j0_mut();
let expected = 0.6459_f64;
assert!((f - expected).abs() < 0.0001);

fn j0_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// j0(1.25) = 0.6459
// using 4 significant bits: 0.625
let dir = f.j0_round(Round::Nearest);
assert_eq!(f, 0.625);
assert_eq!(dir, Ordering::Less);

fn j0_ref(&self) -> J0Ref

Computes the first kind Bessel function of order 0.

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

fn j1(self) -> Float

Computes the value of the first kind Bessel function of order 1, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let j1 = f.j1();
let expected = 0.5106_f64;
assert!((j1 - expected).abs() < 0.0001);

fn j1_mut(&mut self)

Computes the value of the first kind Bessel function of order 1, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.j1_mut();
let expected = 0.5106_f64;
assert!((f - expected).abs() < 0.0001);

fn j1_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// j1(1.25) = 0.5106
// using 4 significant bits: 0.5
let dir = f.j1_round(Round::Nearest);
assert_eq!(f, 0.5);
assert_eq!(dir, Ordering::Less);

fn j1_ref(&self) -> J1Ref

Computes the first kind Bessel function of order 1.

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

fn jn(self, n: i32) -> Float

Computes the value of the first kind Bessel function of order n, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let j2 = f.jn(2);
let expected = 0.1711_f64;
assert!((j2 - expected).abs() < 0.0001);

fn jn_mut(&mut self, n: i32)

Computes the value of the first kind Bessel function of order n, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.jn_mut(2);
let expected = 0.1711_f64;
assert!((f - expected).abs() < 0.0001);

fn jn_round(&mut self, n: i32, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// j2(1.25) = 0.1711
// using 4 significant bits: 0.171875
let dir = f.jn_round(2, Round::Nearest);
assert_eq!(f, 0.171875);
assert_eq!(dir, Ordering::Greater);

fn jn_ref(&self, n: i32) -> JnRef

Computes the first kind Bessel function of order n.

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

fn y0(self) -> Float

Computes the value of the second kind Bessel function of order 0, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let y0 = f.y0();
let expected = 0.2582_f64;
assert!((y0 - expected).abs() < 0.0001);

fn y0_mut(&mut self)

Computes the value of the second kind Bessel function of order 0, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.y0_mut();
let expected = 0.2582_f64;
assert!((f - expected).abs() < 0.0001);

fn y0_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// y0(1.25) = 0.2582
// using 4 significant bits: 0.25
let dir = f.y0_round(Round::Nearest);
assert_eq!(f, 0.25);
assert_eq!(dir, Ordering::Less);

fn y0_ref(&self) -> Y0Ref

Computes the second kind Bessel function of order 0.

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

fn y1(self) -> Float

Computes the value of the second kind Bessel function of order 1, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let y1 = f.y1();
let expected = -0.5844_f64;
assert!((y1 - expected).abs() < 0.0001);

fn y1_mut(&mut self)

Computes the value of the second kind Bessel function of order 1, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.y1_mut();
let expected = -0.5844_f64;
assert!((f - expected).abs() < 0.0001);

fn y1_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// y1(1.25) = -0.5844
// using 4 significant bits: -0.5625
let dir = f.y1_round(Round::Nearest);
assert_eq!(f, -0.5625);
assert_eq!(dir, Ordering::Greater);

fn y1_ref(&self) -> Y1Ref

Computes the second kind Bessel function of order 1.

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

fn yn(self, n: i32) -> Float

Computes the value of the second kind Bessel function of order n, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let y2 = f.yn(2);
let expected = -1.1932_f64;
assert!((y2 - expected).abs() < 0.0001);

fn yn_mut(&mut self, n: i32)

Computes the value of the second kind Bessel function of order n, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.yn_mut(2);
let expected = -1.1932_f64;
assert!((f - expected).abs() < 0.0001);

fn yn_round(&mut self, n: i32, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// y2(1.25) = -1.1932
// using 4 significant bits: -1.25
let dir = f.yn_round(2, Round::Nearest);
assert_eq!(f, -1.25);
assert_eq!(dir, Ordering::Less);

fn yn_ref(&self, n: i32) -> YnRef

Computes the second kind Bessel function of order n.

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

fn agm(self, other: &Float) -> Float

Computes the arithmetic-geometric mean of self and other, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let g = Float::with_val(53, 3.75);
let agm = f.agm(&g);
let expected = 2.3295_f64;
assert!((agm - expected).abs() < 0.0001);

fn agm_mut(&mut self, other: &Float)

Computes the arithmetic-geometric mean of self and other, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
let g = Float::with_val(53, 3.75);
f.agm_mut(&g);
let expected = 2.3295_f64;
assert!((f - expected).abs() < 0.0001);

fn agm_round(&mut self, other: &Float, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
let g = Float::with_val(4, 3.75);
// agm(1.25, 3.75) = 2.3295
// using 4 significant bits: 2.25
let dir = f.agm_round(&g, Round::Nearest);
assert_eq!(f, 2.25);
assert_eq!(dir, Ordering::Less);

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

Computes the arithmetic-geometric mean.

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

fn hypot(self, other: &Float) -> Float

Computes the Euclidean norm of self and other, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let g = Float::with_val(53, 3.75);
let hypot = f.hypot(&g);
let expected = 3.9528_f64;
assert!((hypot - expected).abs() < 0.0001);

fn hypot_mut(&mut self, other: &Float)

Computes the Euclidean norm of self and other, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
let g = Float::with_val(53, 3.75);
f.hypot_mut(&g);
let expected = 3.9528_f64;
assert!((f - expected).abs() < 0.0001);

fn hypot_round(&mut self, other: &Float, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
let g = Float::with_val(4, 3.75);
// hypot(1.25) = 3.9528
// using 4 significant bits: 4.0
let dir = f.hypot_round(&g, Round::Nearest);
assert_eq!(f, 4.0);
assert_eq!(dir, Ordering::Greater);

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

Computes the Euclidean norm.

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

fn ai(self) -> Float

Computes the value of the Airy function Ai on self, rounding to the nearest.

Examples

use rug::Float;
let f = Float::with_val(53, 1.25);
let ai = f.ai();
let expected = 0.0996_f64;
assert!((ai - expected).abs() < 0.0001);

fn ai_mut(&mut self)

Computes the value of the Airy function Ai on self, rounding to the nearest.

Examples

use rug::Float;
let mut f = Float::with_val(53, 1.25);
f.ai_mut();
let expected = 0.0996_f64;
assert!((f - expected).abs() < 0.0001);

fn ai_round(&mut self, round: Round) -> Ordering

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

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut f = Float::with_val(4, 1.25);
// ai(1.25) = 0.0996
// using 4 significant bits: 0.1015625
let dir = f.ai_round(Round::Nearest);
assert_eq!(f, 0.1015625);
assert_eq!(dir, Ordering::Greater);

fn ai_ref(&self) -> AiRef

Computes the Airy function Ai on the value.

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

fn ceil(self) -> Float

Rounds up to the next higher integer.

Examples

use rug::Float;
let f1 = Float::with_val(53, -23.75);
let ceil1 = f1.ceil();
assert_eq!(ceil1, -23);
let f2 = Float::with_val(53, 23.75);
let ceil2 = f2.ceil();
assert_eq!(ceil2, 24);

fn ceil_mut(&mut self)

Rounds up to the next higher integer.

Examples

use rug::Float;
let mut f1 = Float::with_val(53, -23.75);
f1.ceil_mut();
assert_eq!(f1, -23);
let mut f2 = Float::with_val(53, 23.75);
f2.ceil_mut();
assert_eq!(f2, 24);

fn ceil_ref(&self) -> CeilRef

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

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

fn floor(self) -> Float

Rounds down to the next lower integer.

Examples

use rug::Float;
let f1 = Float::with_val(53, -23.75);
let floor1 = f1.floor();
assert_eq!(floor1, -24);
let f2 = Float::with_val(53, 23.75);
let floor2 = f2.floor();
assert_eq!(floor2, 23);

fn floor_mut(&mut self)

Rounds down to the next lower integer.

Examples

use rug::Float;
let mut f1 = Float::with_val(53, -23.75);
f1.floor_mut();
assert_eq!(f1, -24);
let mut f2 = Float::with_val(53, 23.75);
f2.floor_mut();
assert_eq!(f2, 23);

fn floor_ref(&self) -> FloorRef

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

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

fn round(self) -> Float

Rounds to the nearest integer, rounding half-way cases away from zero.

Examples

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

fn round_mut(&mut self)

Rounds to the nearest integer, rounding half-way cases away from zero.

Examples

use rug::Float;
let mut f1 = Float::with_val(53, -23.75);
f1.round_mut();
assert_eq!(f1, -24);
let mut f2 = Float::with_val(53, 23.75);
f2.round_mut();
assert_eq!(f2, 24);

fn round_ref(&self) -> RoundRef

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

Examples

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

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

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

fn trunc(self) -> Float

Rounds to the next integer towards zero.

Examples

use rug::Float;
let f1 = Float::with_val(53, -23.75);
let trunc1 = f1.trunc();
assert_eq!(trunc1, -23);
let f2 = Float::with_val(53, 23.75);
let trunc2 = f2.trunc();
assert_eq!(trunc2, 23);

fn trunc_mut(&mut self)

Rounds to the next integer towards zero.

Examples

use rug::Float;
let mut f1 = Float::with_val(53, -23.75);
f1.trunc_mut();
assert_eq!(f1, -23);
let mut f2 = Float::with_val(53, 23.75);
f2.trunc_mut();
assert_eq!(f2, 23);

fn trunc_ref(&self) -> TruncRef

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

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

fn fract(self) -> Float

Gets the fractional part of the number.

Examples

use rug::Float;
let f1 = Float::with_val(53, -23.75);
let fract1 = f1.fract();
assert_eq!(fract1, -0.75);
let f2 = Float::with_val(53, 23.75);
let fract2 = f2.fract();
assert_eq!(fract2, 0.75);

fn fract_mut(&mut self)

Gets the fractional part of the number.

Examples

use rug::Float;
let mut f1 = Float::with_val(53, -23.75);
f1.fract_mut();
assert_eq!(f1, -0.75);
let mut f2 = Float::with_val(53, 23.75);
f2.fract_mut();
assert_eq!(f2, 0.75);

fn fract_ref(&self) -> FractRef

Gets the fractional part of the number.

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

fn trunc_fract(self, fract: Float) -> (Float, Float)

Gets the integer and fractional parts of the number, rounding to the nearest.

The integer part is stored in self and keeps its precision, while the fractional part is stored in fract keeping its precision.

Examples

use rug::Float;
let f1 = Float::with_val(53, -23.75);
let (trunc1, fract1) = f1.trunc_fract(Float::new(53));
assert_eq!(trunc1, -23);
assert_eq!(fract1, -0.75);
let f2 = Float::with_val(53, 23.75);
let (trunc2, fract2) = f2.trunc_fract(Float::new(53));
assert_eq!(trunc2, 23);
assert_eq!(fract2, 0.75);

fn trunc_fract_mut(&mut self, fract: &mut Float)

Gets the integer and fractional parts of the number, rounding to the nearest.

The integer part is stored in self and keeps its precision, while the fractional part is stored in fract keeping its precision.

Examples

use rug::Float;
let mut f1 = Float::with_val(53, -23.75);
let mut fract1 = Float::new(53);
f1.trunc_fract_mut(&mut fract1);
assert_eq!(f1, -23);
assert_eq!(fract1, -0.75);
let mut f2 = Float::with_val(53, 23.75);
let mut fract2 = Float::new(53);
f2.trunc_fract_mut(&mut fract2);
assert_eq!(f2, 23);
assert_eq!(fract2, 0.75);

fn trunc_fract_round(
    &mut self,
    fract: &mut Float,
    round: Round
) -> (Ordering, Ordering)

Gets the integer and fractional parts of the number, applying the specified rounding method.

The first element of the returned tuple of rounding directions is always Ordering::Equal, as truncating a value in place will always be exact.

The integer part is stored in self and keeps its precision, while the fractional part is stored in fract keeping its precision.

Examples

use rug::Float;
use rug::float::Round;
use std::cmp::Ordering;
// 0.515625 in binary is 0.100001
let mut f1 = Float::with_val(53, -23.515625);
let mut fract1 = Float::new(4);
let dir1 = f1.trunc_fract_round(&mut fract1, Round::Nearest);
assert_eq!(f1, -23);
assert_eq!(fract1, -0.5);
assert_eq!(dir1, (Ordering::Equal, Ordering::Greater));
let mut f2 = Float::with_val(53, 23.515625);
let mut fract2 = Float::new(4);
let dir2 = f2.trunc_fract_round(&mut fract2, Round::Nearest);
assert_eq!(f2, 23);
assert_eq!(fract2, 0.5);
assert_eq!(dir2, (Ordering::Equal, Ordering::Less));

fn trunc_fract_ref(&self) -> TruncFractRef

Gets the integer and fractional parts of the number.

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

fn assign_random_bits(&mut self, rng: &mut RandState) -> Result<(), ()>

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

This is equivalent to generating a random integer in the range 0 ≤ x < 2^p, where 2^p is two raised to the power of the precision, and then dividing the integer by 2^p. The smallest non-zero result will thus be 2^−p, and will only have one bit set. In the smaller possible results, many bits will be zero, and not all the precision will be used.

Examples

use rug::Float;
use rug::rand::RandState;
let mut rand = RandState::new();
let mut f = Float::new(2);
f.assign_random_bits(&mut rand).unwrap();
assert!(f == 0.0 || f == 0.25 || f == 0.5 || f == 0.75);
println!("0.0 ≤ {} < 1.0", f);

Errors

In all the normal cases, the result will be exact. However, if the precision is very large, and the generated random number is very small, this may require an exponent smaller than float::exp_min(); in this case, the number is set to Nan and an error is returned. This would most likely be a programming error.

fn assign_random_cont(&mut self, rng: &mut RandState)

Generates a random number in the continuous range 0 ≤ x < 1, and rounds to the nearest.

The result can be rounded up to be equal to one. This is equivalent to calling assign_random_cont_round(rng, Round::Nearest) (see assign_random_cont_round).

Examples

use rug::Float;
use rug::rand::RandState;
let mut rand = RandState::new();
let mut f = Float::new(2);
f.assign_random_cont(&mut rand);
// The significand is either 0b10 or 0b11
assert!(
    f == 1.0 || f == 0.75 || f == 0.5 || f == 0.375 || f == 0.25
        || f <= 0.1875
);

fn assign_random_cont_round(
    &mut self,
    rng: &mut RandState,
    round: Round
) -> Ordering

Generates a random number in the continous range 0 ≤ x < 1, and applies the specified rounding method.

The result can be rounded up to be equal to one. Unlike the assign_random_bits method which generates a discrete random number at intervals depending on the precision, this method is equivalent to generating a continuous random number with infinite precision and then rounding the result. This means that even the smaller numbers will be using all the available precision bits, and rounding is performed in all cases, not in some corner case.

Examples

use rug::Float;
use rug::float::Round;
use rug::rand::RandState;
use std::cmp::Ordering;
let mut rand = RandState::new();
let mut f = Float::new(2);
let dir = f.assign_random_cont_round(&mut rand, Round::Down);
// We cannot have an exact value without rounding.
assert_eq!(dir, Ordering::Less);
// The significand is either 0b10 or 0b11
assert!(
    f == 0.75 || f == 0.5 || f == 0.375 || f == 0.25 || f <= 0.1875
);

fn assign_random_gaussian(
    &mut self,
    other: Option<&mut Float>,
    rng: &mut RandState
)

Generates two random numbers according to a standard normal Gaussian distribution, rounding to the nearest.

If other is None, only one value is generated.

Examples

use rug::Float;
use rug::rand::RandState;
let mut rand = RandState::new();
let (mut f1, mut f2) = (Float::new(53), Float::new(53));
f1.assign_random_gaussian(Some(&mut f2), &mut rand);
println!("Two Gaussian random numbers: {}, {}", f1, f2);

fn assign_random_gaussian_round(
    &mut self,
    other: Option<&mut Float>,
    rng: &mut RandState,
    round: Round
) -> (Ordering, Ordering)

Generates two random numbers according to a standard normal Gaussian distribution, applying the specified rounding method.

If other is None, only one value is generated.

Rounding directions for generated random numbers cannot be Ordering::Equal, as the random numbers generated can be considered to have infinite precision before rounding.

Examples

use rug::Float;
use rug::float::Round;
use rug::rand::RandState;
use std::cmp::Ordering;
let mut rand = RandState::new();
let (mut f1, mut f2) = (Float::new(53), Float::new(53));
let dirs = f1.assign_random_gaussian_round(
    Some(&mut f2),
    &mut rand,
    Round::Nearest,
);
// Rounding directions cannot be `Ordering::Equal`:
assert_ne!(dirs.0, Ordering::Equal);
assert_ne!(dirs.1, Ordering::Equal);
println!("Two Gaussian random numbers: {}, {}", f1, f2);

Trait Implementations

impl<'a> AssignRound<SquareRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SquareRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SqrtRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SqrtRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<RecipSqrtRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: RecipSqrtRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CbrtRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CbrtRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<RootRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: RootRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AbsRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AbsRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a, Min, Max> AssignRound<ClampRef<'a, Min, Max>> for Float where
    Float: PartialOrd<Min> + PartialOrd<Max> + AssignRound<&'a Min, Round = Round, Ordering = Ordering> + AssignRound<&'a Max, Round = Round, Ordering = Ordering>,
    Min: 'a,
    Max: 'a, 

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(
    &mut self,
    src: ClampRef<'a, Min, Max>,
    round: Round
) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<RecipRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: RecipRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<MinRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MinRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<MaxRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MaxRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<PositiveDiffRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PositiveDiffRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<LnRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: LnRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Log2Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Log2Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Log10Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Log10Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ExpRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ExpRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Exp2Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Exp2Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Exp10Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Exp10Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SinRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SinRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CosRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CosRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<TanRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: TanRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SecRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SecRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CscRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CscRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CotRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CotRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AcosRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AcosRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AsinRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AsinRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AtanRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AtanRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Atan2Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Atan2Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CoshRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CoshRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SinhRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SinhRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<TanhRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: TanhRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SechRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SechRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CschRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CschRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CothRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CothRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AcoshRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AcoshRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AsinhRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AsinhRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AtanhRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AtanhRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Ln1pRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Ln1pRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ExpM1Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ExpM1Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<EintRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: EintRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Li2Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Li2Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<GammaRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: GammaRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<LnGammaRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: LnGammaRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<DigammaRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DigammaRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ZetaRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ZetaRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ErfRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ErfRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ErfcRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ErfcRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<J0Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: J0Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<J1Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: J1Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<JnRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: JnRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Y0Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Y0Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<Y1Ref<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Y1Ref<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<YnRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: YnRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AgmRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AgmRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<HypotRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: HypotRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<AiRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AiRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<CeilRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: CeilRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<FloorRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: FloorRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<RoundRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: RoundRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<TruncRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: TruncRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<FractRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: FractRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ValidFloat<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: ValidFloat, round: Round) -> Ordering

Peforms the assignment.

impl Neg for Float

type Output = Float

The resulting type after applying the - operator.

fn neg(self) -> Float

Performs the unary - operation.

impl NegAssign for Float

fn neg_assign(&mut self)

Peforms the negation.

impl<'a> Neg for &'a Float

type Output = NegRef<'a>

The resulting type after applying the - operator.

fn neg(self) -> NegRef<'a>

Performs the unary - operation.

impl<'a> AssignRound<NegRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: NegRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl Add<Float> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Float> for Float

fn add_assign(&mut self, rhs: Float)

Performs the += operation.

impl<'a> AddAssign<&'a Float> for Float

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

Performs the += operation.

impl AddAssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl<'a> AddAssignRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &'a Float, round: Round) -> Ordering

Performs the addition.

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

type Output = AddRef<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Float) -> AddRef<'a>

Performs the + operation.

impl<'a> AssignRound<AddRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRef, round: Round) -> Ordering

Peforms the assignment.

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

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddFrom<Float> for Float

fn add_from(&mut self, lhs: Float)

Peforms the addition.

impl<'a> AddFrom<&'a Float> for Float

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

Peforms the addition.

impl<'a> AddFromRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl<'a> AddFromRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &'a Float, round: Round) -> Ordering

Performs the addition.

impl Sub<Float> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&'a Float> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> Float

Performs the - operation.

impl SubAssign<Float> for Float

fn sub_assign(&mut self, rhs: Float)

Performs the -= operation.

impl<'a> SubAssign<&'a Float> for Float

fn sub_assign(&mut self, rhs: &'a Float)

Performs the -= operation.

impl SubAssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: Float, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubAssignRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &'a Float, round: Round) -> Ordering

Performs the subtraction.

impl<'a> Sub<&'a Float> for &'a Float

type Output = SubRef<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubRef<'a>

Performs the - operation.

impl<'a> AssignRound<SubRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRef, round: Round) -> Ordering

Peforms the assignment.

impl<'a> Sub<Float> for &'a Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubFrom<Float> for Float

fn sub_from(&mut self, lhs: Float)

Peforms the subtraction.

impl<'a> SubFrom<&'a Float> for Float

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

Peforms the subtraction.

impl<'a> SubFromRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: Float, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubFromRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &'a Float, round: Round) -> Ordering

Performs the subtraction.

impl Mul<Float> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Float> for Float

fn mul_assign(&mut self, rhs: Float)

Performs the *= operation.

impl<'a> MulAssign<&'a Float> for Float

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

Performs the *= operation.

impl MulAssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

impl<'a> MulAssignRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &'a Float, round: Round) -> Ordering

Performs the multiplication.

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

type Output = MulRef<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRef<'a>

Performs the * operation.

impl<'a> AssignRound<MulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRef, round: Round) -> Ordering

Peforms the assignment.

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

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulFrom<Float> for Float

fn mul_from(&mut self, lhs: Float)

Peforms the multiplication.

impl<'a> MulFrom<&'a Float> for Float

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

Peforms the multiplication.

impl<'a> MulFromRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: Float, round: Round) -> Ordering

Performs the multiplication.

impl<'a> MulFromRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &'a Float, round: Round) -> Ordering

Performs the multiplication.

impl Div<Float> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<Float> for Float

fn div_assign(&mut self, rhs: Float)

Performs the /= operation.

impl<'a> DivAssign<&'a Float> for Float

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

Performs the /= operation.

impl DivAssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivAssignRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &'a Float, round: Round) -> Ordering

Performs the division.

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

type Output = DivRef<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> AssignRound<DivRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRef, round: Round) -> Ordering

Peforms the assignment.

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

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivFrom<Float> for Float

fn div_from(&mut self, lhs: Float)

Peforms the division.

impl<'a> DivFrom<&'a Float> for Float

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

Peforms the division.

impl<'a> DivFromRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivFromRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &'a Float, round: Round) -> Ordering

Performs the division.

impl Pow<Float> for Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

impl<'a> Pow<&'a Float> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &'a Float) -> Float

Performs the power operation.

impl PowAssign<Float> for Float

fn pow_assign(&mut self, rhs: Float)

Peforms the power operation.

impl<'a> PowAssign<&'a Float> for Float

fn pow_assign(&mut self, rhs: &'a Float)

Peforms the power operation.

impl PowAssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: Float, round: Round) -> Ordering

Performs the power operation.

impl<'a> PowAssignRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &'a Float, round: Round) -> Ordering

Performs the power operation.

impl<'a> Pow<&'a Float> for &'a Float

type Output = PowRef<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Float) -> PowRef<'a>

Performs the power operation.

impl<'a> AssignRound<PowRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRef, round: Round) -> Ordering

Peforms the assignment.

impl<'a> Pow<Float> for &'a Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

impl PowFrom<Float> for Float

fn pow_from(&mut self, lhs: Float)

Peforms the power operation.

impl<'a> PowFrom<&'a Float> for Float

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

Peforms the power operation.

impl<'a> PowFromRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: Float, round: Round) -> Ordering

Performs the power operation.

impl<'a> PowFromRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: &'a Float, round: Round) -> Ordering

Performs the power operation.

impl Add<Integer> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Integer> for Float

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &'a Integer, round: Round) -> Ordering

Performs the addition.

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

type Output = AddRefInteger<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddRefInteger<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefInteger, round: Round) -> Ordering

Peforms the assignment.

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

type Output = AddRefIntegerOwn<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> AddRefIntegerOwn<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl AddFrom<Integer> for Float

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

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

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

Peforms the addition.

impl AddFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &'a Integer, round: Round) -> Ordering

Performs the addition.

impl Sub<Integer> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> Float

Performs the - operation.

impl SubAssign<Integer> for Float

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

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

fn sub_assign(&mut self, rhs: &'a Integer)

Performs the -= operation.

impl SubAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the subtraction.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &'a Integer, round: Round) -> Ordering

Performs the subtraction.

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

type Output = SubRefInteger<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubRefInteger<'a>

Performs the - operation.

impl<'a> AssignRound<SubRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefInteger, round: Round) -> Ordering

Peforms the assignment.

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

type Output = SubFromRefInteger<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubFromRefInteger<'a>

Performs the - operation.

impl<'a> AssignRound<SubFromRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefInteger, round: Round) -> Ordering

Peforms the assignment.

impl SubFrom<Integer> for Float

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

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

fn sub_from(&mut self, lhs: &'a Integer)

Peforms the subtraction.

impl SubFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: Integer, round: Round) -> Ordering

Performs the subtraction.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &'a Integer, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SubFromRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl Mul<Integer> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Integer> for Float

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &'a Integer, round: Round) -> Ordering

Performs the multiplication.

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

type Output = MulRefInteger<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulRefInteger<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefInteger, round: Round) -> Ordering

Peforms the assignment.

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

type Output = MulRefIntegerOwn<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> MulRefIntegerOwn<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl MulFrom<Integer> for Float

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

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

fn mul_from(&mut self, lhs: &'a Integer)

Peforms the multiplication.

impl MulFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: Integer, round: Round) -> Ordering

Performs the multiplication.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &'a Integer, round: Round) -> Ordering

Performs the multiplication.

impl Div<Integer> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<Integer> for Float

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &'a Integer, round: Round) -> Ordering

Performs the division.

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

type Output = DivRefInteger<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> AssignRound<DivRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefInteger, round: Round) -> Ordering

Peforms the assignment.

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

type Output = DivFromRefInteger<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> AssignRound<DivFromRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefInteger, round: Round) -> Ordering

Peforms the assignment.

impl DivFrom<Integer> for Float

fn div_from(&mut self, lhs: Integer)

Peforms the division.

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

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

Peforms the division.

impl DivFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &'a Integer, round: Round) -> Ordering

Performs the division.

impl<'a> AssignRound<DivRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<DivFromRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl Pow<Integer> for Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: &'a Integer) -> Float

Performs the power operation.

impl PowAssign<Integer> for Float

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

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

fn pow_assign(&mut self, rhs: &'a Integer)

Peforms the power operation.

impl PowAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the power operation.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &'a Integer, round: Round) -> Ordering

Performs the power operation.

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

type Output = PowRefInteger<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Integer) -> PowRefInteger<'a>

Performs the power operation.

impl<'a> AssignRound<PowRefInteger<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRefInteger, round: Round) -> Ordering

Peforms the assignment.

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

type Output = PowRefIntegerOwn<'a>

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> PowRefIntegerOwn<'a>

Performs the power operation.

impl<'a> AssignRound<PowRefIntegerOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRefIntegerOwn, round: Round) -> Ordering

Peforms the assignment.

impl Add<Rational> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Rational> for Float

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

impl<'a> AddAssign<&'a Rational> for Float

fn add_assign(&mut self, rhs: &'a Rational)

Performs the += operation.

impl AddAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl<'a> AddAssignRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &'a Rational, round: Round) -> Ordering

Performs the addition.

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

type Output = AddRefRational<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddRefRational<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefRational<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefRational, round: Round) -> Ordering

Peforms the assignment.

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

type Output = AddRefRationalOwn<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> AddRefRationalOwn<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefRationalOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefRationalOwn, round: Round) -> Ordering

Peforms the assignment.

impl AddFrom<Rational> for Float

fn add_from(&mut self, lhs: Rational)

Peforms the addition.

impl<'a> AddFrom<&'a Rational> for Float

fn add_from(&mut self, lhs: &'a Rational)

Peforms the addition.

impl AddFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl<'a> AddFromRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &'a Rational, round: Round) -> Ordering

Performs the addition.

impl Sub<Rational> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> Float

Performs the - operation.

impl<'a> Sub<&'a Rational> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> Float

Performs the - operation.

impl SubAssign<Rational> for Float

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

impl<'a> SubAssign<&'a Rational> for Float

fn sub_assign(&mut self, rhs: &'a Rational)

Performs the -= operation.

impl SubAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubAssignRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &'a Rational, round: Round) -> Ordering

Performs the subtraction.

impl<'a> Sub<&'a Rational> for &'a Float

type Output = SubRefRational<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubRefRational<'a>

Performs the - operation.

impl<'a> AssignRound<SubRefRational<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefRational, round: Round) -> Ordering

Peforms the assignment.

impl<'a> Sub<Rational> for &'a Float

type Output = SubFromRefRational<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> SubFromRefRational<'a>

Performs the - operation.

impl<'a> AssignRound<SubFromRefRational<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefRational, round: Round) -> Ordering

Peforms the assignment.

impl SubFrom<Rational> for Float

fn sub_from(&mut self, lhs: Rational)

Peforms the subtraction.

impl<'a> SubFrom<&'a Rational> for Float

fn sub_from(&mut self, lhs: &'a Rational)

Peforms the subtraction.

impl SubFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: Rational, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubFromRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &'a Rational, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubRefRationalOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefRationalOwn, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<SubFromRefRationalOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefRationalOwn, round: Round) -> Ordering

Peforms the assignment.

impl Mul<Rational> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Rational> for Float

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

impl<'a> MulAssign<&'a Rational> for Float

fn mul_assign(&mut self, rhs: &'a Rational)

Performs the *= operation.

impl MulAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

impl<'a> MulAssignRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &'a Rational, round: Round) -> Ordering

Performs the multiplication.

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

type Output = MulRefRational<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulRefRational<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefRational<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefRational, round: Round) -> Ordering

Peforms the assignment.

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

type Output = MulRefRationalOwn<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> MulRefRationalOwn<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefRationalOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefRationalOwn, round: Round) -> Ordering

Peforms the assignment.

impl MulFrom<Rational> for Float

fn mul_from(&mut self, lhs: Rational)

Peforms the multiplication.

impl<'a> MulFrom<&'a Rational> for Float

fn mul_from(&mut self, lhs: &'a Rational)

Peforms the multiplication.

impl MulFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: Rational, round: Round) -> Ordering

Performs the multiplication.

impl<'a> MulFromRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &'a Rational, round: Round) -> Ordering

Performs the multiplication.

impl Div<Rational> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<Rational> for Float

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl<'a> DivAssign<&'a Rational> for Float

fn div_assign(&mut self, rhs: &'a Rational)

Performs the /= operation.

impl DivAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivAssignRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &'a Rational, round: Round) -> Ordering

Performs the division.

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

type Output = DivRefRational<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivRefRational<'a>

Performs the / operation.

impl<'a> AssignRound<DivRefRational<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefRational, round: Round) -> Ordering

Peforms the assignment.

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

type Output = DivFromRefRational<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> DivFromRefRational<'a>

Performs the / operation.

impl<'a> AssignRound<DivFromRefRational<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefRational, round: Round) -> Ordering

Peforms the assignment.

impl DivFrom<Rational> for Float

fn div_from(&mut self, lhs: Rational)

Peforms the division.

impl<'a> DivFrom<&'a Rational> for Float

fn div_from(&mut self, lhs: &'a Rational)

Peforms the division.

impl DivFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivFromRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &'a Rational, round: Round) -> Ordering

Performs the division.

impl<'a> AssignRound<DivRefRationalOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefRationalOwn, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<DivFromRefRationalOwn<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefRationalOwn, round: Round) -> Ordering

Peforms the assignment.

impl Add<i32> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<i32> for Float

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

type Output = AddRefI32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> AddRefI32<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefI32, round: Round) -> Ordering

Peforms the assignment.

impl AddAssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl AddFrom<i32> for Float

fn add_from(&mut self, lhs: i32)

Peforms the addition.

impl<'a> AddFromRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl Sub<i32> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<i32> for Float

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<'a> Sub<i32> for &'a Float

type Output = SubRefI32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> SubRefI32<'a>

Performs the - operation.

impl<'a> AssignRound<SubRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefI32, round: Round) -> Ordering

Peforms the assignment.

impl SubAssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: i32, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubFrom<i32> for Float

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

impl SubFromRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: i32, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubFromRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefI32, round: Round) -> Ordering

Peforms the assignment.

impl Mul<i32> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<i32> for Float

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

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

type Output = MulRefI32<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> MulRefI32<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefI32, round: Round) -> Ordering

Peforms the assignment.

impl MulAssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

impl MulFrom<i32> for Float

fn mul_from(&mut self, lhs: i32)

Peforms the multiplication.

impl<'a> MulFromRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: i32, round: Round) -> Ordering

Performs the multiplication.

impl Div<i32> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<i32> for Float

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

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

type Output = DivRefI32<'a>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DivRefI32<'a>

Performs the / operation.

impl<'a> AssignRound<DivRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefI32, round: Round) -> Ordering

Peforms the assignment.

impl DivAssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivFrom<i32> for Float

fn div_from(&mut self, lhs: i32)

Peforms the division.

impl DivFromRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> AssignRound<DivFromRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefI32, round: Round) -> Ordering

Peforms the assignment.

impl Add<u32> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<u32> for Float

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

type Output = AddRefU32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> AddRefU32<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefU32, round: Round) -> Ordering

Peforms the assignment.

impl AddAssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl AddFrom<u32> for Float

fn add_from(&mut self, lhs: u32)

Peforms the addition.

impl<'a> AddFromRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl Sub<u32> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<u32> for Float

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<'a> Sub<u32> for &'a Float

type Output = SubRefU32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> SubRefU32<'a>

Performs the - operation.

impl<'a> AssignRound<SubRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefU32, round: Round) -> Ordering

Peforms the assignment.

impl SubAssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: u32, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubFrom<u32> for Float

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

impl SubFromRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: u32, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubFromRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefU32, round: Round) -> Ordering

Peforms the assignment.

impl Mul<u32> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<u32> for Float

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

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

type Output = MulRefU32<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> MulRefU32<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefU32, round: Round) -> Ordering

Peforms the assignment.

impl MulAssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

impl MulFrom<u32> for Float

fn mul_from(&mut self, lhs: u32)

Peforms the multiplication.

impl<'a> MulFromRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: u32, round: Round) -> Ordering

Performs the multiplication.

impl Div<u32> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<u32> for Float

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

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

type Output = DivRefU32<'a>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DivRefU32<'a>

Performs the / operation.

impl<'a> AssignRound<DivRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefU32, round: Round) -> Ordering

Peforms the assignment.

impl DivAssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivFrom<u32> for Float

fn div_from(&mut self, lhs: u32)

Peforms the division.

impl DivFromRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> AssignRound<DivFromRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefU32, round: Round) -> Ordering

Peforms the assignment.

impl Add<f32> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<f32> for Float

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

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

type Output = AddRefF32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> AddRefF32<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefF32, round: Round) -> Ordering

Peforms the assignment.

impl AddAssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl AddFrom<f32> for Float

fn add_from(&mut self, lhs: f32)

Peforms the addition.

impl<'a> AddFromRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl Sub<f32> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<f32> for Float

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl<'a> Sub<f32> for &'a Float

type Output = SubRefF32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> SubRefF32<'a>

Performs the - operation.

impl<'a> AssignRound<SubRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefF32, round: Round) -> Ordering

Peforms the assignment.

impl SubAssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: f32, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubFrom<f32> for Float

fn sub_from(&mut self, lhs: f32)

Peforms the subtraction.

impl SubFromRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: f32, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubFromRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefF32, round: Round) -> Ordering

Peforms the assignment.

impl Mul<f32> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<f32> for Float

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

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

type Output = MulRefF32<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> MulRefF32<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefF32, round: Round) -> Ordering

Peforms the assignment.

impl MulAssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

impl MulFrom<f32> for Float

fn mul_from(&mut self, lhs: f32)

Peforms the multiplication.

impl<'a> MulFromRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: f32, round: Round) -> Ordering

Performs the multiplication.

impl Div<f32> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<f32> for Float

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

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

type Output = DivRefF32<'a>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> DivRefF32<'a>

Performs the / operation.

impl<'a> AssignRound<DivRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefF32, round: Round) -> Ordering

Peforms the assignment.

impl DivAssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivFrom<f32> for Float

fn div_from(&mut self, lhs: f32)

Peforms the division.

impl DivFromRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> AssignRound<DivFromRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefF32, round: Round) -> Ordering

Peforms the assignment.

impl Add<f64> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<f64> for Float

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

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

type Output = AddRefF64<'a>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> AddRefF64<'a>

Performs the + operation.

impl<'a> AssignRound<AddRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddRefF64, round: Round) -> Ordering

Peforms the assignment.

impl AddAssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl AddFrom<f64> for Float

fn add_from(&mut self, lhs: f64)

Peforms the addition.

impl<'a> AddFromRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl Sub<f64> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<f64> for Float

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl<'a> Sub<f64> for &'a Float

type Output = SubRefF64<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> SubRefF64<'a>

Performs the - operation.

impl<'a> AssignRound<SubRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubRefF64, round: Round) -> Ordering

Peforms the assignment.

impl SubAssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: f64, round: Round) -> Ordering

Performs the subtraction.

impl<'a> SubFrom<f64> for Float

fn sub_from(&mut self, lhs: f64)

Peforms the subtraction.

impl SubFromRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: f64, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubFromRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubFromRefF64, round: Round) -> Ordering

Peforms the assignment.

impl Mul<f64> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<f64> for Float

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

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

type Output = MulRefF64<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> MulRefF64<'a>

Performs the * operation.

impl<'a> AssignRound<MulRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: MulRefF64, round: Round) -> Ordering

Peforms the assignment.

impl MulAssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the multiplication.

impl MulFrom<f64> for Float

fn mul_from(&mut self, lhs: f64)

Peforms the multiplication.

impl<'a> MulFromRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: f64, round: Round) -> Ordering

Performs the multiplication.

impl Div<f64> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<f64> for Float

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

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

type Output = DivRefF64<'a>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> DivRefF64<'a>

Performs the / operation.

impl<'a> AssignRound<DivRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivRefF64, round: Round) -> Ordering

Peforms the assignment.

impl DivAssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> DivFrom<f64> for Float

fn div_from(&mut self, lhs: f64)

Peforms the division.

impl DivFromRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the division.

impl<'a> AssignRound<DivFromRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: DivFromRefF64, round: Round) -> Ordering

Peforms the assignment.

impl Shl<u32> for Float

type Output = Float

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<u32> for Float

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<'a> Shl<u32> for &'a Float

type Output = ShlRefU32<'a>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlRefU32<'a>

Performs the << operation.

impl<'a> AssignRound<ShlRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ShlRefU32, round: Round) -> Ordering

Peforms the assignment.

impl Shr<u32> for Float

type Output = Float

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<u32> for Float

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<'a> Shr<u32> for &'a Float

type Output = ShrRefU32<'a>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrRefU32<'a>

Performs the >> operation.

impl<'a> AssignRound<ShrRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ShrRefU32, round: Round) -> Ordering

Peforms the assignment.

impl Pow<u32> for Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

impl PowAssign<u32> for Float

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl<'a> Pow<u32> for &'a Float

type Output = PowRefU32<'a>

The resulting type after the power operation.

fn pow(self, rhs: u32) -> PowRefU32<'a>

Performs the power operation.

impl<'a> AssignRound<PowRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRefU32, round: Round) -> Ordering

Peforms the assignment.

impl PowAssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: u32, round: Round) -> Ordering

Performs the power operation.

impl<'a> PowFrom<u32> for Float

fn pow_from(&mut self, lhs: u32)

Peforms the power operation.

impl PowFromRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: u32, round: Round) -> Ordering

Performs the power operation.

impl<'a> AssignRound<PowFromRefU32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowFromRefU32, round: Round) -> Ordering

Peforms the assignment.

impl Shl<i32> for Float

type Output = Float

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<i32> for Float

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<'a> Shl<i32> for &'a Float

type Output = ShlRefI32<'a>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlRefI32<'a>

Performs the << operation.

impl<'a> AssignRound<ShlRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ShlRefI32, round: Round) -> Ordering

Peforms the assignment.

impl Shr<i32> for Float

type Output = Float

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<i32> for Float

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<'a> Shr<i32> for &'a Float

type Output = ShrRefI32<'a>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrRefI32<'a>

Performs the >> operation.

impl<'a> AssignRound<ShrRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ShrRefI32, round: Round) -> Ordering

Peforms the assignment.

impl Pow<i32> for Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

impl PowAssign<i32> for Float

fn pow_assign(&mut self, rhs: i32)

Peforms the power operation.

impl<'a> Pow<i32> for &'a Float

type Output = PowRefI32<'a>

The resulting type after the power operation.

fn pow(self, rhs: i32) -> PowRefI32<'a>

Performs the power operation.

impl<'a> AssignRound<PowRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRefI32, round: Round) -> Ordering

Peforms the assignment.

impl PowAssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: i32, round: Round) -> Ordering

Performs the power operation.

impl<'a> PowFrom<i32> for Float

fn pow_from(&mut self, lhs: i32)

Peforms the power operation.

impl PowFromRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: i32, round: Round) -> Ordering

Performs the power operation.

impl<'a> AssignRound<PowFromRefI32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowFromRefI32, round: Round) -> Ordering

Peforms the assignment.

impl Pow<f64> for Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

impl PowAssign<f64> for Float

fn pow_assign(&mut self, rhs: f64)

Peforms the power operation.

impl<'a> Pow<f64> for &'a Float

type Output = PowRefF64<'a>

The resulting type after the power operation.

fn pow(self, rhs: f64) -> PowRefF64<'a>

Performs the power operation.

impl<'a> AssignRound<PowRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRefF64, round: Round) -> Ordering

Peforms the assignment.

impl PowAssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: f64, round: Round) -> Ordering

Performs the power operation.

impl<'a> PowFrom<f64> for Float

fn pow_from(&mut self, lhs: f64)

Peforms the power operation.

impl PowFromRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: f64, round: Round) -> Ordering

Performs the power operation.

impl<'a> AssignRound<PowFromRefF64<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowFromRefF64, round: Round) -> Ordering

Peforms the assignment.

impl Pow<f32> for Float

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

impl PowAssign<f32> for Float

fn pow_assign(&mut self, rhs: f32)

Peforms the power operation.

impl<'a> Pow<f32> for &'a Float

type Output = PowRefF32<'a>

The resulting type after the power operation.

fn pow(self, rhs: f32) -> PowRefF32<'a>

Performs the power operation.

impl<'a> AssignRound<PowRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowRefF32, round: Round) -> Ordering

Peforms the assignment.

impl PowAssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: f32, round: Round) -> Ordering

Performs the power operation.

impl<'a> PowFrom<f32> for Float

fn pow_from(&mut self, lhs: f32)

Peforms the power operation.

impl PowFromRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_from_round(&mut self, lhs: f32, round: Round) -> Ordering

Performs the power operation.

impl<'a> AssignRound<PowFromRefF32<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: PowFromRefF32, round: Round) -> Ordering

Peforms the assignment.

impl<'a> Add<MulRef<'a>> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> AddAssign<MulRef<'a>> for Float

fn add_assign(&mut self, rhs: MulRef)

Performs the += operation.

impl<'a> AddAssignRound<MulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

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

type Output = AddMulRef<'a>

The resulting type after applying the + operator.

fn add(self, rhs: MulRef<'a>) -> AddMulRef<'a>

Performs the + operation.

impl<'a> AssignRound<AddMulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AddMulRef, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AddFrom<MulRef<'a>> for Float

fn add_from(&mut self, lhs: MulRef)

Peforms the addition.

impl<'a> AddFromRound<MulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Performs the addition.

impl<'a> Sub<MulRef<'a>> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: MulRef) -> Float

Performs the - operation.

impl<'a> SubAssign<MulRef<'a>> for Float

fn sub_assign(&mut self, rhs: MulRef)

Performs the -= operation.

impl<'a> SubAssignRound<MulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: MulRef, round: Round) -> Ordering

Performs the subtraction.

impl<'a> Sub<MulRef<'a>> for &'a Float

type Output = SubMulRef<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: MulRef<'a>) -> SubMulRef<'a>

Performs the - operation.

impl<'a> AssignRound<SubMulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubMulRef, round: Round) -> Ordering

Peforms the assignment.

impl<'a> SubFrom<MulRef<'a>> for Float

fn sub_from(&mut self, lhs: MulRef)

Peforms the subtraction.

impl<'a> SubFromRound<MulRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: MulRef, round: Round) -> Ordering

Performs the subtraction.

impl<'a> AssignRound<SubMulFromRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: SubMulFromRef, round: Round) -> Ordering

Peforms the assignment.

impl Sum for Float

fn sum<I>(iter: I) -> Float where
    I: Iterator<Item = Float>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a> Sum<&'a Float> for Float

fn sum<I>(iter: I) -> Float where
    I: Iterator<Item = &'a Float>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl Product for Float

fn product<I>(iter: I) -> Float where
    I: Iterator<Item = Float>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a Float> for Float

fn product<I>(iter: I) -> Float where
    I: Iterator<Item = &'a Float>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl PartialEq for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<Integer> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Integer> for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<Rational> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Rational> for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<u32> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<u32> for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<i32> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<i32> for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<f64> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<f64> for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<f32> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<f32> for Float

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Default for Float

fn default() -> Float

Returns the "default value" for a type.

impl Clone for Float

fn clone(&self) -> Float

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Drop for Float

fn drop(&mut self)

Executes the destructor for this type.

impl From<OrdFloat> for Float

fn from(ord: OrdFloat) -> Float

Performs the conversion.

impl Display for Float

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

Formats the value using the given formatter.

impl Debug for Float

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

Formats the value using the given formatter.

impl LowerExp for Float

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

Formats the value using the given formatter.

impl UpperExp for Float

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

Formats the value using the given formatter.

impl Binary for Float

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

Formats the value using the given formatter.

impl Octal for Float

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

Formats the value using the given formatter.

impl LowerHex for Float

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

Formats the value using the given formatter.

impl UpperHex for Float

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

Formats the value using the given formatter.

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

fn assign(&mut self, rhs: T)

Peforms the assignement.

impl AssignRound<Constant> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: Constant, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<Special> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: Special, _round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a Constant> for Float

type Round = <Float as AssignRound<Constant>>::Round

The rounding method.

type Ordering = <Float as AssignRound<Constant>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a Constant, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a Special> for Float

type Round = <Float as AssignRound<Special>>::Round

The rounding method.

type Ordering = <Float as AssignRound<Special>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a Special, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: &'a Float, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<Float> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: Float, round: Round) -> Ordering

Peforms the assignment.

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

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: &'a Integer, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: &'a Rational, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, rhs: Rational, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<i32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, val: i32, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a i32> for Float

type Round = <Float as AssignRound<i32>>::Round

The rounding method.

type Ordering = <Float as AssignRound<i32>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a i32, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<i64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Peforms the assignment.

impl<'a> AssignRound<&'a i64> for Float

type Round = <Float as AssignRound<i64>>::Round

The rounding method.

type Ordering = <Float as AssignRound<i64>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a i64, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<u32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, val: u32, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a u32> for Float

type Round = <Float as AssignRound<u32>>::Round

The rounding method.

type Ordering = <Float as AssignRound<u32>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a u32, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<u64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

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

Peforms the assignment.

impl<'a> AssignRound<&'a u64> for Float

type Round = <Float as AssignRound<u64>>::Round

The rounding method.

type Ordering = <Float as AssignRound<u64>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a u64, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<f32> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, val: f32, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a f32> for Float

type Round = <Float as AssignRound<f32>>::Round

The rounding method.

type Ordering = <Float as AssignRound<f32>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a f32, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<f64> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, val: f64, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<&'a f64> for Float

type Round = <Float as AssignRound<f64>>::Round

The rounding method.

type Ordering = <Float as AssignRound<f64>>::Ordering

The direction from rounding.

fn assign_round(&mut self, r: &'a f64, round: Round) -> Ordering

Peforms the assignment.

impl Send for Float

impl Sync for Float

impl<'a> AssignRound<AbsRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: AbsRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<ArgRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: ArgRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl<'a> AssignRound<NormRef<'a>> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: NormRef<'a>, round: Round) -> Ordering

Peforms the assignment.

impl Add<Complex> for Float

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddRefFloatOwn<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Complex) -> AddRefFloatOwn<'a>

Performs the + operation.

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

type Output = AddRefFloat<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Complex) -> AddRefFloat<'a>

Performs the + operation.

impl Sub<Complex> for Float

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

impl<'a> Sub<Complex> for &'a Float

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

impl<'a> Sub<&'a Complex> for Float

type Output = SubFromRefFloatOwn<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubFromRefFloatOwn<'a>

Performs the - operation.

impl<'a> Sub<&'a Complex> for &'a Float

type Output = SubRefFloatOwn<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubRefFloatOwn<'a>

Performs the - operation.

impl Mul<Complex> for Float

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulRefFloatOwn<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Complex) -> MulRefFloatOwn<'a>

Performs the * operation.

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

type Output = MulRefFloat<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Complex) -> MulRefFloat<'a>

Performs the * operation.

impl Div<Complex> for Float

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromRefFloatOwn<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Complex) -> DivFromRefFloatOwn<'a>

Performs the / operation.

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

type Output = DivRefFloatOwn<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Complex) -> DivRefFloatOwn<'a>

Performs the / operation.

impl PartialEq<Complex> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.