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);
The Rational
number type supports various functions. Most
methods have three versions:
- The first method consumes the operand.
- The second method has a
_mut
suffix and mutates the operand. - The third method has a
_ref
suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to aRational
number.
use rug::Rational; // 1. consume the operand let a = Rational::from((-15, 2)); let abs_a = a.abs(); assert_eq!(abs_a, (15, 2)); // 2. mutate the operand let mut b = Rational::from((-17, 2)); b.abs_mut(); assert_eq!(b, (17, 2)); // 3. borrow the operand let c = Rational::from((-19, 2)); let r = c.abs_ref(); let abs_c = Rational::from(r); assert_eq!(abs_c, (19, 2)); // c was not consumed assert_eq!(c, (-19, 2));
Methods
impl Rational
[src]
fn new() -> Self
[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<Self>
[src]
Creates a Rational
number 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<Self>
[src]
Creates a Rational
number 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<Self, 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 parse<S: AsRef<[u8]>>(src: S) -> Result<ParseIncomplete, ParseRationalError>
[src]
Parses a decimal string or byte slice into a
Rational
number.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the unwrapped
returned object as Src
.
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.
ASCII whitespace is ignored everywhere in the string.
Underscores are ignored anywhere except before the first digit
of the numerator and between the '/'
and the the first digit
of the denominator.
Examples
use rug::Rational; let valid1 = Rational::parse("-12/23"); let r1 = Rational::from(valid1.unwrap()); assert_eq!(r1, (-12, 23)); let valid2 = Rational::parse("+ 12 / 23"); let r2 = Rational::from(valid2.unwrap()); assert_eq!(r2, (12, 23)); let invalid = Rational::parse("12/"); assert!(invalid.is_err());
fn parse_radix<S: AsRef<[u8]>>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseRationalError>
[src]
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseRationalError>
Parses a string or byte slice into a
Rational
number.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the unwrapped
returned object as Src
.
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.
ASCII whitespace is ignored everywhere in the string.
Underscores are ignored anywhere except before the first digit
of the numerator and between the '/'
and the the first digit
of the denominator.
Examples
use rug::Rational; let valid1 = Rational::parse_radix("12/23", 4); let r1 = Rational::from(valid1.unwrap()); assert_eq!(r1, (2 + 4 * 1, 3 + 4 * 2)); let valid2 = Rational::parse_radix("12 / yz", 36); let r2 = Rational::from(valid2.unwrap()); assert_eq!(r2, (2 + 36 * 1, 35 + 36 * 34)); let invalid = Rational::parse_radix("12/", 10); assert!(invalid.is_err());
Panics
Panics if radix
is less than 2 or greater than 36.
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));
unsafe fn from_canonical<Num, Den>(num: Num, den: Den) -> Self where
Integer: From<Num> + From<Den>,
[src]
Integer: From<Num> + From<Den>,
Creates a new Rational
number from a
numerator and denominator without canonicalizing aftwerwards.
Safety
This function is unsafe because it does not canonicalize the
Rational
number. The caller must
ensure that the numerator and denominator are in canonical
form, as the rest of the library assumes that they are.
Examples
use rug::Rational; // -3 / 5 is in canonical form let r = unsafe { Rational::from_canonical(-3, 5) }; assert_eq!(r, (-3, 5));
unsafe fn assign_canonical<Num, Den>(&mut self, num: Num, den: Den) where
Integer: Assign<Num> + Assign<Den>,
[src]
Integer: Assign<Num> + Assign<Den>,
Assigns to the numerator and denominator without canonicalizing aftwerwards.
Safety
This function is unsafe because it does not canonicalize the
Rational
number after the
assignment. The caller must ensure that the numerator and
denominator are in canonical form, as the rest of the library
assumes that they are.
Examples
use rug::Rational; let mut r = Rational::new(); // -3 / 5 is in canonical form unsafe { r.assign_canonical(-3, 5); } assert_eq!(r, (-3, 5));
unsafe fn from_raw(raw: mpq_t) -> Self
[src]
Creates a Rational
number from an
initialized GMP rational number.
Safety
- The value must be initialized.
- The
gmp_mpfr_sys::gmp::mpq_t
type can be considered as a kind of pointer, so there can be multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist. - The numerator and denominator must be in canonical form, as the rest of the library assumes that they are. Most GMP functions leave the rational number in canonical form, but assignment functions do not. Check the GMP documentation for details.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::gmp; use rug::Rational; use std::mem; fn main() { let r = unsafe { let mut q = mem::uninitialized(); gmp::mpq_init(&mut q); gmp::mpq_set_si(&mut q, -145, 10); gmp::mpq_canonicalize(&mut q); // q is initialized and unique Rational::from_raw(q) }; assert_eq!(r, (-145, 10)); // since r is a Rational now, deallocation is automatic }
fn into_raw(self) -> mpq_t
[src]
Converts a Rational
number into a
GMP rational number.
The returned object should be freed to avoid memory leaks.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::gmp; use rug::Rational; fn main() { let r = Rational::from((-145, 10)); let mut q = r.into_raw(); unsafe { let d = gmp::mpq_get_d(&q); assert_eq!(d, -14.5); // free object to prevent memory leak gmp::mpq_clear(&mut q); } }
fn as_raw(&self) -> *const mpq_t
[src]
Returns a pointer to the internal GMP rational number.
The returned pointer will be valid for as long as self
is
valid.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::gmp; use rug::Rational; fn main() { let r = Rational::from((-145, 10)); let q_ptr = r.as_raw(); unsafe { let d = gmp::mpq_get_d(q_ptr); assert_eq!(d, -14.5); } // r is still valid assert_eq!(r, (-145, 10)); }
fn as_raw_mut(&mut self) -> *mut mpq_t
[src]
Returns an unsafe mutable pointer to the internal GMP rational number.
The returned pointer will be valid for as long as self
is
valid.
Examples
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::gmp; use rug::Rational; fn main() { let mut r = Rational::from((-145, 10)); let q_ptr = r.as_raw_mut(); unsafe { gmp::mpq_inv(q_ptr, q_ptr); } assert_eq!(r, (-10, 145)); }
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 mutate_numer_denom<F>(&mut self, func: F) where
F: FnOnce(&mut Integer, &mut Integer),
[src]
F: FnOnce(&mut Integer, &mut Integer),
Calls a function with mutable references to the numerator and denominator, then canonicalizes the number.
The denominator must not be zero when the function returns.
Examples
use rug::Rational; let mut r = Rational::from((3, 5)); r.mutate_numer_denom(|num, den| { // change r from 3/5 to 4/8, which is equal to 1/2 *num += 1; *den += 3; }); assert_eq!(*r.numer(), 1); assert_eq!(*r.denom(), 2);
This method does not check that the numerator and denominator
are in canonical form before calling func
. This means that
this method can be used to canonicalize the number after some
unsafe methods that do not leave the number in cononical form.
use rug::Rational; let mut r = Rational::from((3, 5)); unsafe { // leave r in non-canonical form *r.as_mut_numer_denom_no_canonicalization().0 += 1; *r.as_mut_numer_denom_no_canonicalization().1 -= 13; } // At this point, r is still not canonical: 4 / -8 assert_eq!(*r.numer(), 4); assert_eq!(*r.denom(), -8); r.mutate_numer_denom(|_, _| {}); // Now r is in canonical form: -1 / 2 assert_eq!(*r.numer(), -1); assert_eq!(*r.denom(), 2);
Panics
Panics if the denominator is zero when the function returns.
unsafe fn as_mut_numer_denom_no_canonicalization(
&mut self
) -> (&mut Integer, &mut Integer)
[src]
&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 caller must ensure that the numerator and
denominator are left in canonical form, as the rest of the
library assumes that they are.
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 in canonical form. *num += &*den; } assert_eq!(r, (8, 5));
This method can also be used to group some operations before canonicalization. This is usually not beneficial, as early canonicalization usually means subsequent arithmetic operations have less work to do.
use rug::Rational; let mut r = Rational::from((3, 5)); unsafe { // first operation: add 1 to numerator *r.as_mut_numer_denom_no_canonicalization().0 += 1; // second operation: subtract 13 from denominator *r.as_mut_numer_denom_no_canonicalization().1 -= 13; } // At this point, r is still not canonical: 4 / -8 assert_eq!(*r.numer(), 4); assert_eq!(*r.denom(), -8); r.mutate_numer_denom(|_, _| {}); // Now r is in canonical form: -1 / 2 assert_eq!(*r.numer(), -1); assert_eq!(*r.denom(), 2);
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<Target = Rational>
.
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<Target = Rational>
.
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<Target = Rational>
.
This method performs some shallow copying, swapping numerator and denominator and making sure the sign is in the numerator.
Examples
use rug::Rational; let r = Rational::from((-7, 11)); let recip_r = r.as_recip(); assert_eq!(*recip_r, (-11, 7)); // methods taking &self can be used on the returned object let rerecip_r = recip_r.as_recip(); assert_eq!(*rerecip_r, (-7, 11)); assert_eq!(*rerecip_r, r);
Panics
Panics if the value is zero.
fn cmp0(&self) -> Ordering
[src]
Returns the same result as self.partial_cmp(&0).unwrap()
,
but is faster.
Examples
use rug::Rational; use std::cmp::Ordering; assert_eq!(Rational::from((-5, 7)).cmp0(), Ordering::Less); assert_eq!(Rational::from(0).cmp0(), Ordering::Equal); assert_eq!(Rational::from((5, 7)).cmp0(), Ordering::Greater);
fn cmp_abs(&self, other: &Self) -> Ordering
[src]
Compares the absolute values.
Examples
use rug::Rational; use std::cmp::Ordering; let a = Rational::from((-23, 10)); let b = Rational::from((-47, 5)); assert_eq!(a.cmp(&b), Ordering::Greater); assert_eq!(a.cmp_abs(&b), Ordering::Less);
fn abs(self) -> Self
[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) -> AbsIncomplete
[src]
Computes the absolute value.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; let r = Rational::from((-100, 17)); let r_ref = r.abs_ref(); let abs = Rational::from(r_ref); assert_eq!(abs, (100, 17));
fn signum(self) -> Rational
[src]
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Examples
use rug::Rational; let r = Rational::from((-100, 17)); let signum = r.signum(); assert_eq!(signum, -1);
fn signum_mut(&mut self)
[src]
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Examples
use rug::Rational; let mut r = Rational::from((-100, 17)); r.signum_mut(); assert_eq!(r, -1);
fn signum_ref(&self) -> SignumIncomplete
[src]
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Assign<Src> for Integer
,
Assign<Src> for Rational
,
From<Src> for Integer
and From<Src> for Rational
are
implemented with the returned object as Src
.
Examples
use rug::{Integer, Rational}; let r = Rational::from((-100, 17)); let r_ref = r.signum_ref(); let signum = Integer::from(r_ref); assert_eq!(signum, -1);
fn clamp<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,
[src]
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,
Clamps the value within the specified bounds.
Examples
use rug::Rational; let min = (-3, 2); let max = (3, 2); let too_small = Rational::from((-5, 2)); let clamped1 = too_small.clamp(&min, &max); assert_eq!(clamped1, (-3, 2)); let in_range = Rational::from((1, 2)); let clamped2 = in_range.clamp(&min, &max); assert_eq!(clamped2, (1, 2));
Panics
Panics if the maximum value is less than the minimum value.
fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,
[src]
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,
Clamps the value within the specified bounds.
Examples
use rug::Rational; let min = (-3, 2); let max = (3, 2); let mut too_small = Rational::from((-5, 2)); too_small.clamp_mut(&min, &max); assert_eq!(too_small, (-3, 2)); let mut in_range = Rational::from((1, 2)); in_range.clamp_mut(&min, &max); assert_eq!(in_range, (1, 2));
Panics
Panics if the maximum value is less than the minimum value.
fn clamp_ref<'a, Min, Max>(
&'a self,
min: &'a Min,
max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
[src]
&'a self,
min: &'a Min,
max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
Clamps the value within the specified bounds.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; let min = (-3, 2); let max = (3, 2); let too_small = Rational::from((-5, 2)); let r1 = too_small.clamp_ref(&min, &max); let clamped1 = Rational::from(r1); assert_eq!(clamped1, (-3, 2)); let in_range = Rational::from((1, 2)); let r2 = in_range.clamp_ref(&min, &max); let clamped2 = Rational::from(r2); assert_eq!(clamped2, (1, 2));
Panics
Panics if the maximum value is less than the minimum value.
fn recip(self) -> Self
[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.
This method never reallocates or copies the heap data. It simply swaps the allocated data of the numerator and denominator and makes sure the denominator is stored as positive.
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) -> RecipIncomplete
[src]
Computes the reciprocal.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; let r = Rational::from((-100, 17)); let r_ref = r.recip_ref(); let recip = Rational::from(r_ref); assert_eq!(recip, (-17, 100));
fn trunc(self) -> Rational
[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 trunc1 = r1.trunc(); assert_eq!(trunc1, -3); // 3.3 let r2 = Rational::from((33, 10)); let trunc2 = r2.trunc(); assert_eq!(trunc2, 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) -> TruncIncomplete
[src]
Rounds the number towards zero.
Assign<Src> for Integer
,
Assign<Src> for Rational
,
From<Src> for Integer
and From<Src> for Rational
are
implemented with the returned object as Src
.
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 rem_trunc(self) -> Self
[src]
Computes the fractional part of the number.
Examples
use rug::Rational; // -100/17 = -5 - 15/17 let r = Rational::from((-100, 17)); let rem = r.rem_trunc(); assert_eq!(rem, (-15, 17));
fn rem_trunc_mut(&mut self)
[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.rem_trunc_mut(); assert_eq!(r, (-15, 17));
fn rem_trunc_ref(&self) -> RemTruncIncomplete
[src]
Computes the fractional part of the number.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; // -100/17 = -5 - 15/17 let r = Rational::from((-100, 17)); let r_ref = r.rem_trunc_ref(); let rem = Rational::from(r_ref); assert_eq!(rem, (-15, 17));
fn fract_trunc(self, trunc: Integer) -> (Self, 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) -> FractTruncIncomplete
[src]
Computes the fractional and truncated parts of the number.
Assign<Src> for (Rational, Integer)
,
Assign<Src> for (&mut Rational, &mut Integer)
and From<Src> for (Rational, Integer)
are implemented
with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; // -100/17 = -5 - 15/17 let r = Rational::from((-100, 17)); let r_ref = r.fract_trunc_ref(); let (mut fract, mut trunc) = (Rational::new(), Integer::new()); (&mut fract, &mut trunc).assign(r_ref); assert_eq!(fract, (-15, 17)); assert_eq!(trunc, -5);
fn ceil(self) -> Rational
[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 ceil1 = r1.ceil(); assert_eq!(ceil1, -3); // 3.3 let r2 = Rational::from((33, 10)); let ceil2 = r2.ceil(); assert_eq!(ceil2, 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) -> CeilIncomplete
[src]
Rounds the number upwards (towards plus infinity).
Assign<Src> for Integer
,
Assign<Src> for Rational
,
From<Src> for Integer
and From<Src> for Rational
are
implemented with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; let mut ceil = Integer::new(); // -3.7 let r1 = Rational::from((-37, 10)); ceil.assign(r1.ceil_ref()); assert_eq!(ceil, -3); // 3.3 let r2 = Rational::from((33, 10)); ceil.assign(r2.ceil_ref()); assert_eq!(ceil, 4);
fn rem_ceil(self) -> Self
[src]
Computes the non-positive remainder after rounding up.
Examples
use rug::Rational; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let rem = r.rem_ceil(); assert_eq!(rem, (-2, 17));
fn rem_ceil_mut(&mut self)
[src]
Computes the non-positive remainder after rounding up.
Examples
use rug::Rational; // 100/17 = 6 - 2/17 let mut r = Rational::from((100, 17)); r.rem_ceil_mut(); assert_eq!(r, (-2, 17));
fn rem_ceil_ref(&self) -> RemCeilIncomplete
[src]
Computes the non-positive remainder after rounding up.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let r_ref = r.rem_ceil_ref(); let rem = Rational::from(r_ref); assert_eq!(rem, (-2, 17));
fn fract_ceil(self, ceil: Integer) -> (Self, Integer)
[src]
Computes the fractional and ceil parts of the number.
The fractional part cannot greater than zero. The initial
value of ceil
is ignored.
Examples
use rug::{Integer, Rational}; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let (fract, ceil) = r.fract_ceil(Integer::new()); assert_eq!(fract, (-2, 17)); assert_eq!(ceil, 6);
fn fract_ceil_mut(&mut self, ceil: &mut Integer)
[src]
Computes the fractional and ceil parts of the number.
The fractional part cannot be greater than zero. The initial
value of ceil
is ignored.
Examples
use rug::{Integer, Rational}; // 100/17 = 6 - 2/17 let mut r = Rational::from((100, 17)); let mut ceil = Integer::new(); r.fract_ceil_mut(&mut ceil); assert_eq!(r, (-2, 17)); assert_eq!(ceil, 6);
fn fract_ceil_ref(&self) -> FractCeilIncomplete
[src]
Computes the fractional and ceil parts of the number.
The fractional part cannot be greater than zero.
Assign<Src> for (Rational, Integer)
,
Assign<Src> for (&mut Rational, &mut Integer)
and From<Src> for (Rational, Integer)
are implemented
with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let r_ref = r.fract_ceil_ref(); let (mut fract, mut ceil) = (Rational::new(), Integer::new()); (&mut fract, &mut ceil).assign(r_ref); assert_eq!(fract, (-2, 17)); assert_eq!(ceil, 6);
fn floor(self) -> Rational
[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 floor1 = r1.floor(); assert_eq!(floor1, -4); // 3.3 let r2 = Rational::from((33, 10)); let floor2 = r2.floor(); assert_eq!(floor2, 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) -> FloorIncomplete
[src]
Rounds the number downwards (towards minus infinity).
Assign<Src> for Integer
,
Assign<Src> for Rational
,
From<Src> for Integer
and From<Src> for Rational
are
implemented with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; let mut floor = Integer::new(); // -3.7 let r1 = Rational::from((-37, 10)); floor.assign(r1.floor_ref()); assert_eq!(floor, -4); // 3.3 let r2 = Rational::from((33, 10)); floor.assign(r2.floor_ref()); assert_eq!(floor, 3);
fn rem_floor(self) -> Self
[src]
Computes the non-negative remainder after rounding down.
Examples
use rug::Rational; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let rem = r.rem_floor(); assert_eq!(rem, (2, 17));
fn rem_floor_mut(&mut self)
[src]
Computes the non-negative remainder after rounding down.
Examples
use rug::Rational; // -100/17 = -6 + 2/17 let mut r = Rational::from((-100, 17)); r.rem_floor_mut(); assert_eq!(r, (2, 17));
fn rem_floor_ref(&self) -> RemFloorIncomplete
[src]
Computes the non-negative remainder after rounding down.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let r_ref = r.rem_floor_ref(); let rem = Rational::from(r_ref); assert_eq!(rem, (2, 17));
fn fract_floor(self, floor: Integer) -> (Self, Integer)
[src]
Computes the fractional and floor parts of the number.
The fractional part cannot be negative. The initial value of
floor
is ignored.
Examples
use rug::{Integer, Rational}; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let (fract, floor) = r.fract_floor(Integer::new()); assert_eq!(fract, (2, 17)); assert_eq!(floor, -6);
fn fract_floor_mut(&mut self, floor: &mut Integer)
[src]
Computes the fractional and floor parts of the number.
The fractional part cannot be negative. The initial value of
floor
is ignored.
Examples
use rug::{Integer, Rational}; // -100/17 = -6 + 2/17 let mut r = Rational::from((-100, 17)); let mut floor = Integer::new(); r.fract_floor_mut(&mut floor); assert_eq!(r, (2, 17)); assert_eq!(floor, -6);
fn fract_floor_ref(&self) -> FractFloorIncomplete
[src]
Computes the fractional and floor parts of the number.
The fractional part cannot be negative.
Assign<Src> for (Rational, Integer)
,
Assign<Src> for (&mut Rational, &mut Integer)
and From<Src> for (Rational, Integer)
are implemented
with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let r_ref = r.fract_floor_ref(); let (mut fract, mut floor) = (Rational::new(), Integer::new()); (&mut fract, &mut floor).assign(r_ref); assert_eq!(fract, (2, 17)); assert_eq!(floor, -6);
fn round(self) -> Rational
[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 round1 = r1.round(); assert_eq!(round1, -4); // 3.7 let r2 = Rational::from((37, 10)); let round2 = r2.round(); assert_eq!(round2, 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) -> RoundIncomplete
[src]
Rounds the number to the nearest integer.
When the number lies exactly between two integers, it is rounded away from zero.
Assign<Src> for Integer
,
Assign<Src> for Rational
,
From<Src> for Integer
and From<Src> for Rational
are
implemented with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; let mut round = Integer::new(); // -3.5 let r1 = Rational::from((-35, 10)); round.assign(r1.round_ref()); assert_eq!(round, -4); // 3.7 let r2 = Rational::from((37, 10)); round.assign(r2.round_ref()); assert_eq!(round, 4);
fn rem_round(self) -> Self
[src]
Computes the remainder after rounding to the nearest integer.
Examples
use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let rem1 = r1.rem_round(); assert_eq!(rem1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let rem2 = r2.rem_round(); assert_eq!(rem2, (-3, 10));
fn rem_round_mut(&mut self)
[src]
Computes the remainder after rounding to the nearest integer.
Examples
use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let mut r1 = Rational::from((-35, 10)); r1.rem_round_mut(); assert_eq!(r1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let mut r2 = Rational::from((37, 10)); r2.rem_round_mut(); assert_eq!(r2, (-3, 10));
fn rem_round_ref(&self) -> RemRoundIncomplete
[src]
Computes the remainder after rounding to the nearest integer.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let r_ref1 = r1.rem_round_ref(); let rem1 = Rational::from(r_ref1); assert_eq!(rem1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let r_ref2 = r2.rem_round_ref(); let rem2 = Rational::from(r_ref2); assert_eq!(rem2, (-3, 10));
fn fract_round(self, round: Integer) -> (Self, Integer)
[src]
Computes the fractional and rounded parts of the number.
The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.
Examples
use rug::{Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let (fract1, round1) = r1.fract_round(Integer::new()); assert_eq!(fract1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let (fract2, round2) = r2.fract_round(Integer::new()); assert_eq!(fract2, (-3, 10)); assert_eq!(round2, 4);
fn fract_round_mut(&mut self, round: &mut Integer)
[src]
Computes the fractional and round parts of the number.
The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.
Examples
use rug::{Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let mut r1 = Rational::from((-35, 10)); let mut round1 = Integer::new(); r1.fract_round_mut(&mut round1); assert_eq!(r1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let mut r2 = Rational::from((37, 10)); let mut round2 = Integer::new(); r2.fract_round_mut(&mut round2); assert_eq!(r2, (-3, 10)); assert_eq!(round2, 4);
fn fract_round_ref(&self) -> FractRoundIncomplete
[src]
Computes the fractional and round parts of the number.
The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.
Assign<Src> for (Rational, Integer)
,
Assign<Src> for (&mut Rational, &mut Integer)
and From<Src> for (Rational, Integer)
are implemented
with the returned object as Src
.
Examples
use rug::{Assign, Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let r_ref1 = r1.fract_round_ref(); let (mut fract1, mut round1) = (Rational::new(), Integer::new()); (&mut fract1, &mut round1).assign(r_ref1); assert_eq!(fract1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let r_ref2 = r2.fract_round_ref(); let (mut fract2, mut round2) = (Rational::new(), Integer::new()); (&mut fract2, &mut round2).assign(r_ref2); assert_eq!(fract2, (-3, 10)); assert_eq!(round2, 4);
fn square(self) -> Self
[src]
Computes the square.
Examples
use rug::Rational; let r = Rational::from((-13, 2)); let square = r.square(); assert_eq!(square, (169, 4));
fn square_mut(&mut self)
[src]
Computes the square.
Examples
use rug::Rational; let mut r = Rational::from((-13, 2)); r.square_mut(); assert_eq!(r, (169, 4));
fn square_ref(&self) -> SquareIncomplete
[src]
Computes the square.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the returned
object as Src
.
Examples
use rug::Rational; let r = Rational::from((-13, 2)); assert_eq!(Rational::from(r.square_ref()), (169, 4));
Trait Implementations
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 = NegIncomplete<'a>
The resulting type after applying the -
operator.
fn neg(self) -> NegIncomplete<'a>
[src]
Performs the unary -
operation.
impl<'a> Assign<NegIncomplete<'a>> for Rational
[src]
impl<'r> From<NegIncomplete<'r>> 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
[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<'a> Add<&'a Rational> for &'a Rational
[src]
type Output = AddIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Rational) -> AddIncomplete<'a>
[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]
impl<'a> AddFrom<&'a Rational> for Rational
[src]
impl<'a> Assign<AddIncomplete<'a>> for Rational
[src]
impl<'r> From<AddIncomplete<'r>> 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
[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<'a> Sub<&'a Rational> for &'a Rational
[src]
type Output = SubIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Rational) -> SubIncomplete<'a>
[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]
impl<'a> SubFrom<&'a Rational> for Rational
[src]
impl<'a> Assign<SubIncomplete<'a>> for Rational
[src]
impl<'r> From<SubIncomplete<'r>> 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
[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<'a> Mul<&'a Rational> for &'a Rational
[src]
type Output = MulIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Rational) -> MulIncomplete<'a>
[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]
impl<'a> MulFrom<&'a Rational> for Rational
[src]
impl<'a> Assign<MulIncomplete<'a>> for Rational
[src]
impl<'r> From<MulIncomplete<'r>> 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
[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<'a> Div<&'a Rational> for &'a Rational
[src]
type Output = DivIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Rational) -> DivIncomplete<'a>
[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]
impl<'a> DivFrom<&'a Rational> for Rational
[src]
impl<'a> Assign<DivIncomplete<'a>> for Rational
[src]
impl<'r> From<DivIncomplete<'r>> 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
[src]
Performs the <<
operation.
impl<'t> Shl<&'t i32> for Rational
[src]
type Output = Rational
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'t i32) -> Rational
[src]
Performs the <<
operation.
impl<'b> Shl<i32> for &'b Rational
[src]
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>
[src]
Performs the <<
operation.
impl<'t, 'b> Shl<&'t i32> for &'b Rational
[src]
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'t i32) -> ShlI32Incomplete<'b>
[src]
Performs the <<
operation.
impl ShlAssign<i32> for Rational
[src]
fn shl_assign(&mut self, rhs: i32)
[src]
Performs the <<=
operation.
impl<'t> ShlAssign<&'t i32> for Rational
[src]
fn shl_assign(&mut self, rhs: &'t i32)
[src]
Performs the <<=
operation.
impl<'a> Assign<ShlI32Incomplete<'a>> for Rational
[src]
impl<'r> From<ShlI32Incomplete<'r>> 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
[src]
Performs the >>
operation.
impl<'t> Shr<&'t i32> for Rational
[src]
type Output = Rational
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'t i32) -> Rational
[src]
Performs the >>
operation.
impl<'b> Shr<i32> for &'b Rational
[src]
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>
[src]
Performs the >>
operation.
impl<'t, 'b> Shr<&'t i32> for &'b Rational
[src]
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'t i32) -> ShrI32Incomplete<'b>
[src]
Performs the >>
operation.
impl ShrAssign<i32> for Rational
[src]
fn shr_assign(&mut self, rhs: i32)
[src]
Performs the >>=
operation.
impl<'t> ShrAssign<&'t i32> for Rational
[src]
fn shr_assign(&mut self, rhs: &'t i32)
[src]
Performs the >>=
operation.
impl<'a> Assign<ShrI32Incomplete<'a>> for Rational
[src]
impl<'r> From<ShrI32Incomplete<'r>> 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
[src]
Performs the power operation. Read more
impl<'t> Pow<&'t i32> for Rational
[src]
type Output = Rational
The resulting type after the power operation.
fn pow(self, rhs: &'t i32) -> Rational
[src]
Performs the power operation. Read more
impl<'b> Pow<i32> for &'b Rational
[src]
type Output = PowI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: i32) -> PowI32Incomplete<'b>
[src]
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t i32> for &'b Rational
[src]
type Output = PowI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &'t i32) -> PowI32Incomplete<'b>
[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<'t> PowAssign<&'t i32> for Rational
[src]
fn pow_assign(&mut self, rhs: &'t i32)
[src]
Peforms the power operation. Read more
impl<'a> Assign<PowI32Incomplete<'a>> for Rational
[src]
impl<'r> From<PowI32Incomplete<'r>> 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
[src]
Performs the <<
operation.
impl<'t> Shl<&'t u32> for Rational
[src]
type Output = Rational
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'t u32) -> Rational
[src]
Performs the <<
operation.
impl<'b> Shl<u32> for &'b Rational
[src]
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>
[src]
Performs the <<
operation.
impl<'t, 'b> Shl<&'t u32> for &'b Rational
[src]
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'t u32) -> ShlU32Incomplete<'b>
[src]
Performs the <<
operation.
impl ShlAssign<u32> for Rational
[src]
fn shl_assign(&mut self, rhs: u32)
[src]
Performs the <<=
operation.
impl<'t> ShlAssign<&'t u32> for Rational
[src]
fn shl_assign(&mut self, rhs: &'t u32)
[src]
Performs the <<=
operation.
impl<'a> Assign<ShlU32Incomplete<'a>> for Rational
[src]
impl<'r> From<ShlU32Incomplete<'r>> 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
[src]
Performs the >>
operation.
impl<'t> Shr<&'t u32> for Rational
[src]
type Output = Rational
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'t u32) -> Rational
[src]
Performs the >>
operation.
impl<'b> Shr<u32> for &'b Rational
[src]
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>
[src]
Performs the >>
operation.
impl<'t, 'b> Shr<&'t u32> for &'b Rational
[src]
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'t u32) -> ShrU32Incomplete<'b>
[src]
Performs the >>
operation.
impl ShrAssign<u32> for Rational
[src]
fn shr_assign(&mut self, rhs: u32)
[src]
Performs the >>=
operation.
impl<'t> ShrAssign<&'t u32> for Rational
[src]
fn shr_assign(&mut self, rhs: &'t u32)
[src]
Performs the >>=
operation.
impl<'a> Assign<ShrU32Incomplete<'a>> for Rational
[src]
impl<'r> From<ShrU32Incomplete<'r>> 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
[src]
Performs the power operation. Read more
impl<'t> Pow<&'t u32> for Rational
[src]
type Output = Rational
The resulting type after the power operation.
fn pow(self, rhs: &'t u32) -> Rational
[src]
Performs the power operation. Read more
impl<'b> Pow<u32> for &'b Rational
[src]
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: u32) -> PowU32Incomplete<'b>
[src]
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t u32> for &'b Rational
[src]
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &'t u32) -> PowU32Incomplete<'b>
[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<'t> PowAssign<&'t u32> for Rational
[src]
fn pow_assign(&mut self, rhs: &'t u32)
[src]
Peforms the power operation. Read more
impl<'a> Assign<PowU32Incomplete<'a>> for Rational
[src]
impl<'r> From<PowU32Incomplete<'r>> for Rational
[src]
impl Sum for Rational
[src]
fn sum<I>(iter: I) -> Rational where
I: Iterator<Item = Rational>,
[src]
I: Iterator<Item = Rational>,
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]
I: Iterator<Item = &'a Rational>,
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]
I: Iterator<Item = Rational>,
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]
I: Iterator<Item = &'a Rational>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl<'a> Assign<AbsIncomplete<'a>> for Rational
[src]
impl<'r> From<AbsIncomplete<'r>> for Rational
[src]
impl<'a, Min, Max> Assign<ClampIncomplete<'a, Min, Max>> for Rational where
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
Min: 'a,
Max: 'a,
[src]
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
Min: 'a,
Max: 'a,
impl<'a, Min, Max> From<ClampIncomplete<'a, Min, Max>> for Rational where
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
Min: 'a,
Max: 'a,
[src]
Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
Min: 'a,
Max: 'a,
impl<'a> Assign<RecipIncomplete<'a>> for Rational
[src]
impl<'r> From<RecipIncomplete<'r>> for Rational
[src]
impl<'a> Assign<RemTruncIncomplete<'a>> for Rational
[src]
impl<'r> From<RemTruncIncomplete<'r>> for Rational
[src]
impl<'a> Assign<RemCeilIncomplete<'a>> for Rational
[src]
impl<'r> From<RemCeilIncomplete<'r>> for Rational
[src]
impl<'a> Assign<RemFloorIncomplete<'a>> for Rational
[src]
impl<'r> From<RemFloorIncomplete<'r>> for Rational
[src]
impl<'a> Assign<RemRoundIncomplete<'a>> for Rational
[src]
impl<'r> From<RemRoundIncomplete<'r>> for Rational
[src]
impl<'a> Assign<SquareIncomplete<'a>> for Rational
[src]
impl<'r> From<SquareIncomplete<'r>> for Rational
[src]
impl Assign<ParseIncomplete> for Rational
[src]
impl<'a> From<ParseIncomplete> for Rational
[src]
impl Eq for Rational
[src]
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<i8> for Rational
[src]
fn eq(&self, other: &i8) -> 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<i8> for Rational
[src]
fn partial_cmp(&self, other: &i8) -> 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<i16> for Rational
[src]
fn eq(&self, other: &i16) -> 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<i16> for Rational
[src]
fn partial_cmp(&self, other: &i16) -> 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<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<isize> for Rational
[src]
fn eq(&self, other: &isize) -> 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<isize> for Rational
[src]
fn partial_cmp(&self, other: &isize) -> 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<u8> for Rational
[src]
fn eq(&self, other: &u8) -> 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<u8> for Rational
[src]
fn partial_cmp(&self, other: &u8) -> 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<u16> for Rational
[src]
fn eq(&self, other: &u16) -> 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<u16> for Rational
[src]
fn partial_cmp(&self, other: &u16) -> 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<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<usize> for Rational
[src]
fn eq(&self, other: &usize) -> 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<usize> for Rational
[src]
fn partial_cmp(&self, other: &usize) -> 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<(i8, i8)> for Rational
[src]
fn eq(&self, other: &(i8, i8)) -> 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<(i8, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, i8)) -> 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<(i8, i16)> for Rational
[src]
fn eq(&self, other: &(i8, i16)) -> 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<(i8, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, i16)) -> 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<(i8, i32)> for Rational
[src]
fn eq(&self, other: &(i8, 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<(i8, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, 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<(i8, i64)> for Rational
[src]
fn eq(&self, other: &(i8, 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<(i8, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, 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<(i8, isize)> for Rational
[src]
fn eq(&self, other: &(i8, isize)) -> 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<(i8, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, isize)) -> 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<(i8, u8)> for Rational
[src]
fn eq(&self, other: &(i8, u8)) -> 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<(i8, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, u8)) -> 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<(i8, u16)> for Rational
[src]
fn eq(&self, other: &(i8, u16)) -> 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<(i8, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, u16)) -> 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<(i8, u32)> for Rational
[src]
fn eq(&self, other: &(i8, 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<(i8, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, 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<(i8, u64)> for Rational
[src]
fn eq(&self, other: &(i8, 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<(i8, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, 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<(i8, usize)> for Rational
[src]
fn eq(&self, other: &(i8, usize)) -> 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<(i8, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(i8, usize)) -> 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<(i16, i8)> for Rational
[src]
fn eq(&self, other: &(i16, i8)) -> 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<(i16, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, i8)) -> 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<(i16, i16)> for Rational
[src]
fn eq(&self, other: &(i16, i16)) -> 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<(i16, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, i16)) -> 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<(i16, i32)> for Rational
[src]
fn eq(&self, other: &(i16, 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<(i16, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, 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<(i16, i64)> for Rational
[src]
fn eq(&self, other: &(i16, 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<(i16, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, 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<(i16, isize)> for Rational
[src]
fn eq(&self, other: &(i16, isize)) -> 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<(i16, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, isize)) -> 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<(i16, u8)> for Rational
[src]
fn eq(&self, other: &(i16, u8)) -> 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<(i16, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, u8)) -> 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<(i16, u16)> for Rational
[src]
fn eq(&self, other: &(i16, u16)) -> 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<(i16, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, u16)) -> 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<(i16, u32)> for Rational
[src]
fn eq(&self, other: &(i16, 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<(i16, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, 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<(i16, u64)> for Rational
[src]
fn eq(&self, other: &(i16, 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<(i16, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, 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<(i16, usize)> for Rational
[src]
fn eq(&self, other: &(i16, usize)) -> 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<(i16, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(i16, usize)) -> 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, i8)> for Rational
[src]
fn eq(&self, other: &(i32, i8)) -> 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, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, i8)) -> 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, i16)> for Rational
[src]
fn eq(&self, other: &(i32, i16)) -> 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, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, i16)) -> 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<(i32, i64)> for Rational
[src]
fn eq(&self, other: &(i32, 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<(i32, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, 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, isize)> for Rational
[src]
fn eq(&self, other: &(i32, isize)) -> 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, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, isize)) -> 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, u8)> for Rational
[src]
fn eq(&self, other: &(i32, u8)) -> 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, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, u8)) -> 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, u16)> for Rational
[src]
fn eq(&self, other: &(i32, u16)) -> 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, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, u16)) -> 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<(i32, u64)> for Rational
[src]
fn eq(&self, other: &(i32, 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<(i32, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, 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, usize)> for Rational
[src]
fn eq(&self, other: &(i32, usize)) -> 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, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(i32, usize)) -> 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, i8)> for Rational
[src]
fn eq(&self, other: &(i64, i8)) -> 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, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, i8)) -> 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, i16)> for Rational
[src]
fn eq(&self, other: &(i64, i16)) -> 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, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, i16)) -> 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, i32)> for Rational
[src]
fn eq(&self, other: &(i64, 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<(i64, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, 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<(i64, isize)> for Rational
[src]
fn eq(&self, other: &(i64, isize)) -> 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, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, isize)) -> 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, u8)> for Rational
[src]
fn eq(&self, other: &(i64, u8)) -> 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, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, u8)) -> 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, u16)> for Rational
[src]
fn eq(&self, other: &(i64, u16)) -> 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, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, u16)) -> 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, u32)> for Rational
[src]
fn eq(&self, other: &(i64, 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<(i64, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, 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<(i64, usize)> for Rational
[src]
fn eq(&self, other: &(i64, usize)) -> 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, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(i64, usize)) -> 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<(isize, i8)> for Rational
[src]
fn eq(&self, other: &(isize, i8)) -> 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<(isize, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, i8)) -> 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<(isize, i16)> for Rational
[src]
fn eq(&self, other: &(isize, i16)) -> 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<(isize, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, i16)) -> 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<(isize, i32)> for Rational
[src]
fn eq(&self, other: &(isize, 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<(isize, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, 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<(isize, i64)> for Rational
[src]
fn eq(&self, other: &(isize, 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<(isize, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, 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<(isize, isize)> for Rational
[src]
fn eq(&self, other: &(isize, isize)) -> 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<(isize, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, isize)) -> 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<(isize, u8)> for Rational
[src]
fn eq(&self, other: &(isize, u8)) -> 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<(isize, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, u8)) -> 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<(isize, u16)> for Rational
[src]
fn eq(&self, other: &(isize, u16)) -> 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<(isize, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, u16)) -> 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<(isize, u32)> for Rational
[src]
fn eq(&self, other: &(isize, 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<(isize, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, 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<(isize, u64)> for Rational
[src]
fn eq(&self, other: &(isize, 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<(isize, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, 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<(isize, usize)> for Rational
[src]
fn eq(&self, other: &(isize, usize)) -> 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<(isize, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(isize, usize)) -> 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<(u8, i8)> for Rational
[src]
fn eq(&self, other: &(u8, i8)) -> 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<(u8, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, i8)) -> 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<(u8, i16)> for Rational
[src]
fn eq(&self, other: &(u8, i16)) -> 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<(u8, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, i16)) -> 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<(u8, i32)> for Rational
[src]
fn eq(&self, other: &(u8, 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<(u8, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, 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<(u8, i64)> for Rational
[src]
fn eq(&self, other: &(u8, 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<(u8, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, 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<(u8, isize)> for Rational
[src]
fn eq(&self, other: &(u8, isize)) -> 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<(u8, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, isize)) -> 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<(u8, u8)> for Rational
[src]
fn eq(&self, other: &(u8, u8)) -> 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<(u8, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, u8)) -> 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<(u8, u16)> for Rational
[src]
fn eq(&self, other: &(u8, u16)) -> 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<(u8, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, u16)) -> 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<(u8, u32)> for Rational
[src]
fn eq(&self, other: &(u8, 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<(u8, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, 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<(u8, u64)> for Rational
[src]
fn eq(&self, other: &(u8, 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<(u8, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, 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<(u8, usize)> for Rational
[src]
fn eq(&self, other: &(u8, usize)) -> 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<(u8, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(u8, usize)) -> 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<(u16, i8)> for Rational
[src]
fn eq(&self, other: &(u16, i8)) -> 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<(u16, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, i8)) -> 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<(u16, i16)> for Rational
[src]
fn eq(&self, other: &(u16, i16)) -> 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<(u16, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, i16)) -> 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<(u16, i32)> for Rational
[src]
fn eq(&self, other: &(u16, 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<(u16, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, 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<(u16, i64)> for Rational
[src]
fn eq(&self, other: &(u16, 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<(u16, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, 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<(u16, isize)> for Rational
[src]
fn eq(&self, other: &(u16, isize)) -> 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<(u16, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, isize)) -> 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<(u16, u8)> for Rational
[src]
fn eq(&self, other: &(u16, u8)) -> 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<(u16, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, u8)) -> 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<(u16, u16)> for Rational
[src]
fn eq(&self, other: &(u16, u16)) -> 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<(u16, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, u16)) -> 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<(u16, u32)> for Rational
[src]
fn eq(&self, other: &(u16, 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<(u16, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, 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<(u16, u64)> for Rational
[src]
fn eq(&self, other: &(u16, 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<(u16, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, 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<(u16, usize)> for Rational
[src]
fn eq(&self, other: &(u16, usize)) -> 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<(u16, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(u16, usize)) -> 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, i8)> for Rational
[src]
fn eq(&self, other: &(u32, i8)) -> 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, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, i8)) -> 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, i16)> for Rational
[src]
fn eq(&self, other: &(u32, i16)) -> 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, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, i16)) -> 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<(u32, i64)> for Rational
[src]
fn eq(&self, other: &(u32, 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<(u32, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, 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, isize)> for Rational
[src]
fn eq(&self, other: &(u32, isize)) -> 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, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, isize)) -> 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, u8)> for Rational
[src]
fn eq(&self, other: &(u32, u8)) -> 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, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, u8)) -> 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, u16)> for Rational
[src]
fn eq(&self, other: &(u32, u16)) -> 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, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, u16)) -> 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<(u32, u64)> for Rational
[src]
fn eq(&self, other: &(u32, 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<(u32, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, 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, usize)> for Rational
[src]
fn eq(&self, other: &(u32, usize)) -> 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, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(u32, usize)) -> 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, i8)> for Rational
[src]
fn eq(&self, other: &(u64, i8)) -> 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, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, i8)) -> 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, i16)> for Rational
[src]
fn eq(&self, other: &(u64, i16)) -> 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, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, i16)) -> 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, i32)> for Rational
[src]
fn eq(&self, other: &(u64, 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<(u64, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, 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<(u64, isize)> for Rational
[src]
fn eq(&self, other: &(u64, isize)) -> 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, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, isize)) -> 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, u8)> for Rational
[src]
fn eq(&self, other: &(u64, u8)) -> 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, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, u8)) -> 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, u16)> for Rational
[src]
fn eq(&self, other: &(u64, u16)) -> 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, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, u16)) -> 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, u32)> for Rational
[src]
fn eq(&self, other: &(u64, 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<(u64, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, 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 PartialEq<(u64, usize)> for Rational
[src]
fn eq(&self, other: &(u64, usize)) -> 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, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(u64, usize)) -> 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<(usize, i8)> for Rational
[src]
fn eq(&self, other: &(usize, i8)) -> 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<(usize, i8)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, i8)) -> 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<(usize, i16)> for Rational
[src]
fn eq(&self, other: &(usize, i16)) -> 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<(usize, i16)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, i16)) -> 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<(usize, i32)> for Rational
[src]
fn eq(&self, other: &(usize, 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<(usize, i32)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, 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<(usize, i64)> for Rational
[src]
fn eq(&self, other: &(usize, 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<(usize, i64)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, 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<(usize, isize)> for Rational
[src]
fn eq(&self, other: &(usize, isize)) -> 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<(usize, isize)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, isize)) -> 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<(usize, u8)> for Rational
[src]
fn eq(&self, other: &(usize, u8)) -> 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<(usize, u8)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, u8)) -> 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<(usize, u16)> for Rational
[src]
fn eq(&self, other: &(usize, u16)) -> 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<(usize, u16)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, u16)) -> 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<(usize, u32)> for Rational
[src]
fn eq(&self, other: &(usize, 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<(usize, u32)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, 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<(usize, u64)> for Rational
[src]
fn eq(&self, other: &(usize, 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<(usize, u64)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, 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<(usize, usize)> for Rational
[src]
fn eq(&self, other: &(usize, usize)) -> 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<(usize, usize)> for Rational
[src]
fn partial_cmp(&self, other: &(usize, usize)) -> 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<f32> for Rational
[src]
fn eq(&self, other: &f32) -> 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<f32> for Rational
[src]
fn partial_cmp(&self, other: &f32) -> 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<f64> for Rational
[src]
fn eq(&self, other: &f64) -> 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<f64> for Rational
[src]
fn partial_cmp(&self, other: &f64) -> 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 Serialize for Rational
[src]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<'de> Deserialize<'de> for Rational
[src]
fn deserialize<D>(deserializer: D) -> Result<Rational, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
fn deserialize_in_place<D>(
deserializer: D,
place: &mut Rational
) -> Result<(), D::Error> where
D: Deserializer<'de>,
[src]
deserializer: D,
place: &mut Rational
) -> Result<(), D::Error> where
D: Deserializer<'de>,
impl Default for Rational
[src]
impl Clone for Rational
[src]
fn clone(&self) -> Rational
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, src: &Rational)
[src]
Performs copy-assignment from source
. Read more
impl Drop for Rational
[src]
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]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
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]
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> From<&'a Rational> for Rational
[src]
impl<Num> Assign<Num> for Rational where
Integer: Assign<Num>,
[src]
Integer: Assign<Num>,
impl<Num> From<Num> for Rational where
Integer: From<Num>,
[src]
Integer: From<Num>,
impl<Num, Den> Assign<(Num, Den)> for Rational where
Integer: Assign<Num> + Assign<Den>,
[src]
Integer: Assign<Num> + Assign<Den>,
impl<Num, Den> From<(Num, Den)> for Rational where
Integer: From<Num> + From<Den>,
[src]
Integer: From<Num> + From<Den>,
impl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational where
Integer: Assign<&'a Num> + Assign<&'a Den>,
[src]
Integer: Assign<&'a Num> + Assign<&'a Den>,
impl<'a, Num, Den> From<&'a (Num, Den)> for Rational where
Integer: From<&'a Num> + From<&'a Den>,
[src]
Integer: From<&'a Num> + From<&'a Den>,
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
[src]
Performs the +
operation.
impl<'a> Add<&'a Float> for Rational
[src]
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddOwnedRationalIncomplete<'a>
[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 &'a Rational
[src]
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddRationalIncomplete<'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<&'a Float> for Rational
[src]
type Output = SubFromOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubFromOwnedRationalIncomplete<'a>
[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 &'a Rational
[src]
type Output = SubOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubOwnedRationalIncomplete<'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<&'a Float> for Rational
[src]
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulOwnedRationalIncomplete<'a>
[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 &'a Rational
[src]
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulRationalIncomplete<'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<&'a Float> for Rational
[src]
type Output = DivFromOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivFromOwnedRationalIncomplete<'a>
[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 &'a Rational
[src]
type Output = DivOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivOwnedRationalIncomplete<'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 Add<Complex> for Rational
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
Performs the +
operation.
impl<'a> Add<&'a Complex> for Rational
[src]
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> AddOwnedRationalIncomplete<'a>
[src]
Performs the +
operation.
impl<'a> Add<Complex> for &'a Rational
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
Performs the +
operation.
impl<'a> Add<&'a Complex> for &'a Rational
[src]
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> AddRationalIncomplete<'a>
[src]
Performs the +
operation.
impl Sub<Complex> for Rational
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
Performs the -
operation.
impl<'a> Sub<&'a Complex> for Rational
[src]
type Output = SubFromOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> SubFromOwnedRationalIncomplete<'a>
[src]
Performs the -
operation.
impl<'a> Sub<Complex> for &'a Rational
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
Performs the -
operation.
impl<'a> Sub<&'a Complex> for &'a Rational
[src]
type Output = SubOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> SubOwnedRationalIncomplete<'a>
[src]
Performs the -
operation.
impl Mul<Complex> for Rational
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
Performs the *
operation.
impl<'a> Mul<&'a Complex> for Rational
[src]
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> MulOwnedRationalIncomplete<'a>
[src]
Performs the *
operation.
impl<'a> Mul<Complex> for &'a Rational
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
Performs the *
operation.
impl<'a> Mul<&'a Complex> for &'a Rational
[src]
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> MulRationalIncomplete<'a>
[src]
Performs the *
operation.