# 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]

#### `fn new() -> Rational`[src]

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>`[src]

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>`[src]

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>`[src]

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>`[src]

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`[src]

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)`[src]

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`[src]

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`[src]

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`[src]

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<(), ()>`[src]

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<(), ()>`[src]

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>`[src]

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>`[src]

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`[src]

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`[src]

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)`[src]

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`[src]

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)`[src]

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)`[src]

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`[src]

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`[src]

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`[src]

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 sign(&self) -> Ordering`[src]

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)).sign(), Ordering::Less);
assert_eq!(Rational::from(0).sign(), Ordering::Equal);
assert_eq!(Rational::from((5, 7)).sign(), Ordering::Greater);```

#### `fn abs(self) -> Rational`[src]

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)`[src]

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`[src]

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

#### `fn recip(self) -> Rational`[src]

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)`[src]

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`[src]

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

#### `fn ceil(self) -> Integer`[src]

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)`[src]

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`[src]

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 floor(self) -> Integer`[src]

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)`[src]

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`[src]

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 round(self) -> Integer`[src]

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)`[src]

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`[src]

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 trunc(self) -> Integer`[src]

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)`[src]

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`[src]

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`[src]

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

#### `fn fract_mut(&mut self)`[src]

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

#### `fn fract_ref(&self) -> FractRef`[src]

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

#### `fn fract_trunc(self, trunc: Integer) -> (Rational, Integer)`[src]

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)`[src]

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`[src]

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]

#### `fn default() -> Rational`[src]

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

### `impl Clone for Rational`[src]

#### `fn clone(&self) -> Rational`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Rational)`[src]

Performs copy-assignment from `source`. Read more

### `impl Drop for Rational`[src]

#### `fn drop(&mut self)`[src]

Executes the destructor for this type. Read more

### `impl Hash for Rational`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

Feeds this value into the given [`Hasher`]. Read more

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

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

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

#### `fn from(t: &'a Rational) -> Rational`[src]

Performs the conversion.

### `impl From<Integer> for Rational`[src]

#### `fn from(val: Integer) -> 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]

#### `fn from(t: &'a Integer) -> Rational`[src]

Performs the conversion.

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

#### `fn from((num, den): (Integer, Integer)) -> 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]

#### `fn from(t: (&'a Integer, &'a Integer)) -> Rational`[src]

Performs the conversion.

### `impl From<i32> for Rational`[src]

#### `fn from(t: i32) -> Rational`[src]

Performs the conversion.

### `impl From<i64> for Rational`[src]

#### `fn from(t: i64) -> Rational`[src]

Performs the conversion.

### `impl From<u32> for Rational`[src]

#### `fn from(t: u32) -> Rational`[src]

Performs the conversion.

### `impl From<u64> for Rational`[src]

#### `fn from(t: u64) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (i32, i32)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (i64, i64)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (i32, u32)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (i64, u64)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (u32, i32)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (u64, i64)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (u32, u32)) -> Rational`[src]

Performs the conversion.

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

#### `fn from(t: (u64, u64)) -> Rational`[src]

Performs the conversion.

### `impl FromStr for Rational`[src]

#### `type Err = ParseRationalError`

The associated error which can be returned from parsing.

#### `fn from_str(src: &str) -> Result<Rational, ParseRationalError>`[src]

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

### `impl Display for Rational`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl Debug for Rational`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter.

### `impl Binary for Rational`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter.

### `impl Octal for Rational`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter.

### `impl LowerHex for Rational`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter.

### `impl UpperHex for Rational`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter.

### `impl Assign for Rational`[src]

#### `fn assign(&mut self, other: Rational)`[src]

Peforms the assignement. Read more

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

#### `fn assign(&mut self, other: &'a Rational)`[src]

Peforms the assignement. Read more

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

#### `fn assign(&mut self, val: &'a Integer)`[src]

Peforms the assignement. Read more

### `impl Assign<Integer> for Rational`[src]

#### `fn assign(&mut self, t: Integer)`[src]

Peforms the assignement. Read more

### `impl Assign<i32> for Rational`[src]

#### `fn assign(&mut self, t: i32)`[src]

Peforms the assignement. Read more

### `impl Assign<i64> for Rational`[src]

#### `fn assign(&mut self, t: i64)`[src]

Peforms the assignement. Read more

### `impl Assign<u32> for Rational`[src]

#### `fn assign(&mut self, t: u32)`[src]

Peforms the assignement. Read more

### `impl Assign<u64> for Rational`[src]

#### `fn assign(&mut self, t: u64)`[src]

Peforms the assignement. Read more

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

#### `fn assign(&mut self, (num, den): (T, U))`[src]

Peforms the assignement. Read more

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

#### `fn from(t: AbsRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: AbsRef<'a>)`[src]

Peforms the assignement. Read more

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

#### `fn from(t: RecipRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: RecipRef<'a>)`[src]

Peforms the assignement. Read more

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

#### `fn from(t: FractRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: FractRef<'a>)`[src]

Peforms the assignement. Read more

### `impl Neg for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `-` operator.

#### `fn neg(self) -> Rational`[src]

Performs the unary `-` operation.

### `impl NegAssign for Rational`[src]

#### `fn neg_assign(&mut self)`[src]

Peforms the negation. Read more

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

#### `type Output = NegRef<'a>`

The resulting type after applying the `-` operator.

#### `fn neg(self) -> NegRef<'a>`[src]

Performs the unary `-` operation.

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

#### `fn from(t: NegRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, rhs: NegRef)`[src]

Peforms the assignement. Read more

### `impl Add<Rational> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: Rational) -> Rational`[src]

Performs the `+` operation.

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

#### `type Output = Rational`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: &'a Rational) -> Rational`[src]

Performs the `+` operation.

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

#### `type Output = Rational`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: Rational) -> Rational`[src]

Performs the `+` operation.

### `impl AddAssign<Rational> for Rational`[src]

#### `fn add_assign(&mut self, rhs: Rational)`[src]

Performs the `+=` operation.

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

#### `fn add_assign(&mut self, rhs: &'a Rational)`[src]

Performs the `+=` operation.

### `impl AddFrom<Rational> for Rational`[src]

#### `fn add_from(&mut self, lhs: Rational)`[src]

Peforms the addition. Read more

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

#### `fn add_from(&mut self, lhs: &'a Rational)`[src]

Peforms the addition. Read more

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

#### `type Output = AddRef<'a>`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: &'a Rational) -> AddRef<'a>`[src]

Performs the `+` operation.

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

#### `fn from(t: AddRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: AddRef)`[src]

Peforms the assignement. Read more

### `impl Sub<Rational> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: Rational) -> Rational`[src]

Performs the `-` operation.

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

#### `type Output = Rational`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: &'a Rational) -> Rational`[src]

Performs the `-` operation.

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

#### `type Output = Rational`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: Rational) -> Rational`[src]

Performs the `-` operation.

### `impl SubAssign<Rational> for Rational`[src]

#### `fn sub_assign(&mut self, rhs: Rational)`[src]

Performs the `-=` operation.

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

#### `fn sub_assign(&mut self, rhs: &'a Rational)`[src]

Performs the `-=` operation.

### `impl SubFrom<Rational> for Rational`[src]

#### `fn sub_from(&mut self, lhs: Rational)`[src]

Peforms the subtraction. Read more

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

#### `fn sub_from(&mut self, lhs: &'a Rational)`[src]

Peforms the subtraction. Read more

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

#### `type Output = SubRef<'a>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: &'a Rational) -> SubRef<'a>`[src]

Performs the `-` operation.

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

#### `fn from(t: SubRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: SubRef)`[src]

Peforms the assignement. Read more

### `impl Mul<Rational> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Rational) -> Rational`[src]

Performs the `*` operation.

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

#### `type Output = Rational`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'a Rational) -> Rational`[src]

Performs the `*` operation.

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

#### `type Output = Rational`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Rational) -> Rational`[src]

Performs the `*` operation.

### `impl MulAssign<Rational> for Rational`[src]

#### `fn mul_assign(&mut self, rhs: Rational)`[src]

Performs the `*=` operation.

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

#### `fn mul_assign(&mut self, rhs: &'a Rational)`[src]

Performs the `*=` operation.

### `impl MulFrom<Rational> for Rational`[src]

#### `fn mul_from(&mut self, lhs: Rational)`[src]

Peforms the multiplication. Read more

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

#### `fn mul_from(&mut self, lhs: &'a Rational)`[src]

Peforms the multiplication. Read more

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

#### `type Output = MulRef<'a>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'a Rational) -> MulRef<'a>`[src]

Performs the `*` operation.

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

#### `fn from(t: MulRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: MulRef)`[src]

Peforms the assignement. Read more

### `impl Div<Rational> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Rational) -> Rational`[src]

Performs the `/` operation.

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

#### `type Output = Rational`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'a Rational) -> Rational`[src]

Performs the `/` operation.

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

#### `type Output = Rational`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Rational) -> Rational`[src]

Performs the `/` operation.

### `impl DivAssign<Rational> for Rational`[src]

#### `fn div_assign(&mut self, rhs: Rational)`[src]

Performs the `/=` operation.

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

#### `fn div_assign(&mut self, rhs: &'a Rational)`[src]

Performs the `/=` operation.

### `impl DivFrom<Rational> for Rational`[src]

#### `fn div_from(&mut self, lhs: Rational)`[src]

Peforms the division. Read more

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

#### `fn div_from(&mut self, lhs: &'a Rational)`[src]

Peforms the division. Read more

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

#### `type Output = DivRef<'a>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'a Rational) -> DivRef<'a>`[src]

Performs the `/` operation.

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

#### `fn from(t: DivRef<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: DivRef)`[src]

Peforms the assignement. Read more

### `impl Shl<i32> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `<<` operator.

#### `fn shl(self, rhs: i32) -> Rational`[src]

Performs the `<<` operation.

### `impl ShlAssign<i32> for Rational`[src]

#### `fn shl_assign(&mut self, rhs: i32)`[src]

Performs the `<<=` operation.

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

#### `type Output = ShlRefI32<'a>`

The resulting type after applying the `<<` operator.

#### `fn shl(self, rhs: i32) -> ShlRefI32<'a>`[src]

Performs the `<<` operation.

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

#### `fn from(t: ShlRefI32<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: ShlRefI32)`[src]

Peforms the assignement. Read more

### `impl Shr<i32> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `>>` operator.

#### `fn shr(self, rhs: i32) -> Rational`[src]

Performs the `>>` operation.

### `impl ShrAssign<i32> for Rational`[src]

#### `fn shr_assign(&mut self, rhs: i32)`[src]

Performs the `>>=` operation.

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

#### `type Output = ShrRefI32<'a>`

The resulting type after applying the `>>` operator.

#### `fn shr(self, rhs: i32) -> ShrRefI32<'a>`[src]

Performs the `>>` operation.

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

#### `fn from(t: ShrRefI32<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: ShrRefI32)`[src]

Peforms the assignement. Read more

### `impl Pow<i32> for Rational`[src]

#### `type Output = Rational`

The resulting type after the power operation.

#### `fn pow(self, rhs: i32) -> Rational`[src]

Performs the power operation. Read more

### `impl PowAssign<i32> for Rational`[src]

#### `fn pow_assign(&mut self, rhs: i32)`[src]

Peforms the power operation. Read more

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

#### `type Output = PowRefI32<'a>`

The resulting type after the power operation.

#### `fn pow(self, rhs: i32) -> PowRefI32<'a>`[src]

Performs the power operation. Read more

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

#### `fn from(t: PowRefI32<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: PowRefI32)`[src]

Peforms the assignement. Read more

### `impl Shl<u32> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `<<` operator.

#### `fn shl(self, rhs: u32) -> Rational`[src]

Performs the `<<` operation.

### `impl ShlAssign<u32> for Rational`[src]

#### `fn shl_assign(&mut self, rhs: u32)`[src]

Performs the `<<=` operation.

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

#### `type Output = ShlRefU32<'a>`

The resulting type after applying the `<<` operator.

#### `fn shl(self, rhs: u32) -> ShlRefU32<'a>`[src]

Performs the `<<` operation.

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

#### `fn from(t: ShlRefU32<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: ShlRefU32)`[src]

Peforms the assignement. Read more

### `impl Shr<u32> for Rational`[src]

#### `type Output = Rational`

The resulting type after applying the `>>` operator.

#### `fn shr(self, rhs: u32) -> Rational`[src]

Performs the `>>` operation.

### `impl ShrAssign<u32> for Rational`[src]

#### `fn shr_assign(&mut self, rhs: u32)`[src]

Performs the `>>=` operation.

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

#### `type Output = ShrRefU32<'a>`

The resulting type after applying the `>>` operator.

#### `fn shr(self, rhs: u32) -> ShrRefU32<'a>`[src]

Performs the `>>` operation.

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

#### `fn from(t: ShrRefU32<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: ShrRefU32)`[src]

Peforms the assignement. Read more

### `impl Pow<u32> for Rational`[src]

#### `type Output = Rational`

The resulting type after the power operation.

#### `fn pow(self, rhs: u32) -> Rational`[src]

Performs the power operation. Read more

### `impl PowAssign<u32> for Rational`[src]

#### `fn pow_assign(&mut self, rhs: u32)`[src]

Peforms the power operation. Read more

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

#### `type Output = PowRefU32<'a>`

The resulting type after the power operation.

#### `fn pow(self, rhs: u32) -> PowRefU32<'a>`[src]

Performs the power operation. Read more

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

#### `fn from(t: PowRefU32<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, src: PowRefU32)`[src]

Peforms the assignement. Read more

### `impl Ord for Rational`[src]

#### `fn cmp(&self, other: &Rational) -> Ordering`[src]

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

#### `fn max(self, other: Self) -> Self`1.22.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self`1.22.0[src]

Compares and returns the minimum of two values. Read more

### `impl PartialEq for Rational`[src]

#### `fn eq(&self, other: &Rational) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd for Rational`[src]

#### `fn partial_cmp(&self, other: &Rational) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &Integer) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd<Integer> for Rational`[src]

#### `fn partial_cmp(&self, other: &Integer) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &i32) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd<i32> for Rational`[src]

#### `fn partial_cmp(&self, other: &i32) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &u32) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd<u32> for Rational`[src]

#### `fn partial_cmp(&self, other: &u32) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &i64) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd<i64> for Rational`[src]

#### `fn partial_cmp(&self, other: &i64) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &u64) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd<u64> for Rational`[src]

#### `fn partial_cmp(&self, other: &u64) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(i32, i32)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(i32, i32)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(i64, i64)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(i64, i64)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(i32, u32)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(i32, u32)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(i64, u64)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(i64, u64)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(u32, i32)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(u32, i32)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(u64, i64)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(u64, i64)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(u32, u32)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(u32, u32)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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]

#### `fn eq(&self, other: &(u64, u64)) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

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

#### `fn partial_cmp(&self, other: &(u64, u64)) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

### `impl Sum for Rational`[src]

#### `fn sum<I>(iter: I) -> Rational where    I: Iterator<Item = Rational>, `[src]

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

### `impl<'a> Sum<&'a Rational> for Rational`[src]

#### `fn sum<I>(iter: I) -> Rational where    I: Iterator<Item = &'a Rational>, `[src]

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

### `impl Product for Rational`[src]

#### `fn product<I>(iter: I) -> Rational where    I: Iterator<Item = Rational>, `[src]

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

### `impl<'a> Product<&'a Rational> for Rational`[src]

#### `fn product<I>(iter: I) -> Rational where    I: Iterator<Item = &'a Rational>, `[src]

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

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

#### `fn from(t: ValidRational<'a>) -> Rational`[src]

Performs the conversion.

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

#### `fn assign(&mut self, rhs: ValidRational)`[src]

Peforms the assignement. Read more

### `impl Add<Float> for Rational`[src]

#### `type Output = Float`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: Float) -> Float`[src]

Performs the `+` operation.

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

#### `type Output = Float`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: Float) -> Float`[src]

Performs the `+` operation.

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

#### `type Output = AddRefRationalOwn<'a>`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: &'a Float) -> AddRefRationalOwn<'a>`[src]

Performs the `+` operation.

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

#### `type Output = AddRefRational<'a>`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: &'a Float) -> AddRefRational<'a>`[src]

Performs the `+` operation.

### `impl Sub<Float> for Rational`[src]

#### `type Output = Float`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: Float) -> Float`[src]

Performs the `-` operation.

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

#### `type Output = Float`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: Float) -> Float`[src]

Performs the `-` operation.

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

#### `type Output = SubFromRefRationalOwn<'a>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: &'a Float) -> SubFromRefRationalOwn<'a>`[src]

Performs the `-` operation.

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

#### `type Output = SubRefRationalOwn<'a>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: &'a Float) -> SubRefRationalOwn<'a>`[src]

Performs the `-` operation.

### `impl Mul<Float> for Rational`[src]

#### `type Output = Float`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Float) -> Float`[src]

Performs the `*` operation.

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

#### `type Output = Float`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Float) -> Float`[src]

Performs the `*` operation.

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

#### `type Output = MulRefRationalOwn<'a>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'a Float) -> MulRefRationalOwn<'a>`[src]

Performs the `*` operation.

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

#### `type Output = MulRefRational<'a>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'a Float) -> MulRefRational<'a>`[src]

Performs the `*` operation.

### `impl Div<Float> for Rational`[src]

#### `type Output = Float`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Float) -> Float`[src]

Performs the `/` operation.

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

#### `type Output = Float`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Float) -> Float`[src]

Performs the `/` operation.

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

#### `type Output = DivFromRefRationalOwn<'a>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'a Float) -> DivFromRefRationalOwn<'a>`[src]

Performs the `/` operation.

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

#### `type Output = DivRefRationalOwn<'a>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'a Float) -> DivRefRationalOwn<'a>`[src]

Performs the `/` operation.

### `impl PartialEq<Float> for Rational`[src]

#### `fn eq(&self, other: &Float) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl PartialOrd<Float> for Rational`[src]

#### `fn partial_cmp(&self, other: &Float) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

### `impl PartialEq<Complex> for Rational`[src]

#### `fn eq(&self, other: &Complex) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.