Struct rug::Rational

pub struct Rational { /* fields omitted */ }

An arbitrary-precision rational number.

A rational number is made up of a numerator Integer and denominator Integer. After rational number functions, the number is always in canonical form, that is, the denominator is always greater than zero, and there are no common factors. Zero is stored as 0/1.

Examples

use rug::Rational;
let r = Rational::from((-12, 15));
let recip = Rational::from(r.recip_ref());
assert_eq!(recip, (-5, 4));
assert_eq!(recip.to_f32(), -1.25);
// The numerator and denominator are stored in canonical form.
let (num, den) = r.into_numer_denom();
assert_eq!(num, -4);
assert_eq!(den, 5);

The Rational type supports various functions. Most methods have three versions: one that consumes the operand, one that mutates the operand, and one that borrows the operand.

use rug::Rational;

// 1. consume the operand
let a = Rational::from((-15, 2));
let abs_a = a.abs();
assert_eq!(abs_a, (15, 2));

// 2. mutate the operand
let mut b = Rational::from((-17, 2));
b.abs_mut();
assert_eq!(b, (17, 2));

// 3. borrow the operand
let c = Rational::from((-19, 2));
let r = c.abs_ref();
let abs_c = Rational::from(r);
assert_eq!(abs_c, (19, 2));
// c was not consumed
assert_eq!(c, (-19, 2));

Methods

impl Rational

fn new() -> Rational

Constructs a new arbitrary-precision rational number with value 0.

Examples

use rug::Rational;
let r = Rational::new();
assert_eq!(r, 0);

fn from_f32(val: f32) -> Option<Rational>

Creates a Rational from an f32 if it is finite, losing no precision.

Examples

use rug::Rational;
use std::f32;
let r = Rational::from_f32(-17125e-3).unwrap();
assert_eq!(r, "-17125/1000".parse::<Rational>().unwrap());
let inf = Rational::from_f32(f32::INFINITY);
assert!(inf.is_none());

fn from_f64(val: f64) -> Option<Rational>

Creates a Rational from an f64 if it is finite, losing no precision.

Examples

use rug::Rational;
use std::f64;
let r = Rational::from_f64(-17125e-3).unwrap();
assert_eq!(r, "-17125/1000".parse::<Rational>().unwrap());
let inf = Rational::from_f64(f64::INFINITY);
assert!(inf.is_none());

fn from_str_radix(src: &str, radix: i32) -> Result<Rational, ParseRationalError>

Parses a Rational number.

Examples

use rug::Rational;
let r1 = Rational::from_str_radix("ff/a", 16).unwrap();
assert_eq!(r1, (255, 10));
let r2 = Rational::from_str_radix("+ff0/a0", 16).unwrap();
assert_eq!(r2, (0xff0, 0xa0));
assert_eq!(*r2.numer(), 51);
assert_eq!(*r2.denom(), 2);

Panics

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

fn valid_str_radix(
    src: &str,
    radix: i32
) -> Result<ValidRational, ParseRationalError>

Checks if a Rational number can be parsed.

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

The string must contain a numerator, and may contain a denominator; the numerator and denominator are separated with a '/'. The numerator can start with an optional minus or plus sign.

Whitespace is not allowed anywhere in the string, including in the beginning and end and around the '/'.

Examples

use rug::Rational;

let valid1 = Rational::valid_str_radix("12/23", 4);
let r1 = Rational::from(valid1.unwrap());
assert_eq!(r1, (2 + 4 * 1, 3 + 4 * 2));
let valid2 = Rational::valid_str_radix("12/yz", 36);
let r2 = Rational::from(valid2.unwrap());
assert_eq!(r2, (2 + 36 * 1, 35 + 36 * 34));

let invalid = Rational::valid_str_radix("12 / 23", 4);
let invalid_f = Rational::from_str_radix("12 / 23", 4);
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) -> Integer

Converts to an Integer, rounding towards zero.

Examples

use rug::Rational;
let pos = Rational::from((139, 10));
let posi = pos.to_integer();
assert_eq!(posi, 13);
let neg = Rational::from((-139, 10));
let negi = neg.to_integer();
assert_eq!(negi, -13);

fn copy_to_integer(&self, i: &mut Integer)

Converts to an Integer inside i, rounding towards zero.

Examples

use rug::{Integer, Rational};
let mut i = Integer::new();
assert_eq!(i, 0);
let pos = Rational::from((139, 10));
pos.copy_to_integer(&mut i);
assert_eq!(i, 13);
let neg = Rational::from((-139, 10));
neg.copy_to_integer(&mut i);
assert_eq!(i, -13);

fn to_f32(&self) -> f32

Converts to an f32, rounding towards zero.

Examples

use rug::Rational;
use rug::rational::SmallRational;
use std::f32;
let min = Rational::from_f32(f32::MIN).unwrap();
let minus_small = min - &*SmallRational::from((7, 2));
// minus_small is truncated to f32::MIN
assert_eq!(minus_small.to_f32(), f32::MIN);
let times_three_two = minus_small * &*SmallRational::from((3, 2));
// times_three_two is too small
assert_eq!(times_three_two.to_f32(), f32::NEG_INFINITY);

fn to_f64(&self) -> f64

Converts to an f64, rounding towards zero.

Examples

use rug::Rational;
use rug::rational::SmallRational;
use std::f64;

// An `f64` has 53 bits of precision.
let exact = 0x1f_1234_5678_9aff_u64;
let den = 0x1000_u64;
let r = Rational::from((exact, den));
assert_eq!(r.to_f64(), exact as f64 / den as f64);

// large has 56 ones
let large = 0xff_1234_5678_9aff_u64;
// trunc has 53 ones followed by 3 zeros
let trunc = 0xff_1234_5678_9af8_u64;
let j = Rational::from((large, den));
assert_eq!(j.to_f64(), trunc as f64 / den as f64);

let max = Rational::from_f64(f64::MAX).unwrap();
let plus_small = max + &*SmallRational::from((7, 2));
// plus_small is truncated to f64::MAX
assert_eq!(plus_small.to_f64(), f64::MAX);
let times_three_two = plus_small * &*SmallRational::from((3, 2));
// times_three_two is too large
assert_eq!(times_three_two.to_f64(), f64::INFINITY);

fn to_string_radix(&self, radix: i32) -> String

Returns a string representation for the specified radix.

Examples

use rug::Rational;
let r1 = Rational::from(0);
assert_eq!(r1.to_string_radix(10), "0");
let r2 = Rational::from((15, 5));
assert_eq!(r2.to_string_radix(10), "3");
let r3 = Rational::from((10, -6));
assert_eq!(r3.to_string_radix(10), "-5/3");
assert_eq!(r3.to_string_radix(5), "-10/3");

Panics

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

fn assign_f32(&mut self, val: f32) -> Result<(), ()>

Assigns from an f32 if it is finite, losing no precision.

Examples

use rug::Rational;
use std::f32;
let mut r = Rational::new();
let ret = r.assign_f32(12.75);
assert!(ret.is_ok());
assert_eq!(r, (1275, 100));
let ret = r.assign_f32(f32::NAN);
assert!(ret.is_err());
assert_eq!(r, (1275, 100));

fn assign_f64(&mut self, val: f64) -> Result<(), ()>

Assigns from an f64 if it is finite, losing no precision.

Examples

use rug::Rational;
let mut r = Rational::new();
let ret = r.assign_f64(12.75);
assert!(ret.is_ok());
assert_eq!(r, (1275, 100));
let ret = r.assign_f64(1.0 / 0.0);
assert!(ret.is_err());
assert_eq!(r, (1275, 100));

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

Parses a Rational number from a string.

Examples

use rug::Rational;
let mut r = Rational::new();
let ret = r.assign_str("1/0");
assert!(ret.is_err());
r.assign_str("-24/2").unwrap();
assert_eq!(*r.numer(), -12);
assert_eq!(*r.denom(), 1);

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

Parses a Rational number from a string with the specified radix.

Examples

use rug::Rational;
let mut r = Rational::new();
r.assign_str_radix("ff/a", 16).unwrap();
assert_eq!(r, (255, 10));
r.assign_str_radix("+ff0/a0", 16).unwrap();
assert_eq!(r, (255, 10));

Panics

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

fn numer(&self) -> &Integer

Borrows the numerator as an Integer.

Examples

use rug::Rational;
let r = Rational::from((12, -20));
// r will be canonicalized to -3 / 5
assert_eq!(*r.numer(), -3)

fn denom(&self) -> &Integer

Borrows the denominator as an Integer.

Examples

use rug::Rational;
let r = Rational::from((12, -20));
// r will be canonicalized to -3 / 5
assert_eq!(*r.denom(), 5);

fn as_numer_denom(&self) -> (&Integer, &Integer)

Borrows the numerator and denominator as Integer values.

Examples

use rug::Rational;
let r = Rational::from((12, -20));
// r will be canonicalized to -3 / 5
let (num, den) = r.as_numer_denom();
assert_eq!(*num, -3);
assert_eq!(*den, 5);

fn as_mut_numer_denom(&mut self) -> MutNumerDenom

Borrows the numerator and denominator mutably. The number is canonicalized when the borrow ends. The denominator must not be zero when the borrow ends.

Examples

use rug::Rational;

let mut r = Rational::from((3, 5));
{
    let mut num_den = r.as_mut_numer_denom();
    // change r from 3/5 to 4/8, which is equal to 1/2
    *num_den.num() += 1;
    *num_den.den() += 3;
    // borrow ends here
}
let num_den = r.as_numer_denom();
assert_eq!(*num_den.0, 1);
assert_eq!(*num_den.1, 2);

If the mutable value is leaked, the denominator is lost when the borrow ends.

use rug::Rational;
use std::mem;

let mut r = Rational::from((3, 5));
{
    let mut num_den = r.as_mut_numer_denom();
    // try change r from 3/5 to 4/8
    *num_den.num() += 1;
    *num_den.den() += 3;
    // forget num_den, so no canonicalization takes place
    mem::forget(num_den)
    // borrow ends here, but nothing happens
}
// because of the leak, 4/8 has become 4/1
let num_den = r.as_numer_denom();
assert_eq!(*num_den.0, 4);
assert_eq!(*num_den.1, 1);

Panics

Panics if the denominator is zero when the borrow ends.

unsafe fn as_mut_numer_denom_no_canonicalization(
    &mut self
) -> (&mut Integer, &mut Integer)

Borrows the numerator and denominator mutably without canonicalizing aftwerwards.

Safety

This function is unsafe because it does not canonicalize the rational number when the borrow ends. The rest of the library assumes that Rational structures keep their numerators and denominators canonicalized.

Examples

use rug::Rational;

let mut r = Rational::from((3, 5));
{
    let (num, den) = unsafe {
        r.as_mut_numer_denom_no_canonicalization()
    };
    // Add one to r by adding den to num. Since num and den
    // are relatively prime, r remains canonicalized.
    *num += &*den;
}
assert_eq!(r, (8, 5));

fn into_numer_denom(self) -> (Integer, Integer)

Converts into numerator and denominator integers.

This function reuses the allocated memory and does not allocate any new memory.

Examples

use rug::Rational;
let r = Rational::from((12, -20));
// r will be canonicalized to -3 / 5
let (num, den) = r.into_numer_denom();
assert_eq!(num, -3);
assert_eq!(den, 5);

fn as_neg(&self) -> BorrowRational

Borrows a negated copy of the Rational number.

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

Examples

use rug::Rational;
let r = Rational::from((7, 11));
let neg_r = r.as_neg();
assert_eq!(*neg_r, (-7, 11));
// methods taking &self can be used on the returned object
let reneg_r = neg_r.as_neg();
assert_eq!(*reneg_r, (7, 11));
assert_eq!(*reneg_r, r);

fn as_abs(&self) -> BorrowRational

Borrows an absolute copy of the Rational number.

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

Examples

use rug::Rational;
let r = Rational::from((-7, 11));
let abs_r = r.as_abs();
assert_eq!(*abs_r, (7, 11));
// methods taking &self can be used on the returned object
let reabs_r = abs_r.as_abs();
assert_eq!(*reabs_r, (7, 11));
assert_eq!(*reabs_r, *abs_r);

fn as_recip(&self) -> BorrowRational

Borrows a reciprocal copy of the Rational number.

The returned object implements Deref with a Rational target. This method performs some shallow copying, swapping numerator and denominator and making sure the sign is in the numerator.

Examples

use rug::Rational;
let r = Rational::from((-7, 11));
let recip_r = r.as_recip();
assert_eq!(*recip_r, (-11, 7));
// methods taking &self can be used on the returned object
let rerecip_r = recip_r.as_recip();
assert_eq!(*rerecip_r, (-7, 11));
assert_eq!(*rerecip_r, r);

Panics

Panics if the value is zero.

fn cmp0(&self) -> Ordering

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

Examples

use rug::Rational;
use std::cmp::Ordering;
assert_eq!(Rational::from((-5, 7)).cmp0(), Ordering::Less);
assert_eq!(Rational::from(0).cmp0(), Ordering::Equal);
assert_eq!(Rational::from((5, 7)).cmp0(), Ordering::Greater);

fn abs(self) -> Self

Computes the absolute value.

Examples

use rug::Rational;
let r = Rational::from((-100, 17));
let abs = r.abs();
assert_eq!(abs, (100, 17));

fn abs_mut(&mut self)

Computes the absolute value.

Examples

use rug::Rational;
let mut r = Rational::from((-100, 17));
r.abs_mut();
assert_eq!(r, (100, 17));

fn abs_ref(&self) -> AbsRef

Computes the absolute value.

Examples

use rug::Rational;
let r = Rational::from((-100, 17));
let r_ref = r.abs_ref();
let abs = Rational::from(r_ref);
assert_eq!(abs, (100, 17));

fn clamp<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Rational where
    Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>, 

Clamps the value within the specified bounds.

Examples

use rug::Rational;
let min = (-3, 2);
let max = (3, 2);
let too_small = Rational::from((-5, 2));
let clamped1 = too_small.clamp(&min, &max);
assert_eq!(clamped1, (-3, 2));
let in_range = Rational::from((1, 2));
let clamped2 = in_range.clamp(&min, &max);
assert_eq!(clamped2, (1, 2));

Panics

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

fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where
    Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>, 

Clamps the value within the specified bounds.

Examples

use rug::Rational;
let min = (-3, 2);
let max = (3, 2);
let mut too_small = Rational::from((-5, 2));
too_small.clamp_mut(&min, &max);
assert_eq!(too_small, (-3, 2));
let mut in_range = Rational::from((1, 2));
in_range.clamp_mut(&min, &max);
assert_eq!(in_range, (1, 2));

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
    Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>, 

Clamps the value within the specified bounds.

Examples

use rug::Rational;
let min = (-3, 2);
let max = (3, 2);
let too_small = Rational::from((-5, 2));
let r1 = too_small.clamp_ref(&min, &max);
let clamped1 = Rational::from(r1);
assert_eq!(clamped1, (-3, 2));
let in_range = Rational::from((1, 2));
let r2 = in_range.clamp_ref(&min, &max);
let clamped2 = Rational::from(r2);
assert_eq!(clamped2, (1, 2));

Panics

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

fn recip(self) -> Self

Computes the reciprocal.

Examples

use rug::Rational;
let r = Rational::from((-100, 17));
let recip = r.recip();
assert_eq!(recip, (-17, 100));

Panics

Panics if the value is zero.

fn recip_mut(&mut self)

Computes the reciprocal.

Examples

use rug::Rational;
let mut r = Rational::from((-100, 17));
r.recip_mut();
assert_eq!(r, (-17, 100));

Panics

Panics if the value is zero.

fn recip_ref(&self) -> RecipRef

Computes the reciprocal.

Examples

use rug::Rational;
let r = Rational::from((-100, 17));
let r_ref = r.recip_ref();
let recip = Rational::from(r_ref);
assert_eq!(recip, (-17, 100));

fn trunc(self) -> Integer

Rounds the number towards zero and returns it as an Integer.

Examples

use rug::Rational;
// -3.7
let r1 = Rational::from((-37, 10));
let i1 = r1.trunc();
assert_eq!(i1, -3);
// 3.3
let r2 = Rational::from((33, 10));
let i2 = r2.trunc();
assert_eq!(i2, 3);

fn trunc_mut(&mut self)

Rounds the number towards zero.

Examples

use rug::{Assign, Rational};
// -3.7
let mut r = Rational::from((-37, 10));
r.trunc_mut();
assert_eq!(r, -3);
// 3.3
r.assign((33, 10));
r.trunc_mut();
assert_eq!(r, 3);

fn trunc_ref(&self) -> TruncRef

Rounds the number towards zero.

Examples

use rug::{Assign, Integer, Rational};
let mut trunc = Integer::new();
// -3.7
let r1 = Rational::from((-37, 10));
trunc.assign(r1.trunc_ref());
assert_eq!(trunc, -3);
// 3.3
let r2 = Rational::from((33, 10));
trunc.assign(r2.trunc_ref());
assert_eq!(trunc, 3);

fn fract(self) -> Rational

Deprecated since 0.9.0

: renamed to rem_trunc

Computes the fractional part of the number.

fn fract_mut(&mut self)

Deprecated since 0.9.0

: renamed to rem_trunc_mut

Computes the fractional part of the number.

fn fract_ref(&self) -> RemTruncRef

Deprecated since 0.9.0

: renamed to rem_trunc_ref

Computes the fractional part of the number.

fn rem_trunc(self) -> Self

Computes the fractional part of the number.

Examples

use rug::Rational;
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
let rem = r.rem_trunc();
assert_eq!(rem, (-15, 17));

fn rem_trunc_mut(&mut self)

Computes the fractional part of the number.

Examples

use rug::Rational;
// -100/17 = -5 - 15/17
let mut r = Rational::from((-100, 17));
r.rem_trunc_mut();
assert_eq!(r, (-15, 17));

fn rem_trunc_ref(&self) -> RemTruncRef

Computes the fractional part of the number.

Examples

use rug::Rational;
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
let r_ref = r.rem_trunc_ref();
let rem = Rational::from(r_ref);
assert_eq!(rem, (-15, 17));

fn fract_trunc(self, trunc: Integer) -> (Rational, Integer)

Computes the fractional and truncated parts of the number.

The initial value of trunc is ignored.

Examples

use rug::{Integer, Rational};
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
let (fract, trunc) = r.fract_trunc(Integer::new());
assert_eq!(fract, (-15, 17));
assert_eq!(trunc, -5);

fn fract_trunc_mut(&mut self, trunc: &mut Integer)

Computes the fractional and truncated parts of the number.

The initial value of trunc is ignored.

Examples

use rug::{Integer, Rational};
// -100/17 = -5 - 15/17
let mut r = Rational::from((-100, 17));
let mut whole = Integer::new();
r.fract_trunc_mut(&mut whole);
assert_eq!(r, (-15, 17));
assert_eq!(whole, -5);

fn fract_trunc_ref(&self) -> FractTruncRef

Computes the fractional and truncated parts of the number.

Examples

use rug::{Assign, Integer, Rational};
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
let r_ref = r.fract_trunc_ref();
let (mut fract, mut trunc) = (Rational::new(), Integer::new());
(&mut fract, &mut trunc).assign(r_ref);
assert_eq!(fract, (-15, 17));
assert_eq!(trunc, -5);

fn ceil(self) -> Integer

Rounds the number upwards (towards plus infinity) and returns it as an Integer.

Examples

use rug::Rational;
// -3.7
let r1 = Rational::from((-37, 10));
let i1 = r1.ceil();
assert_eq!(i1, -3);
// 3.3
let r2 = Rational::from((33, 10));
let i2 = r2.ceil();
assert_eq!(i2, 4);

fn ceil_mut(&mut self)

Rounds the number upwards (towards plus infinity).

Examples

use rug::{Assign, Rational};
// -3.7
let mut r = Rational::from((-37, 10));
r.ceil_mut();
assert_eq!(r, -3);
// 3.3
r.assign((33, 10));
r.ceil_mut();
assert_eq!(r, 4);

fn ceil_ref(&self) -> CeilRef

Rounds the number upwards (towards plus infinity).

Examples

use rug::{Assign, Integer, Rational};
let mut ceil = Integer::new();
// -3.7
let r1 = Rational::from((-37, 10));
ceil.assign(r1.ceil_ref());
assert_eq!(ceil, -3);
// 3.3
let r2 = Rational::from((33, 10));
ceil.assign(r2.ceil_ref());
assert_eq!(ceil, 4);

fn rem_ceil(self) -> Self

Computes the non-positive remainder after rounding up.

Examples

use rug::Rational;
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
let rem = r.rem_ceil();
assert_eq!(rem, (-2, 17));

fn rem_ceil_mut(&mut self)

Computes the non-positive remainder after rounding up.

Examples

use rug::Rational;
// 100/17 = 6 - 2/17
let mut r = Rational::from((100, 17));
r.rem_ceil_mut();
assert_eq!(r, (-2, 17));

fn rem_ceil_ref(&self) -> RemCeilRef

Computes the non-positive remainder after rounding up.

Examples

use rug::Rational;
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
let r_ref = r.rem_ceil_ref();
let rem = Rational::from(r_ref);
assert_eq!(rem, (-2, 17));

fn fract_ceil(self, ceil: Integer) -> (Rational, Integer)

Computes the fractional and ceil parts of the number.

The fractional part cannot greater than zero. The initial value of ceil is ignored.

Examples

use rug::{Integer, Rational};
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
let (fract, ceil) = r.fract_ceil(Integer::new());
assert_eq!(fract, (-2, 17));
assert_eq!(ceil, 6);

fn fract_ceil_mut(&mut self, ceil: &mut Integer)

Computes the fractional and ceil parts of the number.

The fractional part cannot be greater than zero. The initial value of ceil is ignored.

Examples

use rug::{Integer, Rational};
// 100/17 = 6 - 2/17
let mut r = Rational::from((100, 17));
let mut ceil = Integer::new();
r.fract_ceil_mut(&mut ceil);
assert_eq!(r, (-2, 17));
assert_eq!(ceil, 6);

fn fract_ceil_ref(&self) -> FractCeilRef

Computes the fractional and ceil parts of the number.

The fractional part cannot be greater than zero.

Examples

use rug::{Assign, Integer, Rational};
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
let r_ref = r.fract_ceil_ref();
let (mut fract, mut ceil) = (Rational::new(), Integer::new());
(&mut fract, &mut ceil).assign(r_ref);
assert_eq!(fract, (-2, 17));
assert_eq!(ceil, 6);

fn floor(self) -> Integer

Rounds the number downwards (towards minus infinity) and returns it as an Integer.

Examples

use rug::Rational;
// -3.7
let r1 = Rational::from((-37, 10));
let i1 = r1.floor();
assert_eq!(i1, -4);
// 3.3
let r2 = Rational::from((33, 10));
let i2 = r2.floor();
assert_eq!(i2, 3);

fn floor_mut(&mut self)

Rounds the number downwards (towards minus infinity).

use rug::{Assign, Rational};
// -3.7
let mut r = Rational::from((-37, 10));
r.floor_mut();
assert_eq!(r, -4);
// 3.3
r.assign((33, 10));
r.floor_mut();
assert_eq!(r, 3);

fn floor_ref(&self) -> FloorRef

Rounds the number downwards (towards minus infinity).

Examples

use rug::{Assign, Integer, Rational};
let mut floor = Integer::new();
// -3.7
let r1 = Rational::from((-37, 10));
floor.assign(r1.floor_ref());
assert_eq!(floor, -4);
// 3.3
let r2 = Rational::from((33, 10));
floor.assign(r2.floor_ref());
assert_eq!(floor, 3);

fn rem_floor(self) -> Self

Computes the non-negative remainder after rounding down.

Examples

use rug::Rational;
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
let rem = r.rem_floor();
assert_eq!(rem, (2, 17));

fn rem_floor_mut(&mut self)

Computes the non-negative remainder after rounding down.

Examples

use rug::Rational;
// -100/17 = -6 + 2/17
let mut r = Rational::from((-100, 17));
r.rem_floor_mut();
assert_eq!(r, (2, 17));

fn rem_floor_ref(&self) -> RemFloorRef

Computes the non-negative remainder after rounding down.

Examples

use rug::Rational;
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
let r_ref = r.rem_floor_ref();
let rem = Rational::from(r_ref);
assert_eq!(rem, (2, 17));

fn fract_floor(self, floor: Integer) -> (Rational, Integer)

Computes the fractional and floor parts of the number.

The fractional part cannot be negative. The initial value of floor is ignored.

Examples

use rug::{Integer, Rational};
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
let (fract, floor) = r.fract_floor(Integer::new());
assert_eq!(fract, (2, 17));
assert_eq!(floor, -6);

fn fract_floor_mut(&mut self, floor: &mut Integer)

Computes the fractional and floor parts of the number.

The fractional part cannot be negative. The initial value of floor is ignored.

Examples

use rug::{Integer, Rational};
// -100/17 = -6 + 2/17
let mut r = Rational::from((-100, 17));
let mut floor = Integer::new();
r.fract_floor_mut(&mut floor);
assert_eq!(r, (2, 17));
assert_eq!(floor, -6);

fn fract_floor_ref(&self) -> FractFloorRef

Computes the fractional and floor parts of the number.

The fractional part cannot be negative.

Examples

use rug::{Assign, Integer, Rational};
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
let r_ref = r.fract_floor_ref();
let (mut fract, mut floor) = (Rational::new(), Integer::new());
(&mut fract, &mut floor).assign(r_ref);
assert_eq!(fract, (2, 17));
assert_eq!(floor, -6);

fn round(self) -> Integer

Rounds the number to the nearest integer and returns it as an Integer.

When the number lies exactly between two integers, it is rounded away from zero.

Examples

use rug::Rational;
// -3.5
let r1 = Rational::from((-35, 10));
let i1 = r1.round();
assert_eq!(i1, -4);
// 3.7
let r2 = Rational::from((37, 10));
let i2 = r2.round();
assert_eq!(i2, 4);

fn round_mut(&mut self)

Rounds the number to the nearest integer.

When the number lies exactly between two integers, it is rounded away from zero.

Examples

use rug::{Assign, Rational};
// -3.5
let mut r = Rational::from((-35, 10));
r.round_mut();
assert_eq!(r, -4);
// 3.7
r.assign((37, 10));
r.round_mut();
assert_eq!(r, 4);

fn round_ref(&self) -> RoundRef

Rounds the number to the nearest integer.

When the number lies exactly between two integers, it is rounded away from zero.

Examples

use rug::{Assign, Integer, Rational};
let mut round = Integer::new();
// -3.5
let r1 = Rational::from((-35, 10));
round.assign(r1.round_ref());
assert_eq!(round, -4);
// 3.7
let r2 = Rational::from((37, 10));
round.assign(r2.round_ref());
assert_eq!(round, 4);

fn rem_round(self) -> Self

Computes the remainder after rounding to the nearest integer.

Examples

use rug::Rational;
// -3.5 = -4 + 0.5 = -4 + 1/2
let r1 = Rational::from((-35, 10));
let rem1 = r1.rem_round();
assert_eq!(rem1, (1, 2));
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
let rem2 = r2.rem_round();
assert_eq!(rem2, (-3, 10));

fn rem_round_mut(&mut self)

Computes the remainder after rounding to the nearest integer.

Examples

use rug::Rational;
// -3.5 = -4 + 0.5 = -4 + 1/2
let mut r1 = Rational::from((-35, 10));
r1.rem_round_mut();
assert_eq!(r1, (1, 2));
// 3.7 = 4 - 0.3 = 4 - 3/10
let mut r2 = Rational::from((37, 10));
r2.rem_round_mut();
assert_eq!(r2, (-3, 10));

fn rem_round_ref(&self) -> RemRoundRef

Computes the remainder after rounding to the nearest integer.

Examples

use rug::Rational;
// -3.5 = -4 + 0.5 = -4 + 1/2
let r1 = Rational::from((-35, 10));
let r_ref1 = r1.rem_round_ref();
let rem1 = Rational::from(r_ref1);
assert_eq!(rem1, (1, 2));
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
let r_ref2 = r2.rem_round_ref();
let rem2 = Rational::from(r_ref2);
assert_eq!(rem2, (-3, 10));

fn fract_round(self, round: Integer) -> (Rational, Integer)

Computes the fractional and rounded parts of the number.

The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.

Examples

use rug::{Integer, Rational};
// -3.5 = -4 + 0.5 = -4 + 1/2
let r1 = Rational::from((-35, 10));
let (fract1, round1) = r1.fract_round(Integer::new());
assert_eq!(fract1, (1, 2));
assert_eq!(round1, -4);
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
let (fract2, round2) = r2.fract_round(Integer::new());
assert_eq!(fract2, (-3, 10));
assert_eq!(round2, 4);

fn fract_round_mut(&mut self, round: &mut Integer)

Computes the fractional and round parts of the number.

The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.

Examples

use rug::{Integer, Rational};
// -3.5 = -4 + 0.5 = -4 + 1/2
let mut r1 = Rational::from((-35, 10));
let mut round1 = Integer::new();
r1.fract_round_mut(&mut round1);
assert_eq!(r1, (1, 2));
assert_eq!(round1, -4);
// 3.7 = 4 - 0.3 = 4 - 3/10
let mut r2 = Rational::from((37, 10));
let mut round2 = Integer::new();
r2.fract_round_mut(&mut round2);
assert_eq!(r2, (-3, 10));
assert_eq!(round2, 4);

fn fract_round_ref(&self) -> FractRoundRef

Computes the fractional and round parts of the number.

The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.

Examples

use rug::{Assign, Integer, Rational};
// -3.5 = -4 + 0.5 = -4 + 1/2
let r1 = Rational::from((-35, 10));
let r_ref1 = r1.fract_round_ref();
let (mut fract1, mut round1) = (Rational::new(), Integer::new());
(&mut fract1, &mut round1).assign(r_ref1);
assert_eq!(fract1, (1, 2));
assert_eq!(round1, -4);
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
let r_ref2 = r2.fract_round_ref();
let (mut fract2, mut round2) = (Rational::new(), Integer::new());
(&mut fract2, &mut round2).assign(r_ref2);
assert_eq!(fract2, (-3, 10));
assert_eq!(round2, 4);

Trait Implementations

impl<'a> From<AbsRef<'a>> for Rational

fn from(t: AbsRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<AbsRef<'a>> for Rational

fn assign(&mut self, src: AbsRef<'a>)

Peforms the assignement.

impl<'a, Min, Max> From<ClampRef<'a, Min, Max>> for Rational where
    Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
    Min: 'a,
    Max: 'a, 

fn from(t: ClampRef<'a, Min, Max>) -> Rational

Performs the conversion.

impl<'a, Min, Max> Assign<ClampRef<'a, Min, Max>> for Rational where
    Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
    Min: 'a,
    Max: 'a, 

fn assign(&mut self, src: ClampRef<'a, Min, Max>)

Peforms the assignement.

impl<'a> From<RecipRef<'a>> for Rational

fn from(t: RecipRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<RecipRef<'a>> for Rational

fn assign(&mut self, src: RecipRef<'a>)

Peforms the assignement.

impl<'a> From<RemTruncRef<'a>> for Rational

fn from(t: RemTruncRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<RemTruncRef<'a>> for Rational

fn assign(&mut self, src: RemTruncRef<'a>)

Peforms the assignement.

impl<'a> From<RemCeilRef<'a>> for Rational

fn from(t: RemCeilRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<RemCeilRef<'a>> for Rational

fn assign(&mut self, src: RemCeilRef<'a>)

Peforms the assignement.

impl<'a> From<RemFloorRef<'a>> for Rational

fn from(t: RemFloorRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<RemFloorRef<'a>> for Rational

fn assign(&mut self, src: RemFloorRef<'a>)

Peforms the assignement.

impl<'a> From<RemRoundRef<'a>> for Rational

fn from(t: RemRoundRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<RemRoundRef<'a>> for Rational

fn assign(&mut self, src: RemRoundRef<'a>)

Peforms the assignement.

impl<'a> Assign<ValidRational<'a>> for Rational

fn assign(&mut self, rhs: ValidRational)

Peforms the assignement.

impl Neg for Rational

type Output = Rational

The resulting type after applying the - operator.

fn neg(self) -> Rational

Performs the unary - operation.

impl NegAssign for Rational

fn neg_assign(&mut self)

Peforms the negation.

impl<'a> Neg for &'a Rational

type Output = NegRef<'a>

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl<'a> From<NegRef<'a>> for Rational

fn from(t: NegRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<NegRef<'a>> for Rational

fn assign(&mut self, rhs: NegRef)

Peforms the assignement.

impl Add<Rational> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddRef<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Rational> for Rational

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

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

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

Performs the += operation.

impl AddFrom<Rational> for Rational

fn add_from(&mut self, lhs: Rational)

Peforms the addition.

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

fn add_from(&mut self, lhs: &'a Rational)

Peforms the addition.

impl<'a> From<AddRef<'a>> for Rational

fn from(t: AddRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<AddRef<'a>> for Rational

fn assign(&mut self, src: AddRef)

Peforms the assignement.

impl Sub<Rational> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> Rational

Performs the - operation.

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

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubRef<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubRef<'a>

Performs the - operation.

impl SubAssign<Rational> for Rational

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

impl<'a> SubAssign<&'a Rational> for Rational

fn sub_assign(&mut self, rhs: &'a Rational)

Performs the -= operation.

impl SubFrom<Rational> for Rational

fn sub_from(&mut self, lhs: Rational)

Peforms the subtraction.

impl<'a> SubFrom<&'a Rational> for Rational

fn sub_from(&mut self, lhs: &'a Rational)

Peforms the subtraction.

impl<'a> From<SubRef<'a>> for Rational

fn from(t: SubRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<SubRef<'a>> for Rational

fn assign(&mut self, src: SubRef)

Peforms the assignement.

impl Mul<Rational> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> Rational

Performs the * operation.

impl<'a> Mul<&'a Rational> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> Rational

Performs the * operation.

impl<'a> Mul<Rational> for &'a Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> Rational

Performs the * operation.

impl<'a> Mul<&'a Rational> for &'a Rational

type Output = MulRef<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulRef<'a>

Performs the * operation.

impl MulAssign<Rational> for Rational

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

impl<'a> MulAssign<&'a Rational> for Rational

fn mul_assign(&mut self, rhs: &'a Rational)

Performs the *= operation.

impl MulFrom<Rational> for Rational

fn mul_from(&mut self, lhs: Rational)

Peforms the multiplication.

impl<'a> MulFrom<&'a Rational> for Rational

fn mul_from(&mut self, lhs: &'a Rational)

Peforms the multiplication.

impl<'a> From<MulRef<'a>> for Rational

fn from(t: MulRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<MulRef<'a>> for Rational

fn assign(&mut self, src: MulRef)

Peforms the assignement.

impl Div<Rational> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> Rational

Performs the / operation.

impl<'a> Div<&'a Rational> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> Rational

Performs the / operation.

impl<'a> Div<Rational> for &'a Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> Rational

Performs the / operation.

impl<'a> Div<&'a Rational> for &'a Rational

type Output = DivRef<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivRef<'a>

Performs the / operation.

impl DivAssign<Rational> for Rational

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl<'a> DivAssign<&'a Rational> for Rational

fn div_assign(&mut self, rhs: &'a Rational)

Performs the /= operation.

impl DivFrom<Rational> for Rational

fn div_from(&mut self, lhs: Rational)

Peforms the division.

impl<'a> DivFrom<&'a Rational> for Rational

fn div_from(&mut self, lhs: &'a Rational)

Peforms the division.

impl<'a> From<DivRef<'a>> for Rational

fn from(t: DivRef<'a>) -> Self

Performs the conversion.

impl<'a> Assign<DivRef<'a>> for Rational

fn assign(&mut self, src: DivRef)

Peforms the assignement.

impl Shl<i32> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Rational

Performs the << operation.

impl<'t> Shl<&'t i32> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: &'t i32) -> Rational

Performs the << operation.

impl<'b> Shl<i32> for &'b Rational

type Output = ShlRefI32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlRefI32<'b>

Performs the << operation.

impl<'t, 'b> Shl<&'t i32> for &'b Rational

type Output = ShlRefI32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &'t i32) -> ShlRefI32<'b>

Performs the << operation.

impl ShlAssign<i32> for Rational

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<'t> ShlAssign<&'t i32> for Rational

fn shl_assign(&mut self, rhs: &'t i32)

Performs the <<= operation.

impl<'a> From<ShlRefI32<'a>> for Rational

fn from(t: ShlRefI32<'a>) -> Self

Performs the conversion.

impl<'a> Assign<ShlRefI32<'a>> for Rational

fn assign(&mut self, src: ShlRefI32)

Peforms the assignement.

impl Shr<i32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Rational

Performs the >> operation.

impl<'t> Shr<&'t i32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t i32) -> Rational

Performs the >> operation.

impl<'b> Shr<i32> for &'b Rational

type Output = ShrRefI32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrRefI32<'b>

Performs the >> operation.

impl<'t, 'b> Shr<&'t i32> for &'b Rational

type Output = ShrRefI32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t i32) -> ShrRefI32<'b>

Performs the >> operation.

impl ShrAssign<i32> for Rational

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<'t> ShrAssign<&'t i32> for Rational

fn shr_assign(&mut self, rhs: &'t i32)

Performs the >>= operation.

impl<'a> From<ShrRefI32<'a>> for Rational

fn from(t: ShrRefI32<'a>) -> Self

Performs the conversion.

impl<'a> Assign<ShrRefI32<'a>> for Rational

fn assign(&mut self, src: ShrRefI32)

Peforms the assignement.

impl Pow<i32> for Rational

type Output = Rational

The resulting type after the power operation.

fn pow(self, rhs: i32) -> Rational

Performs the power operation.

impl<'t> Pow<&'t i32> for Rational

type Output = Rational

The resulting type after the power operation.

fn pow(self, rhs: &'t i32) -> Rational

Performs the power operation.

impl<'b> Pow<i32> for &'b Rational

type Output = PowRefI32<'b>

The resulting type after the power operation.

fn pow(self, rhs: i32) -> PowRefI32<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t i32> for &'b Rational

type Output = PowRefI32<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t i32) -> PowRefI32<'b>

Performs the power operation.

impl PowAssign<i32> for Rational

fn pow_assign(&mut self, rhs: i32)

Peforms the power operation.

impl<'t> PowAssign<&'t i32> for Rational

fn pow_assign(&mut self, rhs: &'t i32)

Peforms the power operation.

impl<'a> From<PowRefI32<'a>> for Rational

fn from(t: PowRefI32<'a>) -> Self

Performs the conversion.

impl<'a> Assign<PowRefI32<'a>> for Rational

fn assign(&mut self, src: PowRefI32)

Peforms the assignement.

impl Shl<u32> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Rational

Performs the << operation.

impl<'t> Shl<&'t u32> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: &'t u32) -> Rational

Performs the << operation.

impl<'b> Shl<u32> for &'b Rational

type Output = ShlRefU32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlRefU32<'b>

Performs the << operation.

impl<'t, 'b> Shl<&'t u32> for &'b Rational

type Output = ShlRefU32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &'t u32) -> ShlRefU32<'b>

Performs the << operation.

impl ShlAssign<u32> for Rational

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<'t> ShlAssign<&'t u32> for Rational

fn shl_assign(&mut self, rhs: &'t u32)

Performs the <<= operation.

impl<'a> From<ShlRefU32<'a>> for Rational

fn from(t: ShlRefU32<'a>) -> Self

Performs the conversion.

impl<'a> Assign<ShlRefU32<'a>> for Rational

fn assign(&mut self, src: ShlRefU32)

Peforms the assignement.

impl Shr<u32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Rational

Performs the >> operation.

impl<'t> Shr<&'t u32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t u32) -> Rational

Performs the >> operation.

impl<'b> Shr<u32> for &'b Rational

type Output = ShrRefU32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrRefU32<'b>

Performs the >> operation.

impl<'t, 'b> Shr<&'t u32> for &'b Rational

type Output = ShrRefU32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t u32) -> ShrRefU32<'b>

Performs the >> operation.

impl ShrAssign<u32> for Rational

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<'t> ShrAssign<&'t u32> for Rational

fn shr_assign(&mut self, rhs: &'t u32)

Performs the >>= operation.

impl<'a> From<ShrRefU32<'a>> for Rational

fn from(t: ShrRefU32<'a>) -> Self

Performs the conversion.

impl<'a> Assign<ShrRefU32<'a>> for Rational

fn assign(&mut self, src: ShrRefU32)

Peforms the assignement.

impl Pow<u32> for Rational

type Output = Rational

The resulting type after the power operation.

fn pow(self, rhs: u32) -> Rational

Performs the power operation.

impl<'t> Pow<&'t u32> for Rational

type Output = Rational

The resulting type after the power operation.

fn pow(self, rhs: &'t u32) -> Rational

Performs the power operation.

impl<'b> Pow<u32> for &'b Rational

type Output = PowRefU32<'b>

The resulting type after the power operation.

fn pow(self, rhs: u32) -> PowRefU32<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t u32> for &'b Rational

type Output = PowRefU32<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t u32) -> PowRefU32<'b>

Performs the power operation.

impl PowAssign<u32> for Rational

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl<'t> PowAssign<&'t u32> for Rational

fn pow_assign(&mut self, rhs: &'t u32)

Peforms the power operation.

impl<'a> From<PowRefU32<'a>> for Rational

fn from(t: PowRefU32<'a>) -> Self

Performs the conversion.

impl<'a> Assign<PowRefU32<'a>> for Rational

fn assign(&mut self, src: PowRefU32)

Peforms the assignement.

impl Sum for Rational

fn sum<I>(iter: I) -> Rational where
    I: Iterator<Item = Rational>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a> Sum<&'a Rational> for Rational

fn sum<I>(iter: I) -> Rational where
    I: Iterator<Item = &'a Rational>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl Product for Rational

fn product<I>(iter: I) -> Rational where
    I: Iterator<Item = Rational>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a Rational> for Rational

fn product<I>(iter: I) -> Rational where
    I: Iterator<Item = &'a Rational>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Eq for Rational

impl Ord for Rational

fn cmp(&self, other: &Rational) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

impl PartialEq for Rational

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 for Rational

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<Integer> for Rational

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 Rational

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<i32> for Rational

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 Rational

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<u32> for Rational

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 Rational

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<i64> for Rational

fn eq(&self, other: &i64) -> 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<i64> for Rational

fn partial_cmp(&self, other: &i64) -> 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<u64> for Rational

fn eq(&self, other: &u64) -> 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<u64> for Rational

fn partial_cmp(&self, other: &u64) -> 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, i32)> for Rational

fn eq(&self, other: &(i32, 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, i32)> for Rational

fn partial_cmp(&self, other: &(i32, 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<(i64, i64)> for Rational

fn eq(&self, other: &(i64, i64)) -> 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<(i64, i64)> for Rational

fn partial_cmp(&self, other: &(i64, i64)) -> 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, u32)> for Rational

fn eq(&self, other: &(i32, 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<(i32, u32)> for Rational

fn partial_cmp(&self, other: &(i32, 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<(i64, u64)> for Rational

fn eq(&self, other: &(i64, u64)) -> 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<(i64, u64)> for Rational

fn partial_cmp(&self, other: &(i64, u64)) -> 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, i32)> for Rational

fn eq(&self, other: &(u32, 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<(u32, i32)> for Rational

fn partial_cmp(&self, other: &(u32, 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<(u64, i64)> for Rational

fn eq(&self, other: &(u64, i64)) -> 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<(u64, i64)> for Rational

fn partial_cmp(&self, other: &(u64, i64)) -> 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, u32)> for Rational

fn eq(&self, other: &(u32, 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, u32)> for Rational

fn partial_cmp(&self, other: &(u32, 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<(u64, u64)> for Rational

fn eq(&self, other: &(u64, u64)) -> 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<(u64, u64)> for Rational

fn partial_cmp(&self, other: &(u64, u64)) -> 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 Serialize for Rational

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Rational

fn deserialize<D>(deserializer: D) -> Result<Rational, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Default for Rational

fn default() -> Rational

Returns the "default value" for a type.

impl Clone for Rational

fn clone(&self) -> Rational

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Drop for Rational

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for Rational

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<'a> From<&'a Rational> for Rational

fn from(t: &'a Rational) -> Self

Performs the conversion.

impl<Num> From<Num> for Rational where
    Integer: From<Num>, 

fn from(num: Num) -> Rational

Performs the conversion.

impl<Num, Den> From<(Num, Den)> for Rational where
    Integer: From<Num> + From<Den>, 

fn from((num, den): (Num, Den)) -> Rational

Performs the conversion.

impl FromStr for Rational

type Err = ParseRationalError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Rational, ParseRationalError>

Parses a string s to return a value of this type.

impl Display for Rational

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

Formats the value using the given formatter.

impl Debug for Rational

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

Formats the value using the given formatter.

impl Binary for Rational

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

Formats the value using the given formatter.

impl Octal for Rational

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

Formats the value using the given formatter.

impl LowerHex for Rational

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

Formats the value using the given formatter.

impl UpperHex for Rational

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

Formats the value using the given formatter.

impl Assign for Rational

fn assign(&mut self, other: Rational)

Peforms the assignement.

impl<'a> Assign<&'a Rational> for Rational

fn assign(&mut self, other: &'a Rational)

Peforms the assignement.

impl<Num> Assign<Num> for Rational where
    Integer: Assign<Num>, 

fn assign(&mut self, rhs: Num)

Peforms the assignement.

impl<Num, Den> Assign<(Num, Den)> for Rational where
    Integer: Assign<Num> + Assign<Den>, 

fn assign(&mut self, rhs: (Num, Den))

Peforms the assignement.

impl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational where
    Integer: Assign<&'a Num> + Assign<&'a Den>, 

fn assign(&mut self, rhs: &'a (Num, Den))

Peforms the assignement.

impl<'a> From<ValidRational<'a>> for Rational

fn from(t: ValidRational<'a>) -> Self

Performs the conversion.

impl Send for Rational

impl Sync for Rational

impl Add<Float> for Rational

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 Rational

type Output = AddRefRationalOwn<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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 &'a Rational

type Output = AddRefRational<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Sub<Float> for Rational

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 Rational

type Output = SubFromRefRationalOwn<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubFromRefRationalOwn<'a>

Performs the - operation.

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

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 &'a Rational

type Output = SubRefRationalOwn<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubRefRationalOwn<'a>

Performs the - operation.

impl Mul<Float> for Rational

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 Rational

type Output = MulRefRationalOwn<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRefRationalOwn<'a>

Performs the * operation.

impl<'a> Mul<Float> for &'a Rational

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 &'a Rational

type Output = MulRefRational<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRefRational<'a>

Performs the * operation.

impl Div<Float> for Rational

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 Rational

type Output = DivFromRefRationalOwn<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivFromRefRationalOwn<'a>

Performs the / operation.

impl<'a> Div<Float> for &'a Rational

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 &'a Rational

type Output = DivRefRationalOwn<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivRefRationalOwn<'a>

Performs the / operation.

impl PartialEq<Float> for Rational

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<Float> for Rational

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: &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<Complex> for Rational

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 !=.