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

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

# Examples

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

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

Creates a `Rational`

from an `f32`

if it is finite, losing no
precision.

# Examples

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

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

Creates a `Rational`

from an `f64`

if it is finite, losing no
precision.

# Examples

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

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

Parses a `Rational`

number.

# Examples

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

# Panics

Panics if `radix`

is less than 2 or greater than 36.

`fn valid_str_radix(`

src: &str,

radix: i32

) -> Result<ValidRational, ParseRationalError>

src: &str,

radix: i32

) -> Result<ValidRational, ParseRationalError>

Checks if a `Rational`

number can be parsed.

If this method does not return an error, neither will any
other function that parses a `Rational`

number. If this method
returns an error, the other functions will return the same
error.

The string must contain a numerator, and may contain a
denominator; the 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.

`fn to_integer(&self) -> Integer`

Converts to an `Integer`

, rounding
towards zero.

# Examples

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

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

Converts to an `Integer`

inside `i`

,
rounding towards zero.

# Examples

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

`fn to_f32(&self) -> f32`

Converts to an `f32`

, rounding towards zero.

# Examples

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

`fn to_f64(&self) -> f64`

Converts to an `f64`

, rounding towards zero.

# Examples

use rug::Rational; use rug::rational::SmallRational; use std::f64; // An `f64` has 53 bits of precision. let exact = 0x1f_1234_5678_9aff_u64; let den = 0x1000_u64; let r = Rational::from((exact, den)); assert_eq!(r.to_f64(), exact as f64 / den as f64); // large has 56 ones let large = 0xff_1234_5678_9aff_u64; // trunc has 53 ones followed by 3 zeros let trunc = 0xff_1234_5678_9af8_u64; let j = Rational::from((large, den)); assert_eq!(j.to_f64(), trunc as f64 / den as f64); let max = Rational::from_f64(f64::MAX).unwrap(); let plus_small = max + &*SmallRational::from((7, 2)); // plus_small is truncated to f64::MAX assert_eq!(plus_small.to_f64(), f64::MAX); let times_three_two = plus_small * &*SmallRational::from((3, 2)); // times_three_two is too large assert_eq!(times_three_two.to_f64(), f64::INFINITY);

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

Returns a string representation for the specified `radix`

.

# Examples

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

# Panics

Panics if `radix`

is less than 2 or greater than 36.

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

Assigns from an `f32`

if it is finite, losing no precision.

# Examples

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

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

Assigns from an `f64`

if it is finite, losing no precision.

# Examples

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

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

Parses a `Rational`

number from a string.

# Examples

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

`fn assign_str_radix(`

&mut self,

src: &str,

radix: i32

) -> Result<(), ParseRationalError>

&mut self,

src: &str,

radix: i32

) -> Result<(), ParseRationalError>

Parses a `Rational`

number from a string with the specified
radix.

# Examples

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

# Panics

Panics if `radix`

is less than 2 or greater than 36.

`fn numer(&self) -> &Integer`

Borrows the numerator as an `Integer`

.

# Examples

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

`fn denom(&self) -> &Integer`

Borrows the denominator as an
`Integer`

.

# Examples

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

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

Borrows the numerator and denominator as
`Integer`

values.

# Examples

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

`fn as_mut_numer_denom(&mut self) -> MutNumerDenom`

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

# Examples

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

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

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

# Panics

Panics if the denominator is zero when the borrow ends.

`unsafe fn as_mut_numer_denom_no_canonicalization(`

&mut self

) -> (&mut Integer, &mut Integer)

&mut self

) -> (&mut Integer, &mut Integer)

Borrows the numerator and denominator mutably without canonicalizing aftwerwards.

# Safety

This function is unsafe because it does not canonicalize the
rational number when the borrow ends. The rest of the library
assumes that `Rational`

structures keep their numerators and
denominators canonicalized.

# Examples

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

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

Converts into numerator and denominator integers.

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

# Examples

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

`fn sign(&self) -> Ordering`

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.

`fn abs(self) -> Rational`

Computes the absolute value.

# Examples

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

`fn abs_mut(&mut self)`

Computes the absolute value.

# Examples

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

`fn abs_ref(&self) -> AbsRef`

Computes the absolute value.

# Examples

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

`fn recip(self) -> Rational`

Computes the reciprocal.

# Examples

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

# Panics

Panics if the value is zero.

`fn recip_mut(&mut self)`

Computes the reciprocal.

# Examples

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

# Panics

Panics if the value is zero.

`fn recip_ref(&self) -> RecipRef`

Computes the reciprocal.

# Examples

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

`fn ceil(self) -> Integer`

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

.

# Examples

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

`fn ceil_mut(&mut self)`

Rounds the number upwards (towards plus infinity).

# Examples

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

`fn ceil_ref(&self) -> CeilRef`

Rounds the number upwards (towards plus infinity).

# Examples

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

`fn floor(self) -> Integer`

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

`fn floor_mut(&mut self)`

Rounds the number downwards (towards minus infinity).

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

`fn floor_ref(&self) -> FloorRef`

Rounds the number downwards (towards minus infinity).

# Examples

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

`fn round(self) -> Integer`

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

.

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

# Examples

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

`fn round_mut(&mut self)`

Rounds the number to the nearest integer.

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

# Examples

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

`fn round_ref(&self) -> RoundRef`

Rounds the number to the nearest integer.

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

# Examples

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

`fn trunc(self) -> Integer`

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

.

# Examples

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

`fn trunc_mut(&mut self)`

Rounds the number towards zero.

# Examples

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

`fn trunc_ref(&self) -> TruncRef`

Rounds the number towards zero.

# Examples

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

`fn fract(self) -> Rational`

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

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`

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

Computes the fractional and truncated parts of the number.

The initial value of `trunc`

is ignored.

# Examples

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

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

Computes the fractional and truncated parts of the number.

The initial value of `trunc`

is ignored.

# Examples

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

`fn fract_trunc_ref(&self) -> FractTruncRef`

Computes the fractional and truncated parts of the number.

# Examples

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

## Trait Implementations

`impl Default for Rational`

[src]

`impl Clone for Rational`

[src]

`fn clone(&self) -> Rational`

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`

. Read more

`impl Drop for Rational`

[src]

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

[src]

`impl From<Integer> for Rational`

[src]

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

[src]

`impl From<(Integer, Integer)> for Rational`

[src]

`impl<'a> From<(&'a Integer, &'a Integer)> for Rational`

[src]

`impl From<i32> for Rational`

[src]

`impl From<i64> for Rational`

[src]

`impl From<u32> for Rational`

[src]

`impl From<u64> for Rational`

[src]

`impl From<(i32, i32)> for Rational`

[src]

`impl From<(i64, i64)> for Rational`

[src]

`impl From<(i32, u32)> for Rational`

[src]

`impl From<(i64, u64)> for Rational`

[src]

`impl From<(u32, i32)> for Rational`

[src]

`impl From<(u64, i64)> for Rational`

[src]

`impl From<(u32, u32)> for Rational`

[src]

`impl From<(u64, u64)> for Rational`

[src]

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

Parses a string `s`

to return a value of this type. Read more

`impl Display for Rational`

[src]

`impl Debug for Rational`

[src]

`impl Binary for Rational`

[src]

`impl Octal for Rational`

[src]

`impl LowerHex for Rational`

[src]

`impl UpperHex for Rational`

[src]

`impl Assign for Rational`

[src]

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

[src]

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

[src]

`impl Assign<Integer> for Rational`

[src]

`impl Assign<i32> for Rational`

[src]

`impl Assign<i64> for Rational`

[src]

`impl Assign<u32> for Rational`

[src]

`impl Assign<u64> for Rational`

[src]

`impl<T, U> Assign<(T, U)> for Rational where`

Integer: Assign<T>,

Integer: Assign<U>,

[src]

Integer: Assign<T>,

Integer: Assign<U>,

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

[src]

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

[src]

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

[src]

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

[src]

`impl<'a> From<FractRef<'a>> for Rational`

[src]

`impl<'a> Assign<FractRef<'a>> for Rational`

[src]

`impl Neg for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator

`fn neg(self) -> Rational`

The method for the unary `-`

operator

`impl NegAssign for Rational`

[src]

`fn neg_assign(&mut self)`

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

The method for the unary `-`

operator

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

[src]

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

[src]

`impl Add<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

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

The method for the `+`

operator

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

[src]

`type Output = Rational`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl AddAssign<Rational> for Rational`

[src]

`fn add_assign(&mut self, rhs: Rational)`

The method for the `+=`

operator

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

[src]

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

The method for the `+=`

operator

`impl AddFrom<Rational> for Rational`

[src]

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

[src]

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

The method for the `+`

operator

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

[src]

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

[src]

`impl Sub<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

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

The method for the `-`

operator

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

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl SubAssign<Rational> for Rational`

[src]

`fn sub_assign(&mut self, rhs: Rational)`

The method for the `-=`

operator

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

[src]

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

The method for the `-=`

operator

`impl SubFrom<Rational> for Rational`

[src]

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

[src]

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

The method for the `-`

operator

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

[src]

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

[src]

`impl Mul<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

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

The method for the `*`

operator

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

[src]

`type Output = Rational`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl MulAssign<Rational> for Rational`

[src]

`fn mul_assign(&mut self, rhs: Rational)`

The method for the `*=`

operator

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

[src]

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

The method for the `*=`

operator

`impl MulFrom<Rational> for Rational`

[src]

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

[src]

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

The method for the `*`

operator

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

[src]

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

[src]

`impl Div<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

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

The method for the `/`

operator

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

[src]

`type Output = Rational`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl DivAssign<Rational> for Rational`

[src]

`fn div_assign(&mut self, rhs: Rational)`

The method for the `/=`

operator

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

[src]

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

The method for the `/=`

operator

`impl DivFrom<Rational> for Rational`

[src]

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

[src]

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

The method for the `/`

operator

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

[src]

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

[src]

`impl Shl<i32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `<<`

operator

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

The method for the `<<`

operator

`impl ShlAssign<i32> for Rational`

[src]

`fn shl_assign(&mut self, rhs: i32)`

The method for the `<<=`

operator

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

The method for the `<<`

operator

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

[src]

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

[src]

`impl Shr<i32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `>>`

operator

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

The method for the `>>`

operator

`impl ShrAssign<i32> for Rational`

[src]

`fn shr_assign(&mut self, rhs: i32)`

The method for the `>>=`

operator

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

The method for the `>>`

operator

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

[src]

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

[src]

`impl Pow<i32> for Rational`

[src]

`type Output = Rational`

The resulting type after the power operation.

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

Performs the power operation. Read more

`impl PowAssign<i32> for Rational`

[src]

`fn pow_assign(&mut self, rhs: i32)`

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

Performs the power operation. Read more

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

[src]

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

[src]

`impl Shl<u32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `<<`

operator

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

The method for the `<<`

operator

`impl ShlAssign<u32> for Rational`

[src]

`fn shl_assign(&mut self, rhs: u32)`

The method for the `<<=`

operator

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

The method for the `<<`

operator

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

[src]

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

[src]

`impl Shr<u32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `>>`

operator

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

The method for the `>>`

operator

`impl ShrAssign<u32> for Rational`

[src]

`fn shr_assign(&mut self, rhs: u32)`

The method for the `>>=`

operator

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

The method for the `>>`

operator

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

[src]

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

[src]

`impl Pow<u32> for Rational`

[src]

`type Output = Rational`

The resulting type after the power operation.

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

Performs the power operation. Read more

`impl PowAssign<u32> for Rational`

[src]

`fn pow_assign(&mut self, rhs: u32)`

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

Performs the power operation. Read more

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

[src]

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

[src]

`impl Eq for Rational`

[src]

`impl Ord for Rational`

[src]

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

This method returns an `Ordering`

between `self`

and `other`

. Read more

`impl PartialEq for Rational`

[src]

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

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

This method tests for `!=`

.

`impl PartialOrd for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

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

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

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`

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

This method tests for `!=`

.

`impl PartialOrd<Integer> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

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

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

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`

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

This method tests for `!=`

.

`impl PartialOrd<i32> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

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

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

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`

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

This method tests for `!=`

.

`impl PartialOrd<u32> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<i64> for Rational`

[src]

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

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

This method tests for `!=`

.

`impl PartialOrd<i64> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<u64> for Rational`

[src]

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

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

This method tests for `!=`

.

`impl PartialOrd<u64> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(i32, i32)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(i64, i64)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(i32, u32)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(i64, u64)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(u32, i32)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(u64, i64)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(u32, u32)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

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

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

This method tests for `!=`

.

`impl PartialOrd<(u64, u64)> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

Performs the conversion.

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

[src]

`fn assign(&mut self, rhs: ValidRational)`

Peforms the assignement. Read more

`impl Send for Rational`

[src]

`impl Sync for Rational`

[src]

`impl Add<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

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

[src]

`type Output = Float`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

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

The method for the `+`

operator

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

The method for the `+`

operator

`impl Sub<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

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

[src]

`type Output = Float`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

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

The method for the `-`

operator

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

The method for the `-`

operator

`impl Mul<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `*`

operator

`fn mul(self, rhs: Float) -> Float`

The method for the `*`

operator

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

[src]

`type Output = Float`

The resulting type after applying the `*`

operator

`fn mul(self, rhs: Float) -> Float`

The method for the `*`

operator

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

The method for the `*`

operator

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

The method for the `*`

operator

`impl Div<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `/`

operator

`fn div(self, rhs: Float) -> Float`

The method for the `/`

operator

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

[src]

`type Output = Float`

The resulting type after applying the `/`

operator

`fn div(self, rhs: Float) -> Float`

The method for the `/`

operator

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

The method for the `/`

operator

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

The method for the `/`

operator

`impl PartialEq<Float> for Rational`

[src]

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

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

This method tests for `!=`

.

`impl PartialOrd<Float> for Rational`

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0

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

`self`

and `other`

) and is used by the `>=`

operator. Read more