Struct rug::Rational [] [src]

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

Methods

impl Rational
[src]

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

Examples

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

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

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

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.

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 numberator 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.

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

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

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

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

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.

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

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

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

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.

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)

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

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

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.

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

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

Returns Ordering::Less if the number is less than zero, Ordering::Greater if it is greater than zero, or Ordering::Equal if it is equal to zero.

Computes the absolute value.

Examples

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

Computes the absolute value.

Examples

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

Computes the absolute value.

Examples

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

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.

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.

Computes the reciprocal.

Examples

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

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

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

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

Rounds the number downwards (towards minus infinity).

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

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

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

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

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

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

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

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

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

Computes the fractional part of the number.

Examples

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

Computes the fractional part of the number.

Examples

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

Computes the fractional part of the number.

Examples

use rug::Rational;
let r = Rational::from((-100, 17));
let rr = r.fract_ref();
let fract = Rational::from(rr);
assert_eq!(fract, (-15, 17));

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

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

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

Trait Implementations

impl Default for Rational
[src]

Returns the "default value" for a type. Read more

impl Clone for Rational
[src]

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

impl Drop for Rational
[src]

A method called when the value goes out of scope. Read more

impl<'a> From<&'a Rational> for Rational
[src]

Performs the conversion.

impl From<Integer> for Rational
[src]

Constructs a Rational number from an Integer.

This constructor allocates one new Integer and reuses the allocation for val.

impl<'a> From<&'a Integer> for Rational
[src]

Performs the conversion.

impl From<(Integer, Integer)> for Rational
[src]

Constructs a Rational number from a numerator Integer and denominator Integer.

This constructor does not allocate, as it reuses the Integer components.

Panics

Panics if the denominator is zero.

impl<'a> From<(&'a Integer, &'a Integer)> for Rational
[src]

Performs the conversion.

impl From<i32> for Rational
[src]

Performs the conversion.

impl From<i64> for Rational
[src]

Performs the conversion.

impl From<u32> for Rational
[src]

Performs the conversion.

impl From<u64> for Rational
[src]

Performs the conversion.

impl From<(i32, i32)> for Rational
[src]

Performs the conversion.

impl From<(i64, i64)> for Rational
[src]

Performs the conversion.

impl From<(i32, u32)> for Rational
[src]

Performs the conversion.

impl From<(i64, u64)> for Rational
[src]

Performs the conversion.

impl From<(u32, i32)> for Rational
[src]

Performs the conversion.

impl From<(u64, i64)> for Rational
[src]

Performs the conversion.

impl From<(u32, u32)> for Rational
[src]

Performs the conversion.

impl From<(u64, u64)> for Rational
[src]

Performs the conversion.

impl FromStr for Rational
[src]

The associated error which can be returned from parsing.

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

impl Display for Rational
[src]

Formats the value using the given formatter. Read more

impl Debug for Rational
[src]

Formats the value using the given formatter.

impl Binary for Rational
[src]

Formats the value using the given formatter.

impl Octal for Rational
[src]

Formats the value using the given formatter.

impl LowerHex for Rational
[src]

Formats the value using the given formatter.

impl UpperHex for Rational
[src]

Formats the value using the given formatter.

impl Assign for Rational
[src]

Peforms the assignement. Read more

impl<'a> Assign<&'a Rational> for Rational
[src]

Peforms the assignement. Read more

impl<'a> Assign<&'a Integer> for Rational
[src]

Peforms the assignement. Read more

impl Assign<Integer> for Rational
[src]

Peforms the assignement. Read more

impl Assign<i32> for Rational
[src]

Peforms the assignement. Read more

impl Assign<i64> for Rational
[src]

Peforms the assignement. Read more

impl Assign<u32> for Rational
[src]

Peforms the assignement. Read more

impl Assign<u64> for Rational
[src]

Peforms the assignement. Read more

impl<T, U> Assign<(T, U)> for Rational where
    Integer: Assign<T>,
    Integer: Assign<U>, 
[src]

Peforms the assignement. Read more

impl<'a> From<AbsRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<AbsRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl<'a> From<RecipRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<RecipRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl<'a> From<FractRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<FractRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Neg for Rational
[src]

The resulting type after applying the - operator

The method for the unary - operator

impl NegAssign for Rational
[src]

Peforms the negation. Read more

impl<'a> Neg for &'a Rational
[src]

The resulting type after applying the - operator

The method for the unary - operator

impl<'a> From<NegRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<NegRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Add<Rational> for Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl<'a> Add<&'a Rational> for Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl<'a> Add<Rational> for &'a Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl AddAssign<Rational> for Rational
[src]

The method for the += operator

impl<'a> AddAssign<&'a Rational> for Rational
[src]

The method for the += operator

impl AddFrom<Rational> for Rational
[src]

Peforms the addition. Read more

impl<'a> AddFrom<&'a Rational> for Rational
[src]

Peforms the addition. Read more

impl<'a> Add<&'a Rational> for &'a Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl<'a> From<AddRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<AddRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Sub<Rational> for Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl<'a> Sub<&'a Rational> for Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl<'a> Sub<Rational> for &'a Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl SubAssign<Rational> for Rational
[src]

The method for the -= operator

impl<'a> SubAssign<&'a Rational> for Rational
[src]

The method for the -= operator

impl SubFrom<Rational> for Rational
[src]

Peforms the subtraction. Read more

impl<'a> SubFrom<&'a Rational> for Rational
[src]

Peforms the subtraction. Read more

impl<'a> Sub<&'a Rational> for &'a Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl<'a> From<SubRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<SubRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Mul<Rational> for Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl<'a> Mul<&'a Rational> for Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl<'a> Mul<Rational> for &'a Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl MulAssign<Rational> for Rational
[src]

The method for the *= operator

impl<'a> MulAssign<&'a Rational> for Rational
[src]

The method for the *= operator

impl MulFrom<Rational> for Rational
[src]

Peforms the multiplication. Read more

impl<'a> MulFrom<&'a Rational> for Rational
[src]

Peforms the multiplication. Read more

impl<'a> Mul<&'a Rational> for &'a Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl<'a> From<MulRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<MulRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Div<Rational> for Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl<'a> Div<&'a Rational> for Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl<'a> Div<Rational> for &'a Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl DivAssign<Rational> for Rational
[src]

The method for the /= operator

impl<'a> DivAssign<&'a Rational> for Rational
[src]

The method for the /= operator

impl DivFrom<Rational> for Rational
[src]

Peforms the division. Read more

impl<'a> DivFrom<&'a Rational> for Rational
[src]

Peforms the division. Read more

impl<'a> Div<&'a Rational> for &'a Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl<'a> From<DivRef<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<DivRef<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Shl<i32> for Rational
[src]

The resulting type after applying the << operator

The method for the << operator

impl ShlAssign<i32> for Rational
[src]

The method for the <<= operator

impl<'a> Shl<i32> for &'a Rational
[src]

The resulting type after applying the << operator

The method for the << operator

impl<'a> From<ShlRefI32<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<ShlRefI32<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Shr<i32> for Rational
[src]

The resulting type after applying the >> operator

The method for the >> operator

impl ShrAssign<i32> for Rational
[src]

The method for the >>= operator

impl<'a> Shr<i32> for &'a Rational
[src]

The resulting type after applying the >> operator

The method for the >> operator

impl<'a> From<ShrRefI32<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<ShrRefI32<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Pow<i32> for Rational
[src]

The resulting type after the power operation.

Performs the power operation. Read more

impl PowAssign<i32> for Rational
[src]

Peforms the power operation. Read more

impl<'a> Pow<i32> for &'a Rational
[src]

The resulting type after the power operation.

Performs the power operation. Read more

impl<'a> From<PowRefI32<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<PowRefI32<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Shl<u32> for Rational
[src]

The resulting type after applying the << operator

The method for the << operator

impl ShlAssign<u32> for Rational
[src]

The method for the <<= operator

impl<'a> Shl<u32> for &'a Rational
[src]

The resulting type after applying the << operator

The method for the << operator

impl<'a> From<ShlRefU32<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<ShlRefU32<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Shr<u32> for Rational
[src]

The resulting type after applying the >> operator

The method for the >> operator

impl ShrAssign<u32> for Rational
[src]

The method for the >>= operator

impl<'a> Shr<u32> for &'a Rational
[src]

The resulting type after applying the >> operator

The method for the >> operator

impl<'a> From<ShrRefU32<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<ShrRefU32<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Pow<u32> for Rational
[src]

The resulting type after the power operation.

Performs the power operation. Read more

impl PowAssign<u32> for Rational
[src]

Peforms the power operation. Read more

impl<'a> Pow<u32> for &'a Rational
[src]

The resulting type after the power operation.

Performs the power operation. Read more

impl<'a> From<PowRefU32<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<PowRefU32<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Eq for Rational
[src]

impl Ord for Rational
[src]

This method returns an Ordering between self and other. Read more

impl PartialEq for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<Integer> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<Integer> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<i32> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<i32> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<u32> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<u32> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<i64> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<i64> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<u64> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<u64> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(i32, i32)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(i32, i32)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(i64, i64)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(i64, i64)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(i32, u32)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(i32, u32)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(i64, u64)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(i64, u64)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(u32, i32)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(u32, i32)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(u64, i64)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(u64, i64)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(u32, u32)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(u32, u32)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl PartialEq<(u64, u64)> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<(u64, u64)> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl<'a> From<ValidRational<'a>> for Rational
[src]

Performs the conversion.

impl<'a> Assign<ValidRational<'a>> for Rational
[src]

Peforms the assignement. Read more

impl Send for Rational
[src]

impl Sync for Rational
[src]

impl Add<Float> for Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl<'a> Add<Float> for &'a Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl<'a> Add<&'a Float> for Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl<'a> Add<&'a Float> for &'a Rational
[src]

The resulting type after applying the + operator

The method for the + operator

impl Sub<Float> for Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl<'a> Sub<Float> for &'a Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl<'a> Sub<&'a Float> for Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl<'a> Sub<&'a Float> for &'a Rational
[src]

The resulting type after applying the - operator

The method for the - operator

impl Mul<Float> for Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl<'a> Mul<Float> for &'a Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl<'a> Mul<&'a Float> for Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl<'a> Mul<&'a Float> for &'a Rational
[src]

The resulting type after applying the * operator

The method for the * operator

impl Div<Float> for Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl<'a> Div<Float> for &'a Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl<'a> Div<&'a Float> for Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl<'a> Div<&'a Float> for &'a Rational
[src]

The resulting type after applying the / operator

The method for the / operator

impl PartialEq<Float> for Rational
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl PartialOrd<Float> for Rational
[src]

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more