Struct rug::Rational [−][src]
#[repr(transparent)]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]
impl Rational
pub fn new() -> Self
[src]
pub fn new() -> Self
Constructs a new arbitrary-precision Rational
number with
value 0.
Examples
use rug::Rational; let r = Rational::new(); assert_eq!(r, 0);
pub unsafe fn from_raw(raw: mpq_t) -> Self
[src]
pub unsafe fn from_raw(raw: mpq_t) -> Self
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 }
pub fn into_raw(self) -> mpq_t
[src]
pub fn into_raw(self) -> mpq_t
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); } }
pub fn as_raw(&self) -> *const mpq_t
[src]
pub fn as_raw(&self) -> *const mpq_t
Returns a pointer to the inner 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)); }
pub fn as_raw_mut(&mut self) -> *mut mpq_t
[src]
pub fn as_raw_mut(&mut self) -> *mut mpq_t
Returns an unsafe mutable pointer to the inner 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)); }
pub fn from_f32(value: f32) -> Option<Self>
[src]
pub fn from_f32(value: f32) -> Option<Self>
Creates a Rational
number from an f32
if it is
finite, losing no precision.
If the compiler supports TryFrom
, this conversion can also
be performed using Rational::try_from(value)
.
Examples
use rug::Rational; use std::f32; // -17.125 can be stored exactly as f32 let r = Rational::from_f32(-17.125).unwrap(); assert_eq!(r, (-17125, 1000)); let inf = Rational::from_f32(f32::INFINITY); assert!(inf.is_none());
pub fn from_f64(value: f64) -> Option<Self>
[src]
pub fn from_f64(value: f64) -> Option<Self>
Creates a Rational
number from an f64
if it is
finite, losing no precision.
If the compiler supports TryFrom
, this conversion can also
be performed using Rational::try_from(value)
.
Examples
use rug::Rational; use std::f64; // -17.125 can be stored exactly as f64 let r = Rational::from_f64(-17.125).unwrap(); assert_eq!(r, (-17125, 1000)); let inf = Rational::from_f64(f64::INFINITY); assert!(inf.is_none());
pub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseRationalError>
[src]
pub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseRationalError>
Parses a Rational
number.
Panics
Panics if radix
is less than 2 or greater than 36.
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);
pub fn parse<S>(src: S) -> Result<ParseIncomplete, ParseRationalError> where
S: AsRef<[u8]>,
[src]
pub fn parse<S>(src: S) -> Result<ParseIncomplete, ParseRationalError> where
S: AsRef<[u8]>,
Parses a decimal string slice (&str
) or byte slice
(&[u8]
) into a Rational
number.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the
unwrapped returned incomplete-computation value 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());
pub fn parse_radix<S>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseRationalError> where
S: AsRef<[u8]>,
[src]
pub fn parse_radix<S>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseRationalError> where
S: AsRef<[u8]>,
Parses a string slice (&str
) or byte slice
(&[u8]
) into a Rational
number.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the
unwrapped returned incomplete-computation value 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.
Panics
Panics if radix
is less than 2 or greater than 36.
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());
pub fn to_f32(&self) -> f32
[src]
pub fn to_f32(&self) -> f32
Converts to an f32
, rounding towards zero.
Examples
use rug::rational::SmallRational; use rug::Rational; 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);
pub fn to_f64(&self) -> f64
[src]
pub fn to_f64(&self) -> f64
Converts to an f64
, rounding towards zero.
Examples
use rug::rational::SmallRational; use rug::Rational; 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);
pub fn to_string_radix(&self, radix: i32) -> String
[src]
pub fn to_string_radix(&self, radix: i32) -> String
Returns a string representation for the specified radix
.
Panics
Panics if radix
is less than 2 or greater than 36.
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");
pub fn assign_f32(&mut self, val: f32) -> Result<(), ()>
[src]
pub fn assign_f32(&mut self, val: f32) -> Result<(), ()>
Assigns from an f32
if it is finite,
losing no precision.
Examples
use rug::Rational; use std::f32; let mut r = Rational::new(); let ret = r.assign_f32(12.75); assert!(ret.is_ok()); assert_eq!(r, (1275, 100)); let ret = r.assign_f32(f32::NAN); assert!(ret.is_err()); assert_eq!(r, (1275, 100));
pub fn assign_f64(&mut self, val: f64) -> Result<(), ()>
[src]
pub fn assign_f64(&mut self, val: f64) -> Result<(), ()>
Assigns from an f64
if it is finite,
losing no precision.
Examples
use rug::Rational; let mut r = Rational::new(); let ret = r.assign_f64(12.75); assert!(ret.is_ok()); assert_eq!(r, (1275, 100)); let ret = r.assign_f64(1.0 / 0.0); assert!(ret.is_err()); assert_eq!(r, (1275, 100));
pub unsafe fn from_canonical<Num, Den>(num: Num, den: Den) -> Self where
Integer: From<Num> + From<Den>,
[src]
pub unsafe fn from_canonical<Num, Den>(num: Num, den: Den) -> Self where
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));
pub unsafe fn assign_canonical<Num, Den>(&mut self, num: Num, den: Den) where
Integer: Assign<Num> + Assign<Den>,
[src]
pub unsafe fn assign_canonical<Num, Den>(&mut self, num: Num, den: Den) where
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));
pub fn numer(&self) -> &Integer
[src]
pub fn numer(&self) -> &Integer
Borrows the numerator as an Integer
.
Examples
use rug::Rational; let r = Rational::from((12, -20)); // r will be canonicalized to -3 / 5 assert_eq!(*r.numer(), -3)
pub fn denom(&self) -> &Integer
[src]
pub fn denom(&self) -> &Integer
Borrows the denominator as an Integer
.
Examples
use rug::Rational; let r = Rational::from((12, -20)); // r will be canonicalized to -3 / 5 assert_eq!(*r.denom(), 5);
pub fn mutate_numer_denom<F>(&mut self, func: F) where
F: FnOnce(&mut Integer, &mut Integer),
[src]
pub fn mutate_numer_denom<F>(&mut self, func: F) where
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.
Panics
Panics if the denominator is 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);
pub unsafe fn as_mut_numer_denom_no_canonicalization(
&mut self
) -> (&mut Integer, &mut Integer)
[src]
pub unsafe fn as_mut_numer_denom_no_canonicalization(
&mut self
) -> (&mut Integer, &mut Integer)
Borrows the numerator and denominator mutably without canonicalizing aftwerwards.
Safety
This function is unsafe because it does not canonicalize the
Rational
number when the borrow ends. The 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);
pub fn into_numer_denom(self) -> (Integer, Integer)
[src]
pub fn into_numer_denom(self) -> (Integer, Integer)
Converts into numerator and denominator Integer
values.
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);
pub fn as_neg(&self) -> BorrowRational
[src]
pub fn as_neg(&self) -> BorrowRational
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);
pub fn as_abs(&self) -> BorrowRational
[src]
pub fn as_abs(&self) -> BorrowRational
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);
pub fn as_recip(&self) -> BorrowRational
[src]
pub fn as_recip(&self) -> BorrowRational
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.
Panics
Panics if the value is zero.
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);
pub fn cmp0(&self) -> Ordering
[src]
pub fn cmp0(&self) -> Ordering
Returns the same result as self.cmp(&0.into())
, 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);
pub fn cmp_abs(&self, other: &Self) -> Ordering
[src]
pub fn cmp_abs(&self, other: &Self) -> Ordering
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);
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
[src]
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Adds a list of Rational
values.
Assign<Src> for Rational
,
From<Src> for Rational
,
AddAssign<Src> for Rational
and
Add<Src> for Rational
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Rational; let values = [ Rational::from((5, 2)), Rational::from((-100_000, 7)), Rational::from(-4), ]; let r = Rational::sum(values.iter()); let sum = Rational::from(r); let expected = (5 * 7 - 100_000 * 2 - 4 * 14, 14); assert_eq!(sum, expected);
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
[src]
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
Finds the dot product of a list of Rational
value pairs.
Assign<Src> for Rational
,
From<Src> for Rational
,
AddAssign<Src> for Rational
and
Add<Src> for Rational
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Rational; let a = [Rational::from((270, 7)), Rational::from((-11, 10))]; let b = [Rational::from(7), Rational::from((1, 2))]; let r = Rational::dot(a.iter().zip(b.iter())); let dot = Rational::from(r); let expected = (270 * 20 - 11, 20); assert_eq!(dot, expected);
pub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
[src]
pub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Multiplies a list of Rational
values.
Assign<Src> for Rational
,
From<Src> for Rational
,
MulAssign<Src> for Rational
and
Mul<Src> for Rational
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Rational; let values = [ Rational::from((5, 2)), Rational::from((-100_000, 7)), Rational::from(-4), ]; let r = Rational::product(values.iter()); let product = Rational::from(r); let expected = (5 * -100_000 * -4, 2 * 7); assert_eq!(product, expected);
pub fn abs(self) -> Self
[src]
pub fn abs(self) -> Self
Computes the absolute value.
Examples
use rug::Rational; let r = Rational::from((-100, 17)); let abs = r.abs(); assert_eq!(abs, (100, 17));
pub fn abs_mut(&mut self)
[src]
pub fn abs_mut(&mut self)
Computes the absolute value.
Examples
use rug::Rational; let mut r = Rational::from((-100, 17)); r.abs_mut(); assert_eq!(r, (100, 17));
pub fn abs_ref(&self) -> AbsIncomplete
[src]
pub fn abs_ref(&self) -> AbsIncomplete
Computes the absolute value.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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));
pub fn signum(self) -> Rational
[src]
pub fn signum(self) -> Rational
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);
pub fn signum_mut(&mut self)
[src]
pub fn signum_mut(&mut self)
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);
pub fn signum_ref(&self) -> SignumIncomplete
[src]
pub fn signum_ref(&self) -> SignumIncomplete
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 incomplete-computation value 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);
pub 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]
pub 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>,
Clamps the value within the specified bounds.
Panics
Panics if the maximum value is less than the minimum value.
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));
pub 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]
pub 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>,
Clamps the value within the specified bounds.
Panics
Panics if the maximum value is less than the minimum value.
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));
pub 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]
pub 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>,
Clamps the value within the specified bounds.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with the
returned incomplete-computation value as Src
.
Panics
Panics if the maximum value is less than the minimum value.
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));
pub fn recip(self) -> Self
[src]
pub fn recip(self) -> Self
Computes the reciprocal.
Panics
Panics if the value is zero.
Examples
use rug::Rational; let r = Rational::from((-100, 17)); let recip = r.recip(); assert_eq!(recip, (-17, 100));
pub fn recip_mut(&mut self)
[src]
pub fn recip_mut(&mut self)
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.
Panics
Panics if the value is zero.
Examples
use rug::Rational; let mut r = Rational::from((-100, 17)); r.recip_mut(); assert_eq!(r, (-17, 100));
pub fn recip_ref(&self) -> RecipIncomplete
[src]
pub fn recip_ref(&self) -> RecipIncomplete
Computes the reciprocal.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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));
pub fn trunc(self) -> Rational
[src]
pub fn trunc(self) -> Rational
Rounds the number towards zero.
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);
pub fn trunc_mut(&mut self)
[src]
pub fn trunc_mut(&mut self)
Rounds the number towards zero.
Examples
use rug::{Assign, Rational}; // -3.7 let mut r = Rational::from((-37, 10)); r.trunc_mut(); assert_eq!(r, -3); // 3.3 r.assign((33, 10)); r.trunc_mut(); assert_eq!(r, 3);
pub fn trunc_ref(&self) -> TruncIncomplete
[src]
pub fn trunc_ref(&self) -> TruncIncomplete
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 incomplete-computation value 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);
pub fn rem_trunc(self) -> Self
[src]
pub fn rem_trunc(self) -> Self
Computes the fractional part of the number.
Examples
use rug::Rational; // -100/17 = -5 - 15/17 let r = Rational::from((-100, 17)); let rem = r.rem_trunc(); assert_eq!(rem, (-15, 17));
pub fn rem_trunc_mut(&mut self)
[src]
pub fn rem_trunc_mut(&mut self)
Computes the fractional part of the number.
Examples
use rug::Rational; // -100/17 = -5 - 15/17 let mut r = Rational::from((-100, 17)); r.rem_trunc_mut(); assert_eq!(r, (-15, 17));
pub fn rem_trunc_ref(&self) -> RemTruncIncomplete
[src]
pub fn rem_trunc_ref(&self) -> RemTruncIncomplete
Computes the fractional part of the number.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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));
pub fn fract_trunc(self, trunc: Integer) -> (Self, Integer)
[src]
pub fn fract_trunc(self, trunc: Integer) -> (Self, Integer)
Computes the fractional and truncated parts of the number.
The initial value of trunc
is ignored.
Examples
use rug::{Integer, Rational}; // -100/17 = -5 - 15/17 let r = Rational::from((-100, 17)); let (fract, trunc) = r.fract_trunc(Integer::new()); assert_eq!(fract, (-15, 17)); assert_eq!(trunc, -5);
pub fn fract_trunc_mut(&mut self, trunc: &mut Integer)
[src]
pub fn fract_trunc_mut(&mut self, trunc: &mut Integer)
Computes the fractional and truncated parts of the number.
The initial value of trunc
is ignored.
Examples
use rug::{Integer, Rational}; // -100/17 = -5 - 15/17 let mut r = Rational::from((-100, 17)); let mut whole = Integer::new(); r.fract_trunc_mut(&mut whole); assert_eq!(r, (-15, 17)); assert_eq!(whole, -5);
pub fn fract_trunc_ref(&self) -> FractTruncIncomplete
[src]
pub fn fract_trunc_ref(&self) -> FractTruncIncomplete
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
incomplete-computation value 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);
pub fn ceil(self) -> Rational
[src]
pub fn ceil(self) -> Rational
Rounds the number upwards (towards plus infinity).
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);
pub fn ceil_mut(&mut self)
[src]
pub fn ceil_mut(&mut self)
Rounds the number upwards (towards plus infinity).
Examples
use rug::{Assign, Rational}; // -3.7 let mut r = Rational::from((-37, 10)); r.ceil_mut(); assert_eq!(r, -3); // 3.3 r.assign((33, 10)); r.ceil_mut(); assert_eq!(r, 4);
pub fn ceil_ref(&self) -> CeilIncomplete
[src]
pub fn ceil_ref(&self) -> CeilIncomplete
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 incomplete-computation value 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);
pub fn rem_ceil(self) -> Self
[src]
pub fn rem_ceil(self) -> Self
Computes the non-positive remainder after rounding up.
Examples
use rug::Rational; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let rem = r.rem_ceil(); assert_eq!(rem, (-2, 17));
pub fn rem_ceil_mut(&mut self)
[src]
pub fn rem_ceil_mut(&mut self)
Computes the non-positive remainder after rounding up.
Examples
use rug::Rational; // 100/17 = 6 - 2/17 let mut r = Rational::from((100, 17)); r.rem_ceil_mut(); assert_eq!(r, (-2, 17));
pub fn rem_ceil_ref(&self) -> RemCeilIncomplete
[src]
pub fn rem_ceil_ref(&self) -> RemCeilIncomplete
Computes the non-positive remainder after rounding up.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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));
pub fn fract_ceil(self, ceil: Integer) -> (Self, Integer)
[src]
pub fn fract_ceil(self, ceil: Integer) -> (Self, Integer)
Computes the fractional and ceil parts of the number.
The fractional part cannot greater than zero. The initial
value of ceil
is ignored.
Examples
use rug::{Integer, Rational}; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let (fract, ceil) = r.fract_ceil(Integer::new()); assert_eq!(fract, (-2, 17)); assert_eq!(ceil, 6);
pub fn fract_ceil_mut(&mut self, ceil: &mut Integer)
[src]
pub fn fract_ceil_mut(&mut self, ceil: &mut Integer)
Computes the fractional and ceil parts of the number.
The fractional part cannot be greater than zero. The initial
value of ceil
is ignored.
Examples
use rug::{Integer, Rational}; // 100/17 = 6 - 2/17 let mut r = Rational::from((100, 17)); let mut ceil = Integer::new(); r.fract_ceil_mut(&mut ceil); assert_eq!(r, (-2, 17)); assert_eq!(ceil, 6);
pub fn fract_ceil_ref(&self) -> FractCeilIncomplete
[src]
pub fn fract_ceil_ref(&self) -> FractCeilIncomplete
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
incomplete-computation value 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);
pub fn floor(self) -> Rational
[src]
pub fn floor(self) -> Rational
Rounds the number downwards (towards minus infinity).
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);
pub fn floor_mut(&mut self)
[src]
pub fn floor_mut(&mut self)
Rounds the number downwards (towards minus infinity).
use rug::{Assign, Rational}; // -3.7 let mut r = Rational::from((-37, 10)); r.floor_mut(); assert_eq!(r, -4); // 3.3 r.assign((33, 10)); r.floor_mut(); assert_eq!(r, 3);
pub fn floor_ref(&self) -> FloorIncomplete
[src]
pub fn floor_ref(&self) -> FloorIncomplete
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 incomplete-computation value 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);
pub fn rem_floor(self) -> Self
[src]
pub fn rem_floor(self) -> Self
Computes the non-negative remainder after rounding down.
Examples
use rug::Rational; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let rem = r.rem_floor(); assert_eq!(rem, (2, 17));
pub fn rem_floor_mut(&mut self)
[src]
pub fn rem_floor_mut(&mut self)
Computes the non-negative remainder after rounding down.
Examples
use rug::Rational; // -100/17 = -6 + 2/17 let mut r = Rational::from((-100, 17)); r.rem_floor_mut(); assert_eq!(r, (2, 17));
pub fn rem_floor_ref(&self) -> RemFloorIncomplete
[src]
pub fn rem_floor_ref(&self) -> RemFloorIncomplete
Computes the non-negative remainder after rounding down.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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));
pub fn fract_floor(self, floor: Integer) -> (Self, Integer)
[src]
pub fn fract_floor(self, floor: Integer) -> (Self, Integer)
Computes the fractional and floor parts of the number.
The fractional part cannot be negative. The initial value of
floor
is ignored.
Examples
use rug::{Integer, Rational}; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let (fract, floor) = r.fract_floor(Integer::new()); assert_eq!(fract, (2, 17)); assert_eq!(floor, -6);
pub fn fract_floor_mut(&mut self, floor: &mut Integer)
[src]
pub fn fract_floor_mut(&mut self, floor: &mut Integer)
Computes the fractional and floor parts of the number.
The fractional part cannot be negative. The initial value of
floor
is ignored.
Examples
use rug::{Integer, Rational}; // -100/17 = -6 + 2/17 let mut r = Rational::from((-100, 17)); let mut floor = Integer::new(); r.fract_floor_mut(&mut floor); assert_eq!(r, (2, 17)); assert_eq!(floor, -6);
pub fn fract_floor_ref(&self) -> FractFloorIncomplete
[src]
pub fn fract_floor_ref(&self) -> FractFloorIncomplete
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
incomplete-computation value 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);
pub fn round(self) -> Rational
[src]
pub fn round(self) -> Rational
Rounds the number to the nearest 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);
pub fn round_mut(&mut self)
[src]
pub fn round_mut(&mut self)
Rounds the number to the nearest integer.
When the number lies exactly between two integers, it is rounded away from zero.
Examples
use rug::{Assign, Rational}; // -3.5 let mut r = Rational::from((-35, 10)); r.round_mut(); assert_eq!(r, -4); // 3.7 r.assign((37, 10)); r.round_mut(); assert_eq!(r, 4);
pub fn round_ref(&self) -> RoundIncomplete
[src]
pub fn round_ref(&self) -> RoundIncomplete
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 incomplete-computation value 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);
pub fn rem_round(self) -> Self
[src]
pub fn rem_round(self) -> Self
Computes the remainder after rounding to the nearest integer.
Examples
use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let rem1 = r1.rem_round(); assert_eq!(rem1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let rem2 = r2.rem_round(); assert_eq!(rem2, (-3, 10));
pub fn rem_round_mut(&mut self)
[src]
pub fn rem_round_mut(&mut self)
Computes the remainder after rounding to the nearest integer.
Examples
use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let mut r1 = Rational::from((-35, 10)); r1.rem_round_mut(); assert_eq!(r1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let mut r2 = Rational::from((37, 10)); r2.rem_round_mut(); assert_eq!(r2, (-3, 10));
pub fn rem_round_ref(&self) -> RemRoundIncomplete
[src]
pub fn rem_round_ref(&self) -> RemRoundIncomplete
Computes the remainder after rounding to the nearest integer.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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));
pub fn fract_round(self, round: Integer) -> (Self, Integer)
[src]
pub fn fract_round(self, round: Integer) -> (Self, Integer)
Computes the fractional and rounded parts of the number.
The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.
Examples
use rug::{Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let (fract1, round1) = r1.fract_round(Integer::new()); assert_eq!(fract1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let (fract2, round2) = r2.fract_round(Integer::new()); assert_eq!(fract2, (-3, 10)); assert_eq!(round2, 4);
pub fn fract_round_mut(&mut self, round: &mut Integer)
[src]
pub fn fract_round_mut(&mut self, round: &mut Integer)
Computes the fractional and round parts of the number.
The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.
Examples
use rug::{Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let mut r1 = Rational::from((-35, 10)); let mut round1 = Integer::new(); r1.fract_round_mut(&mut round1); assert_eq!(r1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let mut r2 = Rational::from((37, 10)); let mut round2 = Integer::new(); r2.fract_round_mut(&mut round2); assert_eq!(r2, (-3, 10)); assert_eq!(round2, 4);
pub fn fract_round_ref(&self) -> FractRoundIncomplete
[src]
pub fn fract_round_ref(&self) -> FractRoundIncomplete
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
incomplete-computation value 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);
pub fn square(self) -> Self
[src]
pub fn square(self) -> Self
Computes the square.
Examples
use rug::Rational; let r = Rational::from((-13, 2)); let square = r.square(); assert_eq!(square, (169, 4));
pub fn square_mut(&mut self)
[src]
pub fn square_mut(&mut self)
Computes the square.
Examples
use rug::Rational; let mut r = Rational::from((-13, 2)); r.square_mut(); assert_eq!(r, (169, 4));
pub fn square_ref(&self) -> SquareIncomplete
[src]
pub fn square_ref(&self) -> SquareIncomplete
Computes the square.
Assign<Src> for Rational
and
From<Src> for Rational
are implemented with
the returned incomplete-computation value 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]
impl Neg for Rational
type Output = Rational
The resulting type after applying the -
operator.
fn neg(self) -> Rational
[src]
fn neg(self) -> Rational
Performs the unary -
operation.
impl NegAssign for Rational
[src]
impl NegAssign for Rational
fn neg_assign(&mut self)
[src]
fn neg_assign(&mut self)
Peforms the negation. Read more
impl<'a> Neg for &'a Rational
[src]
impl<'a> Neg for &'a Rational
type Output = NegIncomplete<'a>
The resulting type after applying the -
operator.
fn neg(self) -> NegIncomplete<'a>
[src]
fn neg(self) -> NegIncomplete<'a>
Performs the unary -
operation.
impl Add<Rational> for Rational
[src]
impl Add<Rational> for Rational
type Output = Rational
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> Rational
[src]
fn add(self, rhs: Rational) -> Rational
Performs the +
operation.
impl<'a> Add<&'a Rational> for Rational
[src]
impl<'a> Add<&'a Rational> for Rational
type Output = Rational
The resulting type after applying the +
operator.
fn add(self, rhs: &Rational) -> Rational
[src]
fn add(self, rhs: &Rational) -> Rational
Performs the +
operation.
impl<'a> Add<Rational> for &'a Rational
[src]
impl<'a> Add<Rational> for &'a Rational
type Output = Rational
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> Rational
[src]
fn add(self, rhs: Rational) -> Rational
Performs the +
operation.
impl<'a> Add<&'a Rational> for &'a Rational
[src]
impl<'a> Add<&'a Rational> for &'a Rational
type Output = AddIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Rational) -> AddIncomplete
[src]
fn add(self, rhs: &'a Rational) -> AddIncomplete
Performs the +
operation.
impl AddAssign<Rational> for Rational
[src]
impl AddAssign<Rational> for Rational
fn add_assign(&mut self, rhs: Rational)
[src]
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation.
impl<'a> AddAssign<&'a Rational> for Rational
[src]
impl<'a> AddAssign<&'a Rational> for Rational
fn add_assign(&mut self, rhs: &Rational)
[src]
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation.
impl AddFrom<Rational> for Rational
[src]
impl AddFrom<Rational> for Rational
impl<'a> AddFrom<&'a Rational> for Rational
[src]
impl<'a> AddFrom<&'a Rational> for Rational
impl Sub<Rational> for Rational
[src]
impl Sub<Rational> for Rational
type Output = Rational
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> Rational
[src]
fn sub(self, rhs: Rational) -> Rational
Performs the -
operation.
impl<'a> Sub<&'a Rational> for Rational
[src]
impl<'a> Sub<&'a Rational> for Rational
type Output = Rational
The resulting type after applying the -
operator.
fn sub(self, rhs: &Rational) -> Rational
[src]
fn sub(self, rhs: &Rational) -> Rational
Performs the -
operation.
impl<'a> Sub<Rational> for &'a Rational
[src]
impl<'a> Sub<Rational> for &'a Rational
type Output = Rational
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> Rational
[src]
fn sub(self, rhs: Rational) -> Rational
Performs the -
operation.
impl<'a> Sub<&'a Rational> for &'a Rational
[src]
impl<'a> Sub<&'a Rational> for &'a Rational
type Output = SubIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Rational) -> SubIncomplete
[src]
fn sub(self, rhs: &'a Rational) -> SubIncomplete
Performs the -
operation.
impl SubAssign<Rational> for Rational
[src]
impl SubAssign<Rational> for Rational
fn sub_assign(&mut self, rhs: Rational)
[src]
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation.
impl<'a> SubAssign<&'a Rational> for Rational
[src]
impl<'a> SubAssign<&'a Rational> for Rational
fn sub_assign(&mut self, rhs: &Rational)
[src]
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation.
impl SubFrom<Rational> for Rational
[src]
impl SubFrom<Rational> for Rational
impl<'a> SubFrom<&'a Rational> for Rational
[src]
impl<'a> SubFrom<&'a Rational> for Rational
impl Mul<Rational> for Rational
[src]
impl Mul<Rational> for Rational
type Output = Rational
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> Rational
[src]
fn mul(self, rhs: Rational) -> Rational
Performs the *
operation.
impl<'a> Mul<&'a Rational> for Rational
[src]
impl<'a> Mul<&'a Rational> for Rational
type Output = Rational
The resulting type after applying the *
operator.
fn mul(self, rhs: &Rational) -> Rational
[src]
fn mul(self, rhs: &Rational) -> Rational
Performs the *
operation.
impl<'a> Mul<Rational> for &'a Rational
[src]
impl<'a> Mul<Rational> for &'a Rational
type Output = Rational
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> Rational
[src]
fn mul(self, rhs: Rational) -> Rational
Performs the *
operation.
impl<'a> Mul<&'a Rational> for &'a Rational
[src]
impl<'a> Mul<&'a Rational> for &'a Rational
type Output = MulIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Rational) -> MulIncomplete
[src]
fn mul(self, rhs: &'a Rational) -> MulIncomplete
Performs the *
operation.
impl MulAssign<Rational> for Rational
[src]
impl MulAssign<Rational> for Rational
fn mul_assign(&mut self, rhs: Rational)
[src]
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation.
impl<'a> MulAssign<&'a Rational> for Rational
[src]
impl<'a> MulAssign<&'a Rational> for Rational
fn mul_assign(&mut self, rhs: &Rational)
[src]
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation.
impl MulFrom<Rational> for Rational
[src]
impl MulFrom<Rational> for Rational
impl<'a> MulFrom<&'a Rational> for Rational
[src]
impl<'a> MulFrom<&'a Rational> for Rational
impl Div<Rational> for Rational
[src]
impl Div<Rational> for Rational
type Output = Rational
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> Rational
[src]
fn div(self, rhs: Rational) -> Rational
Performs the /
operation.
impl<'a> Div<&'a Rational> for Rational
[src]
impl<'a> Div<&'a Rational> for Rational
type Output = Rational
The resulting type after applying the /
operator.
fn div(self, rhs: &Rational) -> Rational
[src]
fn div(self, rhs: &Rational) -> Rational
Performs the /
operation.
impl<'a> Div<Rational> for &'a Rational
[src]
impl<'a> Div<Rational> for &'a Rational
type Output = Rational
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> Rational
[src]
fn div(self, rhs: Rational) -> Rational
Performs the /
operation.
impl<'a> Div<&'a Rational> for &'a Rational
[src]
impl<'a> Div<&'a Rational> for &'a Rational
type Output = DivIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Rational) -> DivIncomplete
[src]
fn div(self, rhs: &'a Rational) -> DivIncomplete
Performs the /
operation.
impl DivAssign<Rational> for Rational
[src]
impl DivAssign<Rational> for Rational
fn div_assign(&mut self, rhs: Rational)
[src]
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation.
impl<'a> DivAssign<&'a Rational> for Rational
[src]
impl<'a> DivAssign<&'a Rational> for Rational
fn div_assign(&mut self, rhs: &Rational)
[src]
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation.
impl DivFrom<Rational> for Rational
[src]
impl DivFrom<Rational> for Rational
impl<'a> DivFrom<&'a Rational> for Rational
[src]
impl<'a> DivFrom<&'a Rational> for Rational
impl Shl<i32> for Rational
[src]
impl Shl<i32> for Rational
type Output = Rational
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> Rational
[src]
fn shl(self, rhs: i32) -> Rational
Performs the <<
operation.
impl<'t> Shl<&'t i32> for Rational
[src]
impl<'t> Shl<&'t i32> for Rational
type Output = Rational
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> Rational
[src]
fn shl(self, rhs: &i32) -> Rational
Performs the <<
operation.
impl<'b> Shl<i32> for &'b Rational
[src]
impl<'b> Shl<i32> for &'b Rational
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>
[src]
fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>
Performs the <<
operation.
impl<'t, 'b> Shl<&'t i32> for &'b Rational
[src]
impl<'t, 'b> Shl<&'t i32> for &'b Rational
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b>
[src]
fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b>
Performs the <<
operation.
impl ShlAssign<i32> for Rational
[src]
impl ShlAssign<i32> for Rational
fn shl_assign(&mut self, rhs: i32)
[src]
fn shl_assign(&mut self, rhs: i32)
Performs the <<=
operation.
impl<'t> ShlAssign<&'t i32> for Rational
[src]
impl<'t> ShlAssign<&'t i32> for Rational
fn shl_assign(&mut self, rhs: &i32)
[src]
fn shl_assign(&mut self, rhs: &i32)
Performs the <<=
operation.
impl Shr<i32> for Rational
[src]
impl Shr<i32> for Rational
type Output = Rational
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> Rational
[src]
fn shr(self, rhs: i32) -> Rational
Performs the >>
operation.
impl<'t> Shr<&'t i32> for Rational
[src]
impl<'t> Shr<&'t i32> for Rational
type Output = Rational
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> Rational
[src]
fn shr(self, rhs: &i32) -> Rational
Performs the >>
operation.
impl<'b> Shr<i32> for &'b Rational
[src]
impl<'b> Shr<i32> for &'b Rational
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>
[src]
fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>
Performs the >>
operation.
impl<'t, 'b> Shr<&'t i32> for &'b Rational
[src]
impl<'t, 'b> Shr<&'t i32> for &'b Rational
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b>
[src]
fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b>
Performs the >>
operation.
impl ShrAssign<i32> for Rational
[src]
impl ShrAssign<i32> for Rational
fn shr_assign(&mut self, rhs: i32)
[src]
fn shr_assign(&mut self, rhs: i32)
Performs the >>=
operation.
impl<'t> ShrAssign<&'t i32> for Rational
[src]
impl<'t> ShrAssign<&'t i32> for Rational
fn shr_assign(&mut self, rhs: &i32)
[src]
fn shr_assign(&mut self, rhs: &i32)
Performs the >>=
operation.
impl Pow<i32> for Rational
[src]
impl Pow<i32> for Rational
type Output = Rational
The resulting type after the power operation.
fn pow(self, rhs: i32) -> Rational
[src]
fn pow(self, rhs: i32) -> Rational
Performs the power operation. Read more
impl<'t> Pow<&'t i32> for Rational
[src]
impl<'t> Pow<&'t i32> for Rational
type Output = Rational
The resulting type after the power operation.
fn pow(self, rhs: &i32) -> Rational
[src]
fn pow(self, rhs: &i32) -> Rational
Performs the power operation. Read more
impl<'b> Pow<i32> for &'b Rational
[src]
impl<'b> Pow<i32> for &'b Rational
type Output = PowI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: i32) -> PowI32Incomplete<'b>
[src]
fn pow(self, rhs: i32) -> PowI32Incomplete<'b>
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t i32> for &'b Rational
[src]
impl<'t, 'b> Pow<&'t i32> for &'b Rational
type Output = PowI32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>
[src]
fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>
Performs the power operation. Read more
impl PowAssign<i32> for Rational
[src]
impl PowAssign<i32> for Rational
fn pow_assign(&mut self, rhs: i32)
[src]
fn pow_assign(&mut self, rhs: i32)
Peforms the power operation. Read more
impl<'t> PowAssign<&'t i32> for Rational
[src]
impl<'t> PowAssign<&'t i32> for Rational
fn pow_assign(&mut self, rhs: &i32)
[src]
fn pow_assign(&mut self, rhs: &i32)
Peforms the power operation. Read more
impl Shl<u32> for Rational
[src]
impl Shl<u32> for Rational
type Output = Rational
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> Rational
[src]
fn shl(self, rhs: u32) -> Rational
Performs the <<
operation.
impl<'t> Shl<&'t u32> for Rational
[src]
impl<'t> Shl<&'t u32> for Rational
type Output = Rational
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> Rational
[src]
fn shl(self, rhs: &u32) -> Rational
Performs the <<
operation.
impl<'b> Shl<u32> for &'b Rational
[src]
impl<'b> Shl<u32> for &'b Rational
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>
[src]
fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>
Performs the <<
operation.
impl<'t, 'b> Shl<&'t u32> for &'b Rational
[src]
impl<'t, 'b> Shl<&'t u32> for &'b Rational
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b>
[src]
fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b>
Performs the <<
operation.
impl ShlAssign<u32> for Rational
[src]
impl ShlAssign<u32> for Rational
fn shl_assign(&mut self, rhs: u32)
[src]
fn shl_assign(&mut self, rhs: u32)
Performs the <<=
operation.
impl<'t> ShlAssign<&'t u32> for Rational
[src]
impl<'t> ShlAssign<&'t u32> for Rational
fn shl_assign(&mut self, rhs: &u32)
[src]
fn shl_assign(&mut self, rhs: &u32)
Performs the <<=
operation.
impl Shr<u32> for Rational
[src]
impl Shr<u32> for Rational
type Output = Rational
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> Rational
[src]
fn shr(self, rhs: u32) -> Rational
Performs the >>
operation.
impl<'t> Shr<&'t u32> for Rational
[src]
impl<'t> Shr<&'t u32> for Rational
type Output = Rational
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> Rational
[src]
fn shr(self, rhs: &u32) -> Rational
Performs the >>
operation.
impl<'b> Shr<u32> for &'b Rational
[src]
impl<'b> Shr<u32> for &'b Rational
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>
[src]
fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>
Performs the >>
operation.
impl<'t, 'b> Shr<&'t u32> for &'b Rational
[src]
impl<'t, 'b> Shr<&'t u32> for &'b Rational
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b>
[src]
fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b>
Performs the >>
operation.
impl ShrAssign<u32> for Rational
[src]
impl ShrAssign<u32> for Rational
fn shr_assign(&mut self, rhs: u32)
[src]
fn shr_assign(&mut self, rhs: u32)
Performs the >>=
operation.
impl<'t> ShrAssign<&'t u32> for Rational
[src]
impl<'t> ShrAssign<&'t u32> for Rational
fn shr_assign(&mut self, rhs: &u32)
[src]
fn shr_assign(&mut self, rhs: &u32)
Performs the >>=
operation.
impl Pow<u32> for Rational
[src]
impl Pow<u32> for Rational
type Output = Rational
The resulting type after the power operation.
fn pow(self, rhs: u32) -> Rational
[src]
fn pow(self, rhs: u32) -> Rational
Performs the power operation. Read more
impl<'t> Pow<&'t u32> for Rational
[src]
impl<'t> Pow<&'t u32> for Rational
type Output = Rational
The resulting type after the power operation.
fn pow(self, rhs: &u32) -> Rational
[src]
fn pow(self, rhs: &u32) -> Rational
Performs the power operation. Read more
impl<'b> Pow<u32> for &'b Rational
[src]
impl<'b> Pow<u32> for &'b Rational
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: u32) -> PowU32Incomplete<'b>
[src]
fn pow(self, rhs: u32) -> PowU32Incomplete<'b>
Performs the power operation. Read more
impl<'t, 'b> Pow<&'t u32> for &'b Rational
[src]
impl<'t, 'b> Pow<&'t u32> for &'b Rational
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>
[src]
fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>
Performs the power operation. Read more
impl PowAssign<u32> for Rational
[src]
impl PowAssign<u32> for Rational
fn pow_assign(&mut self, rhs: u32)
[src]
fn pow_assign(&mut self, rhs: u32)
Peforms the power operation. Read more
impl<'t> PowAssign<&'t u32> for Rational
[src]
impl<'t> PowAssign<&'t u32> for Rational
fn pow_assign(&mut self, rhs: &u32)
[src]
fn pow_assign(&mut self, rhs: &u32)
Peforms the power operation. Read more
impl<T> Sum<T> for Rational where
Rational: AddAssign<T>,
[src]
impl<T> Sum<T> for Rational where
Rational: AddAssign<T>,
fn sum<I>(iter: I) -> Rational where
I: Iterator<Item = T>,
[src]
fn sum<I>(iter: I) -> Rational where
I: Iterator<Item = T>,
Method which takes an iterator and generates Self
from the elements by "summing up" the items. Read more
impl<T> Product<T> for Rational where
Rational: MulAssign<T>,
[src]
impl<T> Product<T> for Rational where
Rational: MulAssign<T>,
fn product<I>(iter: I) -> Rational where
I: Iterator<Item = T>,
[src]
fn product<I>(iter: I) -> Rational where
I: Iterator<Item = T>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl Eq for Rational
[src]
impl Eq for Rational
impl Ord for Rational
[src]
impl Ord for Rational
fn cmp(&self, other: &Rational) -> Ordering
[src]
fn cmp(&self, other: &Rational) -> Ordering
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.21.0[src]
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
impl PartialEq for Rational
[src]
impl PartialEq for Rational
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd for Rational
[src]
impl PartialOrd for Rational
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<Integer> for Rational
fn eq(&self, other: &Integer) -> bool
[src]
fn eq(&self, other: &Integer) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Rational> for Integer
[src]
impl PartialEq<Rational> for Integer
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Integer> for Rational
[src]
impl PartialOrd<Integer> for Rational
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<Rational> for Integer
[src]
impl PartialOrd<Rational> for Integer
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<i8> for Rational
fn eq(&self, other: &i8) -> bool
[src]
fn eq(&self, other: &i8) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<i8> for Rational
[src]
impl PartialOrd<i8> for Rational
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for i8
[src]
impl PartialEq<Rational> for i8
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for i8
[src]
impl PartialOrd<Rational> for i8
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<i16> for Rational
fn eq(&self, other: &i16) -> bool
[src]
fn eq(&self, other: &i16) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<i16> for Rational
[src]
impl PartialOrd<i16> for Rational
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for i16
[src]
impl PartialEq<Rational> for i16
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for i16
[src]
impl PartialOrd<Rational> for i16
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<i32> for Rational
fn eq(&self, other: &i32) -> bool
[src]
fn eq(&self, other: &i32) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<i32> for Rational
[src]
impl PartialOrd<i32> for Rational
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for i32
[src]
impl PartialEq<Rational> for i32
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for i32
[src]
impl PartialOrd<Rational> for i32
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<i64> for Rational
fn eq(&self, other: &i64) -> bool
[src]
fn eq(&self, other: &i64) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<i64> for Rational
[src]
impl PartialOrd<i64> for Rational
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for i64
[src]
impl PartialEq<Rational> for i64
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for i64
[src]
impl PartialOrd<Rational> for i64
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i128> for Rational
[src]
impl PartialEq<i128> for Rational
fn eq(&self, other: &i128) -> bool
[src]
fn eq(&self, other: &i128) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<i128> for Rational
[src]
impl PartialOrd<i128> for Rational
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for i128
[src]
impl PartialEq<Rational> for i128
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for i128
[src]
impl PartialOrd<Rational> for i128
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<isize> for Rational
fn eq(&self, other: &isize) -> bool
[src]
fn eq(&self, other: &isize) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<isize> for Rational
[src]
impl PartialOrd<isize> for Rational
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for isize
[src]
impl PartialEq<Rational> for isize
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for isize
[src]
impl PartialOrd<Rational> for isize
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<u8> for Rational
fn eq(&self, other: &u8) -> bool
[src]
fn eq(&self, other: &u8) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<u8> for Rational
[src]
impl PartialOrd<u8> for Rational
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for u8
[src]
impl PartialEq<Rational> for u8
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for u8
[src]
impl PartialOrd<Rational> for u8
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<u16> for Rational
fn eq(&self, other: &u16) -> bool
[src]
fn eq(&self, other: &u16) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<u16> for Rational
[src]
impl PartialOrd<u16> for Rational
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for u16
[src]
impl PartialEq<Rational> for u16
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for u16
[src]
impl PartialOrd<Rational> for u16
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<u32> for Rational
fn eq(&self, other: &u32) -> bool
[src]
fn eq(&self, other: &u32) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<u32> for Rational
[src]
impl PartialOrd<u32> for Rational
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for u32
[src]
impl PartialEq<Rational> for u32
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for u32
[src]
impl PartialOrd<Rational> for u32
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<u64> for Rational
fn eq(&self, other: &u64) -> bool
[src]
fn eq(&self, other: &u64) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<u64> for Rational
[src]
impl PartialOrd<u64> for Rational
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for u64
[src]
impl PartialEq<Rational> for u64
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for u64
[src]
impl PartialOrd<Rational> for u64
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u128> for Rational
[src]
impl PartialEq<u128> for Rational
fn eq(&self, other: &u128) -> bool
[src]
fn eq(&self, other: &u128) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<u128> for Rational
[src]
impl PartialOrd<u128> for Rational
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for u128
[src]
impl PartialEq<Rational> for u128
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for u128
[src]
impl PartialOrd<Rational> for u128
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<usize> for Rational
fn eq(&self, other: &usize) -> bool
[src]
fn eq(&self, other: &usize) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<usize> for Rational
[src]
impl PartialOrd<usize> for Rational
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for usize
[src]
impl PartialEq<Rational> for usize
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for usize
[src]
impl PartialOrd<Rational> for usize
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, i8)> for Rational
fn eq(&self, other: &(i8, i8)) -> bool
[src]
fn eq(&self, other: &(i8, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, i8)> for Rational
[src]
impl PartialOrd<(i8, i8)> for Rational
fn partial_cmp(&self, other: &(i8, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, i8)
[src]
impl PartialEq<Rational> for (i8, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, i8)
[src]
impl PartialOrd<Rational> for (i8, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, i16)> for Rational
fn eq(&self, other: &(i8, i16)) -> bool
[src]
fn eq(&self, other: &(i8, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, i16)> for Rational
[src]
impl PartialOrd<(i8, i16)> for Rational
fn partial_cmp(&self, other: &(i8, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, i16)
[src]
impl PartialEq<Rational> for (i8, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, i16)
[src]
impl PartialOrd<Rational> for (i8, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, i32)> for Rational
fn eq(&self, other: &(i8, i32)) -> bool
[src]
fn eq(&self, other: &(i8, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, i32)> for Rational
[src]
impl PartialOrd<(i8, i32)> for Rational
fn partial_cmp(&self, other: &(i8, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, i32)
[src]
impl PartialEq<Rational> for (i8, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, i32)
[src]
impl PartialOrd<Rational> for (i8, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, i64)> for Rational
fn eq(&self, other: &(i8, i64)) -> bool
[src]
fn eq(&self, other: &(i8, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, i64)> for Rational
[src]
impl PartialOrd<(i8, i64)> for Rational
fn partial_cmp(&self, other: &(i8, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, i64)
[src]
impl PartialEq<Rational> for (i8, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, i64)
[src]
impl PartialOrd<Rational> for (i8, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i8, i128)> for Rational
[src]
impl PartialEq<(i8, i128)> for Rational
fn eq(&self, other: &(i8, i128)) -> bool
[src]
fn eq(&self, other: &(i8, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, i128)> for Rational
[src]
impl PartialOrd<(i8, i128)> for Rational
fn partial_cmp(&self, other: &(i8, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, i128)
[src]
impl PartialEq<Rational> for (i8, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, i128)
[src]
impl PartialOrd<Rational> for (i8, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, isize)> for Rational
fn eq(&self, other: &(i8, isize)) -> bool
[src]
fn eq(&self, other: &(i8, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, isize)> for Rational
[src]
impl PartialOrd<(i8, isize)> for Rational
fn partial_cmp(&self, other: &(i8, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, isize)
[src]
impl PartialEq<Rational> for (i8, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, isize)
[src]
impl PartialOrd<Rational> for (i8, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, u8)> for Rational
fn eq(&self, other: &(i8, u8)) -> bool
[src]
fn eq(&self, other: &(i8, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, u8)> for Rational
[src]
impl PartialOrd<(i8, u8)> for Rational
fn partial_cmp(&self, other: &(i8, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, u8)
[src]
impl PartialEq<Rational> for (i8, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, u8)
[src]
impl PartialOrd<Rational> for (i8, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, u16)> for Rational
fn eq(&self, other: &(i8, u16)) -> bool
[src]
fn eq(&self, other: &(i8, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, u16)> for Rational
[src]
impl PartialOrd<(i8, u16)> for Rational
fn partial_cmp(&self, other: &(i8, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, u16)
[src]
impl PartialEq<Rational> for (i8, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, u16)
[src]
impl PartialOrd<Rational> for (i8, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, u32)> for Rational
fn eq(&self, other: &(i8, u32)) -> bool
[src]
fn eq(&self, other: &(i8, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, u32)> for Rational
[src]
impl PartialOrd<(i8, u32)> for Rational
fn partial_cmp(&self, other: &(i8, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, u32)
[src]
impl PartialEq<Rational> for (i8, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, u32)
[src]
impl PartialOrd<Rational> for (i8, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, u64)> for Rational
fn eq(&self, other: &(i8, u64)) -> bool
[src]
fn eq(&self, other: &(i8, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, u64)> for Rational
[src]
impl PartialOrd<(i8, u64)> for Rational
fn partial_cmp(&self, other: &(i8, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, u64)
[src]
impl PartialEq<Rational> for (i8, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, u64)
[src]
impl PartialOrd<Rational> for (i8, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i8, u128)> for Rational
[src]
impl PartialEq<(i8, u128)> for Rational
fn eq(&self, other: &(i8, u128)) -> bool
[src]
fn eq(&self, other: &(i8, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, u128)> for Rational
[src]
impl PartialOrd<(i8, u128)> for Rational
fn partial_cmp(&self, other: &(i8, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, u128)
[src]
impl PartialEq<Rational> for (i8, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, u128)
[src]
impl PartialOrd<Rational> for (i8, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i8, usize)> for Rational
fn eq(&self, other: &(i8, usize)) -> bool
[src]
fn eq(&self, other: &(i8, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i8, usize)> for Rational
[src]
impl PartialOrd<(i8, usize)> for Rational
fn partial_cmp(&self, other: &(i8, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i8, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i8, usize)
[src]
impl PartialEq<Rational> for (i8, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i8, usize)
[src]
impl PartialOrd<Rational> for (i8, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, i8)> for Rational
fn eq(&self, other: &(i16, i8)) -> bool
[src]
fn eq(&self, other: &(i16, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, i8)> for Rational
[src]
impl PartialOrd<(i16, i8)> for Rational
fn partial_cmp(&self, other: &(i16, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, i8)
[src]
impl PartialEq<Rational> for (i16, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, i8)
[src]
impl PartialOrd<Rational> for (i16, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, i16)> for Rational
fn eq(&self, other: &(i16, i16)) -> bool
[src]
fn eq(&self, other: &(i16, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, i16)> for Rational
[src]
impl PartialOrd<(i16, i16)> for Rational
fn partial_cmp(&self, other: &(i16, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, i16)
[src]
impl PartialEq<Rational> for (i16, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, i16)
[src]
impl PartialOrd<Rational> for (i16, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, i32)> for Rational
fn eq(&self, other: &(i16, i32)) -> bool
[src]
fn eq(&self, other: &(i16, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, i32)> for Rational
[src]
impl PartialOrd<(i16, i32)> for Rational
fn partial_cmp(&self, other: &(i16, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, i32)
[src]
impl PartialEq<Rational> for (i16, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, i32)
[src]
impl PartialOrd<Rational> for (i16, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, i64)> for Rational
fn eq(&self, other: &(i16, i64)) -> bool
[src]
fn eq(&self, other: &(i16, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, i64)> for Rational
[src]
impl PartialOrd<(i16, i64)> for Rational
fn partial_cmp(&self, other: &(i16, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, i64)
[src]
impl PartialEq<Rational> for (i16, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, i64)
[src]
impl PartialOrd<Rational> for (i16, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i16, i128)> for Rational
[src]
impl PartialEq<(i16, i128)> for Rational
fn eq(&self, other: &(i16, i128)) -> bool
[src]
fn eq(&self, other: &(i16, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, i128)> for Rational
[src]
impl PartialOrd<(i16, i128)> for Rational
fn partial_cmp(&self, other: &(i16, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, i128)
[src]
impl PartialEq<Rational> for (i16, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, i128)
[src]
impl PartialOrd<Rational> for (i16, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, isize)> for Rational
fn eq(&self, other: &(i16, isize)) -> bool
[src]
fn eq(&self, other: &(i16, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, isize)> for Rational
[src]
impl PartialOrd<(i16, isize)> for Rational
fn partial_cmp(&self, other: &(i16, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, isize)
[src]
impl PartialEq<Rational> for (i16, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, isize)
[src]
impl PartialOrd<Rational> for (i16, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, u8)> for Rational
fn eq(&self, other: &(i16, u8)) -> bool
[src]
fn eq(&self, other: &(i16, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, u8)> for Rational
[src]
impl PartialOrd<(i16, u8)> for Rational
fn partial_cmp(&self, other: &(i16, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, u8)
[src]
impl PartialEq<Rational> for (i16, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, u8)
[src]
impl PartialOrd<Rational> for (i16, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, u16)> for Rational
fn eq(&self, other: &(i16, u16)) -> bool
[src]
fn eq(&self, other: &(i16, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, u16)> for Rational
[src]
impl PartialOrd<(i16, u16)> for Rational
fn partial_cmp(&self, other: &(i16, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, u16)
[src]
impl PartialEq<Rational> for (i16, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, u16)
[src]
impl PartialOrd<Rational> for (i16, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, u32)> for Rational
fn eq(&self, other: &(i16, u32)) -> bool
[src]
fn eq(&self, other: &(i16, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, u32)> for Rational
[src]
impl PartialOrd<(i16, u32)> for Rational
fn partial_cmp(&self, other: &(i16, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, u32)
[src]
impl PartialEq<Rational> for (i16, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, u32)
[src]
impl PartialOrd<Rational> for (i16, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, u64)> for Rational
fn eq(&self, other: &(i16, u64)) -> bool
[src]
fn eq(&self, other: &(i16, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, u64)> for Rational
[src]
impl PartialOrd<(i16, u64)> for Rational
fn partial_cmp(&self, other: &(i16, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, u64)
[src]
impl PartialEq<Rational> for (i16, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, u64)
[src]
impl PartialOrd<Rational> for (i16, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i16, u128)> for Rational
[src]
impl PartialEq<(i16, u128)> for Rational
fn eq(&self, other: &(i16, u128)) -> bool
[src]
fn eq(&self, other: &(i16, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, u128)> for Rational
[src]
impl PartialOrd<(i16, u128)> for Rational
fn partial_cmp(&self, other: &(i16, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, u128)
[src]
impl PartialEq<Rational> for (i16, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, u128)
[src]
impl PartialOrd<Rational> for (i16, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i16, usize)> for Rational
fn eq(&self, other: &(i16, usize)) -> bool
[src]
fn eq(&self, other: &(i16, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i16, usize)> for Rational
[src]
impl PartialOrd<(i16, usize)> for Rational
fn partial_cmp(&self, other: &(i16, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i16, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i16, usize)
[src]
impl PartialEq<Rational> for (i16, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i16, usize)
[src]
impl PartialOrd<Rational> for (i16, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, i8)> for Rational
fn eq(&self, other: &(i32, i8)) -> bool
[src]
fn eq(&self, other: &(i32, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, i8)> for Rational
[src]
impl PartialOrd<(i32, i8)> for Rational
fn partial_cmp(&self, other: &(i32, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, i8)
[src]
impl PartialEq<Rational> for (i32, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, i8)
[src]
impl PartialOrd<Rational> for (i32, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, i16)> for Rational
fn eq(&self, other: &(i32, i16)) -> bool
[src]
fn eq(&self, other: &(i32, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, i16)> for Rational
[src]
impl PartialOrd<(i32, i16)> for Rational
fn partial_cmp(&self, other: &(i32, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, i16)
[src]
impl PartialEq<Rational> for (i32, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, i16)
[src]
impl PartialOrd<Rational> for (i32, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, i32)> for Rational
fn eq(&self, other: &(i32, i32)) -> bool
[src]
fn eq(&self, other: &(i32, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, i32)> for Rational
[src]
impl PartialOrd<(i32, i32)> for Rational
fn partial_cmp(&self, other: &(i32, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, i32)
[src]
impl PartialEq<Rational> for (i32, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, i32)
[src]
impl PartialOrd<Rational> for (i32, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, i64)> for Rational
fn eq(&self, other: &(i32, i64)) -> bool
[src]
fn eq(&self, other: &(i32, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, i64)> for Rational
[src]
impl PartialOrd<(i32, i64)> for Rational
fn partial_cmp(&self, other: &(i32, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, i64)
[src]
impl PartialEq<Rational> for (i32, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, i64)
[src]
impl PartialOrd<Rational> for (i32, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i32, i128)> for Rational
[src]
impl PartialEq<(i32, i128)> for Rational
fn eq(&self, other: &(i32, i128)) -> bool
[src]
fn eq(&self, other: &(i32, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, i128)> for Rational
[src]
impl PartialOrd<(i32, i128)> for Rational
fn partial_cmp(&self, other: &(i32, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, i128)
[src]
impl PartialEq<Rational> for (i32, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, i128)
[src]
impl PartialOrd<Rational> for (i32, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, isize)> for Rational
fn eq(&self, other: &(i32, isize)) -> bool
[src]
fn eq(&self, other: &(i32, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, isize)> for Rational
[src]
impl PartialOrd<(i32, isize)> for Rational
fn partial_cmp(&self, other: &(i32, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, isize)
[src]
impl PartialEq<Rational> for (i32, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, isize)
[src]
impl PartialOrd<Rational> for (i32, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, u8)> for Rational
fn eq(&self, other: &(i32, u8)) -> bool
[src]
fn eq(&self, other: &(i32, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, u8)> for Rational
[src]
impl PartialOrd<(i32, u8)> for Rational
fn partial_cmp(&self, other: &(i32, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, u8)
[src]
impl PartialEq<Rational> for (i32, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, u8)
[src]
impl PartialOrd<Rational> for (i32, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, u16)> for Rational
fn eq(&self, other: &(i32, u16)) -> bool
[src]
fn eq(&self, other: &(i32, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, u16)> for Rational
[src]
impl PartialOrd<(i32, u16)> for Rational
fn partial_cmp(&self, other: &(i32, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, u16)
[src]
impl PartialEq<Rational> for (i32, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, u16)
[src]
impl PartialOrd<Rational> for (i32, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, u32)> for Rational
fn eq(&self, other: &(i32, u32)) -> bool
[src]
fn eq(&self, other: &(i32, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, u32)> for Rational
[src]
impl PartialOrd<(i32, u32)> for Rational
fn partial_cmp(&self, other: &(i32, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, u32)
[src]
impl PartialEq<Rational> for (i32, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, u32)
[src]
impl PartialOrd<Rational> for (i32, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, u64)> for Rational
fn eq(&self, other: &(i32, u64)) -> bool
[src]
fn eq(&self, other: &(i32, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, u64)> for Rational
[src]
impl PartialOrd<(i32, u64)> for Rational
fn partial_cmp(&self, other: &(i32, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, u64)
[src]
impl PartialEq<Rational> for (i32, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, u64)
[src]
impl PartialOrd<Rational> for (i32, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i32, u128)> for Rational
[src]
impl PartialEq<(i32, u128)> for Rational
fn eq(&self, other: &(i32, u128)) -> bool
[src]
fn eq(&self, other: &(i32, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, u128)> for Rational
[src]
impl PartialOrd<(i32, u128)> for Rational
fn partial_cmp(&self, other: &(i32, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, u128)
[src]
impl PartialEq<Rational> for (i32, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, u128)
[src]
impl PartialOrd<Rational> for (i32, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i32, usize)> for Rational
fn eq(&self, other: &(i32, usize)) -> bool
[src]
fn eq(&self, other: &(i32, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i32, usize)> for Rational
[src]
impl PartialOrd<(i32, usize)> for Rational
fn partial_cmp(&self, other: &(i32, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i32, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i32, usize)
[src]
impl PartialEq<Rational> for (i32, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i32, usize)
[src]
impl PartialOrd<Rational> for (i32, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, i8)> for Rational
fn eq(&self, other: &(i64, i8)) -> bool
[src]
fn eq(&self, other: &(i64, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, i8)> for Rational
[src]
impl PartialOrd<(i64, i8)> for Rational
fn partial_cmp(&self, other: &(i64, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, i8)
[src]
impl PartialEq<Rational> for (i64, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, i8)
[src]
impl PartialOrd<Rational> for (i64, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, i16)> for Rational
fn eq(&self, other: &(i64, i16)) -> bool
[src]
fn eq(&self, other: &(i64, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, i16)> for Rational
[src]
impl PartialOrd<(i64, i16)> for Rational
fn partial_cmp(&self, other: &(i64, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, i16)
[src]
impl PartialEq<Rational> for (i64, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, i16)
[src]
impl PartialOrd<Rational> for (i64, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, i32)> for Rational
fn eq(&self, other: &(i64, i32)) -> bool
[src]
fn eq(&self, other: &(i64, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, i32)> for Rational
[src]
impl PartialOrd<(i64, i32)> for Rational
fn partial_cmp(&self, other: &(i64, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, i32)
[src]
impl PartialEq<Rational> for (i64, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, i32)
[src]
impl PartialOrd<Rational> for (i64, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, i64)> for Rational
fn eq(&self, other: &(i64, i64)) -> bool
[src]
fn eq(&self, other: &(i64, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, i64)> for Rational
[src]
impl PartialOrd<(i64, i64)> for Rational
fn partial_cmp(&self, other: &(i64, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, i64)
[src]
impl PartialEq<Rational> for (i64, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, i64)
[src]
impl PartialOrd<Rational> for (i64, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i64, i128)> for Rational
[src]
impl PartialEq<(i64, i128)> for Rational
fn eq(&self, other: &(i64, i128)) -> bool
[src]
fn eq(&self, other: &(i64, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, i128)> for Rational
[src]
impl PartialOrd<(i64, i128)> for Rational
fn partial_cmp(&self, other: &(i64, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, i128)
[src]
impl PartialEq<Rational> for (i64, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, i128)
[src]
impl PartialOrd<Rational> for (i64, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, isize)> for Rational
fn eq(&self, other: &(i64, isize)) -> bool
[src]
fn eq(&self, other: &(i64, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, isize)> for Rational
[src]
impl PartialOrd<(i64, isize)> for Rational
fn partial_cmp(&self, other: &(i64, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, isize)
[src]
impl PartialEq<Rational> for (i64, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, isize)
[src]
impl PartialOrd<Rational> for (i64, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, u8)> for Rational
fn eq(&self, other: &(i64, u8)) -> bool
[src]
fn eq(&self, other: &(i64, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, u8)> for Rational
[src]
impl PartialOrd<(i64, u8)> for Rational
fn partial_cmp(&self, other: &(i64, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, u8)
[src]
impl PartialEq<Rational> for (i64, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, u8)
[src]
impl PartialOrd<Rational> for (i64, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, u16)> for Rational
fn eq(&self, other: &(i64, u16)) -> bool
[src]
fn eq(&self, other: &(i64, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, u16)> for Rational
[src]
impl PartialOrd<(i64, u16)> for Rational
fn partial_cmp(&self, other: &(i64, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, u16)
[src]
impl PartialEq<Rational> for (i64, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, u16)
[src]
impl PartialOrd<Rational> for (i64, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, u32)> for Rational
fn eq(&self, other: &(i64, u32)) -> bool
[src]
fn eq(&self, other: &(i64, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, u32)> for Rational
[src]
impl PartialOrd<(i64, u32)> for Rational
fn partial_cmp(&self, other: &(i64, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, u32)
[src]
impl PartialEq<Rational> for (i64, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, u32)
[src]
impl PartialOrd<Rational> for (i64, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, u64)> for Rational
fn eq(&self, other: &(i64, u64)) -> bool
[src]
fn eq(&self, other: &(i64, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, u64)> for Rational
[src]
impl PartialOrd<(i64, u64)> for Rational
fn partial_cmp(&self, other: &(i64, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, u64)
[src]
impl PartialEq<Rational> for (i64, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, u64)
[src]
impl PartialOrd<Rational> for (i64, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i64, u128)> for Rational
[src]
impl PartialEq<(i64, u128)> for Rational
fn eq(&self, other: &(i64, u128)) -> bool
[src]
fn eq(&self, other: &(i64, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, u128)> for Rational
[src]
impl PartialOrd<(i64, u128)> for Rational
fn partial_cmp(&self, other: &(i64, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, u128)
[src]
impl PartialEq<Rational> for (i64, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, u128)
[src]
impl PartialOrd<Rational> for (i64, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(i64, usize)> for Rational
fn eq(&self, other: &(i64, usize)) -> bool
[src]
fn eq(&self, other: &(i64, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i64, usize)> for Rational
[src]
impl PartialOrd<(i64, usize)> for Rational
fn partial_cmp(&self, other: &(i64, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i64, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i64, usize)
[src]
impl PartialEq<Rational> for (i64, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i64, usize)
[src]
impl PartialOrd<Rational> for (i64, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, i8)> for Rational
[src]
impl PartialEq<(i128, i8)> for Rational
fn eq(&self, other: &(i128, i8)) -> bool
[src]
fn eq(&self, other: &(i128, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, i8)> for Rational
[src]
impl PartialOrd<(i128, i8)> for Rational
fn partial_cmp(&self, other: &(i128, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, i8)
[src]
impl PartialEq<Rational> for (i128, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, i8)
[src]
impl PartialOrd<Rational> for (i128, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, i16)> for Rational
[src]
impl PartialEq<(i128, i16)> for Rational
fn eq(&self, other: &(i128, i16)) -> bool
[src]
fn eq(&self, other: &(i128, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, i16)> for Rational
[src]
impl PartialOrd<(i128, i16)> for Rational
fn partial_cmp(&self, other: &(i128, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, i16)
[src]
impl PartialEq<Rational> for (i128, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, i16)
[src]
impl PartialOrd<Rational> for (i128, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, i32)> for Rational
[src]
impl PartialEq<(i128, i32)> for Rational
fn eq(&self, other: &(i128, i32)) -> bool
[src]
fn eq(&self, other: &(i128, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, i32)> for Rational
[src]
impl PartialOrd<(i128, i32)> for Rational
fn partial_cmp(&self, other: &(i128, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, i32)
[src]
impl PartialEq<Rational> for (i128, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, i32)
[src]
impl PartialOrd<Rational> for (i128, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, i64)> for Rational
[src]
impl PartialEq<(i128, i64)> for Rational
fn eq(&self, other: &(i128, i64)) -> bool
[src]
fn eq(&self, other: &(i128, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, i64)> for Rational
[src]
impl PartialOrd<(i128, i64)> for Rational
fn partial_cmp(&self, other: &(i128, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, i64)
[src]
impl PartialEq<Rational> for (i128, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, i64)
[src]
impl PartialOrd<Rational> for (i128, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, i128)> for Rational
[src]
impl PartialEq<(i128, i128)> for Rational
fn eq(&self, other: &(i128, i128)) -> bool
[src]
fn eq(&self, other: &(i128, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, i128)> for Rational
[src]
impl PartialOrd<(i128, i128)> for Rational
fn partial_cmp(&self, other: &(i128, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, i128)
[src]
impl PartialEq<Rational> for (i128, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, i128)
[src]
impl PartialOrd<Rational> for (i128, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, isize)> for Rational
[src]
impl PartialEq<(i128, isize)> for Rational
fn eq(&self, other: &(i128, isize)) -> bool
[src]
fn eq(&self, other: &(i128, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, isize)> for Rational
[src]
impl PartialOrd<(i128, isize)> for Rational
fn partial_cmp(&self, other: &(i128, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, isize)
[src]
impl PartialEq<Rational> for (i128, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, isize)
[src]
impl PartialOrd<Rational> for (i128, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, u8)> for Rational
[src]
impl PartialEq<(i128, u8)> for Rational
fn eq(&self, other: &(i128, u8)) -> bool
[src]
fn eq(&self, other: &(i128, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, u8)> for Rational
[src]
impl PartialOrd<(i128, u8)> for Rational
fn partial_cmp(&self, other: &(i128, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, u8)
[src]
impl PartialEq<Rational> for (i128, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, u8)
[src]
impl PartialOrd<Rational> for (i128, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, u16)> for Rational
[src]
impl PartialEq<(i128, u16)> for Rational
fn eq(&self, other: &(i128, u16)) -> bool
[src]
fn eq(&self, other: &(i128, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, u16)> for Rational
[src]
impl PartialOrd<(i128, u16)> for Rational
fn partial_cmp(&self, other: &(i128, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, u16)
[src]
impl PartialEq<Rational> for (i128, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, u16)
[src]
impl PartialOrd<Rational> for (i128, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, u32)> for Rational
[src]
impl PartialEq<(i128, u32)> for Rational
fn eq(&self, other: &(i128, u32)) -> bool
[src]
fn eq(&self, other: &(i128, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, u32)> for Rational
[src]
impl PartialOrd<(i128, u32)> for Rational
fn partial_cmp(&self, other: &(i128, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, u32)
[src]
impl PartialEq<Rational> for (i128, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, u32)
[src]
impl PartialOrd<Rational> for (i128, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, u64)> for Rational
[src]
impl PartialEq<(i128, u64)> for Rational
fn eq(&self, other: &(i128, u64)) -> bool
[src]
fn eq(&self, other: &(i128, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, u64)> for Rational
[src]
impl PartialOrd<(i128, u64)> for Rational
fn partial_cmp(&self, other: &(i128, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, u64)
[src]
impl PartialEq<Rational> for (i128, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, u64)
[src]
impl PartialOrd<Rational> for (i128, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, u128)> for Rational
[src]
impl PartialEq<(i128, u128)> for Rational
fn eq(&self, other: &(i128, u128)) -> bool
[src]
fn eq(&self, other: &(i128, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, u128)> for Rational
[src]
impl PartialOrd<(i128, u128)> for Rational
fn partial_cmp(&self, other: &(i128, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, u128)
[src]
impl PartialEq<Rational> for (i128, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, u128)
[src]
impl PartialOrd<Rational> for (i128, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(i128, usize)> for Rational
[src]
impl PartialEq<(i128, usize)> for Rational
fn eq(&self, other: &(i128, usize)) -> bool
[src]
fn eq(&self, other: &(i128, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(i128, usize)> for Rational
[src]
impl PartialOrd<(i128, usize)> for Rational
fn partial_cmp(&self, other: &(i128, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(i128, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (i128, usize)
[src]
impl PartialEq<Rational> for (i128, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (i128, usize)
[src]
impl PartialOrd<Rational> for (i128, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, i8)> for Rational
fn eq(&self, other: &(isize, i8)) -> bool
[src]
fn eq(&self, other: &(isize, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, i8)> for Rational
[src]
impl PartialOrd<(isize, i8)> for Rational
fn partial_cmp(&self, other: &(isize, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, i8)
[src]
impl PartialEq<Rational> for (isize, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, i8)
[src]
impl PartialOrd<Rational> for (isize, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, i16)> for Rational
fn eq(&self, other: &(isize, i16)) -> bool
[src]
fn eq(&self, other: &(isize, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, i16)> for Rational
[src]
impl PartialOrd<(isize, i16)> for Rational
fn partial_cmp(&self, other: &(isize, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, i16)
[src]
impl PartialEq<Rational> for (isize, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, i16)
[src]
impl PartialOrd<Rational> for (isize, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, i32)> for Rational
fn eq(&self, other: &(isize, i32)) -> bool
[src]
fn eq(&self, other: &(isize, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, i32)> for Rational
[src]
impl PartialOrd<(isize, i32)> for Rational
fn partial_cmp(&self, other: &(isize, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, i32)
[src]
impl PartialEq<Rational> for (isize, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, i32)
[src]
impl PartialOrd<Rational> for (isize, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, i64)> for Rational
fn eq(&self, other: &(isize, i64)) -> bool
[src]
fn eq(&self, other: &(isize, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, i64)> for Rational
[src]
impl PartialOrd<(isize, i64)> for Rational
fn partial_cmp(&self, other: &(isize, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, i64)
[src]
impl PartialEq<Rational> for (isize, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, i64)
[src]
impl PartialOrd<Rational> for (isize, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(isize, i128)> for Rational
[src]
impl PartialEq<(isize, i128)> for Rational
fn eq(&self, other: &(isize, i128)) -> bool
[src]
fn eq(&self, other: &(isize, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, i128)> for Rational
[src]
impl PartialOrd<(isize, i128)> for Rational
fn partial_cmp(&self, other: &(isize, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, i128)
[src]
impl PartialEq<Rational> for (isize, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, i128)
[src]
impl PartialOrd<Rational> for (isize, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, isize)> for Rational
fn eq(&self, other: &(isize, isize)) -> bool
[src]
fn eq(&self, other: &(isize, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, isize)> for Rational
[src]
impl PartialOrd<(isize, isize)> for Rational
fn partial_cmp(&self, other: &(isize, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, isize)
[src]
impl PartialEq<Rational> for (isize, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, isize)
[src]
impl PartialOrd<Rational> for (isize, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, u8)> for Rational
fn eq(&self, other: &(isize, u8)) -> bool
[src]
fn eq(&self, other: &(isize, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, u8)> for Rational
[src]
impl PartialOrd<(isize, u8)> for Rational
fn partial_cmp(&self, other: &(isize, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, u8)
[src]
impl PartialEq<Rational> for (isize, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, u8)
[src]
impl PartialOrd<Rational> for (isize, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, u16)> for Rational
fn eq(&self, other: &(isize, u16)) -> bool
[src]
fn eq(&self, other: &(isize, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, u16)> for Rational
[src]
impl PartialOrd<(isize, u16)> for Rational
fn partial_cmp(&self, other: &(isize, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, u16)
[src]
impl PartialEq<Rational> for (isize, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, u16)
[src]
impl PartialOrd<Rational> for (isize, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, u32)> for Rational
fn eq(&self, other: &(isize, u32)) -> bool
[src]
fn eq(&self, other: &(isize, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, u32)> for Rational
[src]
impl PartialOrd<(isize, u32)> for Rational
fn partial_cmp(&self, other: &(isize, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, u32)
[src]
impl PartialEq<Rational> for (isize, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, u32)
[src]
impl PartialOrd<Rational> for (isize, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, u64)> for Rational
fn eq(&self, other: &(isize, u64)) -> bool
[src]
fn eq(&self, other: &(isize, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, u64)> for Rational
[src]
impl PartialOrd<(isize, u64)> for Rational
fn partial_cmp(&self, other: &(isize, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, u64)
[src]
impl PartialEq<Rational> for (isize, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, u64)
[src]
impl PartialOrd<Rational> for (isize, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(isize, u128)> for Rational
[src]
impl PartialEq<(isize, u128)> for Rational
fn eq(&self, other: &(isize, u128)) -> bool
[src]
fn eq(&self, other: &(isize, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, u128)> for Rational
[src]
impl PartialOrd<(isize, u128)> for Rational
fn partial_cmp(&self, other: &(isize, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, u128)
[src]
impl PartialEq<Rational> for (isize, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, u128)
[src]
impl PartialOrd<Rational> for (isize, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(isize, usize)> for Rational
fn eq(&self, other: &(isize, usize)) -> bool
[src]
fn eq(&self, other: &(isize, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(isize, usize)> for Rational
[src]
impl PartialOrd<(isize, usize)> for Rational
fn partial_cmp(&self, other: &(isize, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(isize, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (isize, usize)
[src]
impl PartialEq<Rational> for (isize, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (isize, usize)
[src]
impl PartialOrd<Rational> for (isize, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, i8)> for Rational
fn eq(&self, other: &(u8, i8)) -> bool
[src]
fn eq(&self, other: &(u8, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, i8)> for Rational
[src]
impl PartialOrd<(u8, i8)> for Rational
fn partial_cmp(&self, other: &(u8, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, i8)
[src]
impl PartialEq<Rational> for (u8, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, i8)
[src]
impl PartialOrd<Rational> for (u8, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, i16)> for Rational
fn eq(&self, other: &(u8, i16)) -> bool
[src]
fn eq(&self, other: &(u8, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, i16)> for Rational
[src]
impl PartialOrd<(u8, i16)> for Rational
fn partial_cmp(&self, other: &(u8, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, i16)
[src]
impl PartialEq<Rational> for (u8, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, i16)
[src]
impl PartialOrd<Rational> for (u8, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, i32)> for Rational
fn eq(&self, other: &(u8, i32)) -> bool
[src]
fn eq(&self, other: &(u8, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, i32)> for Rational
[src]
impl PartialOrd<(u8, i32)> for Rational
fn partial_cmp(&self, other: &(u8, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, i32)
[src]
impl PartialEq<Rational> for (u8, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, i32)
[src]
impl PartialOrd<Rational> for (u8, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, i64)> for Rational
fn eq(&self, other: &(u8, i64)) -> bool
[src]
fn eq(&self, other: &(u8, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, i64)> for Rational
[src]
impl PartialOrd<(u8, i64)> for Rational
fn partial_cmp(&self, other: &(u8, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, i64)
[src]
impl PartialEq<Rational> for (u8, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, i64)
[src]
impl PartialOrd<Rational> for (u8, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u8, i128)> for Rational
[src]
impl PartialEq<(u8, i128)> for Rational
fn eq(&self, other: &(u8, i128)) -> bool
[src]
fn eq(&self, other: &(u8, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, i128)> for Rational
[src]
impl PartialOrd<(u8, i128)> for Rational
fn partial_cmp(&self, other: &(u8, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, i128)
[src]
impl PartialEq<Rational> for (u8, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, i128)
[src]
impl PartialOrd<Rational> for (u8, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, isize)> for Rational
fn eq(&self, other: &(u8, isize)) -> bool
[src]
fn eq(&self, other: &(u8, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, isize)> for Rational
[src]
impl PartialOrd<(u8, isize)> for Rational
fn partial_cmp(&self, other: &(u8, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, isize)
[src]
impl PartialEq<Rational> for (u8, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, isize)
[src]
impl PartialOrd<Rational> for (u8, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, u8)> for Rational
fn eq(&self, other: &(u8, u8)) -> bool
[src]
fn eq(&self, other: &(u8, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, u8)> for Rational
[src]
impl PartialOrd<(u8, u8)> for Rational
fn partial_cmp(&self, other: &(u8, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, u8)
[src]
impl PartialEq<Rational> for (u8, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, u8)
[src]
impl PartialOrd<Rational> for (u8, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, u16)> for Rational
fn eq(&self, other: &(u8, u16)) -> bool
[src]
fn eq(&self, other: &(u8, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, u16)> for Rational
[src]
impl PartialOrd<(u8, u16)> for Rational
fn partial_cmp(&self, other: &(u8, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, u16)
[src]
impl PartialEq<Rational> for (u8, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, u16)
[src]
impl PartialOrd<Rational> for (u8, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, u32)> for Rational
fn eq(&self, other: &(u8, u32)) -> bool
[src]
fn eq(&self, other: &(u8, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, u32)> for Rational
[src]
impl PartialOrd<(u8, u32)> for Rational
fn partial_cmp(&self, other: &(u8, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, u32)
[src]
impl PartialEq<Rational> for (u8, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, u32)
[src]
impl PartialOrd<Rational> for (u8, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, u64)> for Rational
fn eq(&self, other: &(u8, u64)) -> bool
[src]
fn eq(&self, other: &(u8, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, u64)> for Rational
[src]
impl PartialOrd<(u8, u64)> for Rational
fn partial_cmp(&self, other: &(u8, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, u64)
[src]
impl PartialEq<Rational> for (u8, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, u64)
[src]
impl PartialOrd<Rational> for (u8, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u8, u128)> for Rational
[src]
impl PartialEq<(u8, u128)> for Rational
fn eq(&self, other: &(u8, u128)) -> bool
[src]
fn eq(&self, other: &(u8, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, u128)> for Rational
[src]
impl PartialOrd<(u8, u128)> for Rational
fn partial_cmp(&self, other: &(u8, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, u128)
[src]
impl PartialEq<Rational> for (u8, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, u128)
[src]
impl PartialOrd<Rational> for (u8, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u8, usize)> for Rational
fn eq(&self, other: &(u8, usize)) -> bool
[src]
fn eq(&self, other: &(u8, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u8, usize)> for Rational
[src]
impl PartialOrd<(u8, usize)> for Rational
fn partial_cmp(&self, other: &(u8, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u8, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u8, usize)
[src]
impl PartialEq<Rational> for (u8, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u8, usize)
[src]
impl PartialOrd<Rational> for (u8, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, i8)> for Rational
fn eq(&self, other: &(u16, i8)) -> bool
[src]
fn eq(&self, other: &(u16, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, i8)> for Rational
[src]
impl PartialOrd<(u16, i8)> for Rational
fn partial_cmp(&self, other: &(u16, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, i8)
[src]
impl PartialEq<Rational> for (u16, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, i8)
[src]
impl PartialOrd<Rational> for (u16, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, i16)> for Rational
fn eq(&self, other: &(u16, i16)) -> bool
[src]
fn eq(&self, other: &(u16, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, i16)> for Rational
[src]
impl PartialOrd<(u16, i16)> for Rational
fn partial_cmp(&self, other: &(u16, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, i16)
[src]
impl PartialEq<Rational> for (u16, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, i16)
[src]
impl PartialOrd<Rational> for (u16, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, i32)> for Rational
fn eq(&self, other: &(u16, i32)) -> bool
[src]
fn eq(&self, other: &(u16, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, i32)> for Rational
[src]
impl PartialOrd<(u16, i32)> for Rational
fn partial_cmp(&self, other: &(u16, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, i32)
[src]
impl PartialEq<Rational> for (u16, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, i32)
[src]
impl PartialOrd<Rational> for (u16, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, i64)> for Rational
fn eq(&self, other: &(u16, i64)) -> bool
[src]
fn eq(&self, other: &(u16, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, i64)> for Rational
[src]
impl PartialOrd<(u16, i64)> for Rational
fn partial_cmp(&self, other: &(u16, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, i64)
[src]
impl PartialEq<Rational> for (u16, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, i64)
[src]
impl PartialOrd<Rational> for (u16, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u16, i128)> for Rational
[src]
impl PartialEq<(u16, i128)> for Rational
fn eq(&self, other: &(u16, i128)) -> bool
[src]
fn eq(&self, other: &(u16, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, i128)> for Rational
[src]
impl PartialOrd<(u16, i128)> for Rational
fn partial_cmp(&self, other: &(u16, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, i128)
[src]
impl PartialEq<Rational> for (u16, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, i128)
[src]
impl PartialOrd<Rational> for (u16, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, isize)> for Rational
fn eq(&self, other: &(u16, isize)) -> bool
[src]
fn eq(&self, other: &(u16, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, isize)> for Rational
[src]
impl PartialOrd<(u16, isize)> for Rational
fn partial_cmp(&self, other: &(u16, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, isize)
[src]
impl PartialEq<Rational> for (u16, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, isize)
[src]
impl PartialOrd<Rational> for (u16, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, u8)> for Rational
fn eq(&self, other: &(u16, u8)) -> bool
[src]
fn eq(&self, other: &(u16, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, u8)> for Rational
[src]
impl PartialOrd<(u16, u8)> for Rational
fn partial_cmp(&self, other: &(u16, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, u8)
[src]
impl PartialEq<Rational> for (u16, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, u8)
[src]
impl PartialOrd<Rational> for (u16, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, u16)> for Rational
fn eq(&self, other: &(u16, u16)) -> bool
[src]
fn eq(&self, other: &(u16, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, u16)> for Rational
[src]
impl PartialOrd<(u16, u16)> for Rational
fn partial_cmp(&self, other: &(u16, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, u16)
[src]
impl PartialEq<Rational> for (u16, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, u16)
[src]
impl PartialOrd<Rational> for (u16, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, u32)> for Rational
fn eq(&self, other: &(u16, u32)) -> bool
[src]
fn eq(&self, other: &(u16, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, u32)> for Rational
[src]
impl PartialOrd<(u16, u32)> for Rational
fn partial_cmp(&self, other: &(u16, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, u32)
[src]
impl PartialEq<Rational> for (u16, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, u32)
[src]
impl PartialOrd<Rational> for (u16, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, u64)> for Rational
fn eq(&self, other: &(u16, u64)) -> bool
[src]
fn eq(&self, other: &(u16, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, u64)> for Rational
[src]
impl PartialOrd<(u16, u64)> for Rational
fn partial_cmp(&self, other: &(u16, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, u64)
[src]
impl PartialEq<Rational> for (u16, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, u64)
[src]
impl PartialOrd<Rational> for (u16, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u16, u128)> for Rational
[src]
impl PartialEq<(u16, u128)> for Rational
fn eq(&self, other: &(u16, u128)) -> bool
[src]
fn eq(&self, other: &(u16, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, u128)> for Rational
[src]
impl PartialOrd<(u16, u128)> for Rational
fn partial_cmp(&self, other: &(u16, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, u128)
[src]
impl PartialEq<Rational> for (u16, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, u128)
[src]
impl PartialOrd<Rational> for (u16, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u16, usize)> for Rational
fn eq(&self, other: &(u16, usize)) -> bool
[src]
fn eq(&self, other: &(u16, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u16, usize)> for Rational
[src]
impl PartialOrd<(u16, usize)> for Rational
fn partial_cmp(&self, other: &(u16, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u16, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u16, usize)
[src]
impl PartialEq<Rational> for (u16, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u16, usize)
[src]
impl PartialOrd<Rational> for (u16, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, i8)> for Rational
fn eq(&self, other: &(u32, i8)) -> bool
[src]
fn eq(&self, other: &(u32, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, i8)> for Rational
[src]
impl PartialOrd<(u32, i8)> for Rational
fn partial_cmp(&self, other: &(u32, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, i8)
[src]
impl PartialEq<Rational> for (u32, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, i8)
[src]
impl PartialOrd<Rational> for (u32, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, i16)> for Rational
fn eq(&self, other: &(u32, i16)) -> bool
[src]
fn eq(&self, other: &(u32, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, i16)> for Rational
[src]
impl PartialOrd<(u32, i16)> for Rational
fn partial_cmp(&self, other: &(u32, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, i16)
[src]
impl PartialEq<Rational> for (u32, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, i16)
[src]
impl PartialOrd<Rational> for (u32, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, i32)> for Rational
fn eq(&self, other: &(u32, i32)) -> bool
[src]
fn eq(&self, other: &(u32, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, i32)> for Rational
[src]
impl PartialOrd<(u32, i32)> for Rational
fn partial_cmp(&self, other: &(u32, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, i32)
[src]
impl PartialEq<Rational> for (u32, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, i32)
[src]
impl PartialOrd<Rational> for (u32, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, i64)> for Rational
fn eq(&self, other: &(u32, i64)) -> bool
[src]
fn eq(&self, other: &(u32, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, i64)> for Rational
[src]
impl PartialOrd<(u32, i64)> for Rational
fn partial_cmp(&self, other: &(u32, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, i64)
[src]
impl PartialEq<Rational> for (u32, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, i64)
[src]
impl PartialOrd<Rational> for (u32, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u32, i128)> for Rational
[src]
impl PartialEq<(u32, i128)> for Rational
fn eq(&self, other: &(u32, i128)) -> bool
[src]
fn eq(&self, other: &(u32, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, i128)> for Rational
[src]
impl PartialOrd<(u32, i128)> for Rational
fn partial_cmp(&self, other: &(u32, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, i128)
[src]
impl PartialEq<Rational> for (u32, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, i128)
[src]
impl PartialOrd<Rational> for (u32, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, isize)> for Rational
fn eq(&self, other: &(u32, isize)) -> bool
[src]
fn eq(&self, other: &(u32, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, isize)> for Rational
[src]
impl PartialOrd<(u32, isize)> for Rational
fn partial_cmp(&self, other: &(u32, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, isize)
[src]
impl PartialEq<Rational> for (u32, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, isize)
[src]
impl PartialOrd<Rational> for (u32, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, u8)> for Rational
fn eq(&self, other: &(u32, u8)) -> bool
[src]
fn eq(&self, other: &(u32, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, u8)> for Rational
[src]
impl PartialOrd<(u32, u8)> for Rational
fn partial_cmp(&self, other: &(u32, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, u8)
[src]
impl PartialEq<Rational> for (u32, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, u8)
[src]
impl PartialOrd<Rational> for (u32, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, u16)> for Rational
fn eq(&self, other: &(u32, u16)) -> bool
[src]
fn eq(&self, other: &(u32, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, u16)> for Rational
[src]
impl PartialOrd<(u32, u16)> for Rational
fn partial_cmp(&self, other: &(u32, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, u16)
[src]
impl PartialEq<Rational> for (u32, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, u16)
[src]
impl PartialOrd<Rational> for (u32, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, u32)> for Rational
fn eq(&self, other: &(u32, u32)) -> bool
[src]
fn eq(&self, other: &(u32, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, u32)> for Rational
[src]
impl PartialOrd<(u32, u32)> for Rational
fn partial_cmp(&self, other: &(u32, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, u32)
[src]
impl PartialEq<Rational> for (u32, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, u32)
[src]
impl PartialOrd<Rational> for (u32, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, u64)> for Rational
fn eq(&self, other: &(u32, u64)) -> bool
[src]
fn eq(&self, other: &(u32, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, u64)> for Rational
[src]
impl PartialOrd<(u32, u64)> for Rational
fn partial_cmp(&self, other: &(u32, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, u64)
[src]
impl PartialEq<Rational> for (u32, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, u64)
[src]
impl PartialOrd<Rational> for (u32, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u32, u128)> for Rational
[src]
impl PartialEq<(u32, u128)> for Rational
fn eq(&self, other: &(u32, u128)) -> bool
[src]
fn eq(&self, other: &(u32, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, u128)> for Rational
[src]
impl PartialOrd<(u32, u128)> for Rational
fn partial_cmp(&self, other: &(u32, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, u128)
[src]
impl PartialEq<Rational> for (u32, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, u128)
[src]
impl PartialOrd<Rational> for (u32, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u32, usize)> for Rational
fn eq(&self, other: &(u32, usize)) -> bool
[src]
fn eq(&self, other: &(u32, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u32, usize)> for Rational
[src]
impl PartialOrd<(u32, usize)> for Rational
fn partial_cmp(&self, other: &(u32, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u32, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u32, usize)
[src]
impl PartialEq<Rational> for (u32, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u32, usize)
[src]
impl PartialOrd<Rational> for (u32, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, i8)> for Rational
fn eq(&self, other: &(u64, i8)) -> bool
[src]
fn eq(&self, other: &(u64, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, i8)> for Rational
[src]
impl PartialOrd<(u64, i8)> for Rational
fn partial_cmp(&self, other: &(u64, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, i8)
[src]
impl PartialEq<Rational> for (u64, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, i8)
[src]
impl PartialOrd<Rational> for (u64, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, i16)> for Rational
fn eq(&self, other: &(u64, i16)) -> bool
[src]
fn eq(&self, other: &(u64, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, i16)> for Rational
[src]
impl PartialOrd<(u64, i16)> for Rational
fn partial_cmp(&self, other: &(u64, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, i16)
[src]
impl PartialEq<Rational> for (u64, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, i16)
[src]
impl PartialOrd<Rational> for (u64, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, i32)> for Rational
fn eq(&self, other: &(u64, i32)) -> bool
[src]
fn eq(&self, other: &(u64, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, i32)> for Rational
[src]
impl PartialOrd<(u64, i32)> for Rational
fn partial_cmp(&self, other: &(u64, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, i32)
[src]
impl PartialEq<Rational> for (u64, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, i32)
[src]
impl PartialOrd<Rational> for (u64, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, i64)> for Rational
fn eq(&self, other: &(u64, i64)) -> bool
[src]
fn eq(&self, other: &(u64, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, i64)> for Rational
[src]
impl PartialOrd<(u64, i64)> for Rational
fn partial_cmp(&self, other: &(u64, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, i64)
[src]
impl PartialEq<Rational> for (u64, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, i64)
[src]
impl PartialOrd<Rational> for (u64, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u64, i128)> for Rational
[src]
impl PartialEq<(u64, i128)> for Rational
fn eq(&self, other: &(u64, i128)) -> bool
[src]
fn eq(&self, other: &(u64, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, i128)> for Rational
[src]
impl PartialOrd<(u64, i128)> for Rational
fn partial_cmp(&self, other: &(u64, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, i128)
[src]
impl PartialEq<Rational> for (u64, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, i128)
[src]
impl PartialOrd<Rational> for (u64, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, isize)> for Rational
fn eq(&self, other: &(u64, isize)) -> bool
[src]
fn eq(&self, other: &(u64, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, isize)> for Rational
[src]
impl PartialOrd<(u64, isize)> for Rational
fn partial_cmp(&self, other: &(u64, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, isize)
[src]
impl PartialEq<Rational> for (u64, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, isize)
[src]
impl PartialOrd<Rational> for (u64, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, u8)> for Rational
fn eq(&self, other: &(u64, u8)) -> bool
[src]
fn eq(&self, other: &(u64, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, u8)> for Rational
[src]
impl PartialOrd<(u64, u8)> for Rational
fn partial_cmp(&self, other: &(u64, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, u8)
[src]
impl PartialEq<Rational> for (u64, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, u8)
[src]
impl PartialOrd<Rational> for (u64, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, u16)> for Rational
fn eq(&self, other: &(u64, u16)) -> bool
[src]
fn eq(&self, other: &(u64, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, u16)> for Rational
[src]
impl PartialOrd<(u64, u16)> for Rational
fn partial_cmp(&self, other: &(u64, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, u16)
[src]
impl PartialEq<Rational> for (u64, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, u16)
[src]
impl PartialOrd<Rational> for (u64, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, u32)> for Rational
fn eq(&self, other: &(u64, u32)) -> bool
[src]
fn eq(&self, other: &(u64, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, u32)> for Rational
[src]
impl PartialOrd<(u64, u32)> for Rational
fn partial_cmp(&self, other: &(u64, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, u32)
[src]
impl PartialEq<Rational> for (u64, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, u32)
[src]
impl PartialOrd<Rational> for (u64, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, u64)> for Rational
fn eq(&self, other: &(u64, u64)) -> bool
[src]
fn eq(&self, other: &(u64, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, u64)> for Rational
[src]
impl PartialOrd<(u64, u64)> for Rational
fn partial_cmp(&self, other: &(u64, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, u64)
[src]
impl PartialEq<Rational> for (u64, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, u64)
[src]
impl PartialOrd<Rational> for (u64, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u64, u128)> for Rational
[src]
impl PartialEq<(u64, u128)> for Rational
fn eq(&self, other: &(u64, u128)) -> bool
[src]
fn eq(&self, other: &(u64, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, u128)> for Rational
[src]
impl PartialOrd<(u64, u128)> for Rational
fn partial_cmp(&self, other: &(u64, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, u128)
[src]
impl PartialEq<Rational> for (u64, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, u128)
[src]
impl PartialOrd<Rational> for (u64, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(u64, usize)> for Rational
fn eq(&self, other: &(u64, usize)) -> bool
[src]
fn eq(&self, other: &(u64, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u64, usize)> for Rational
[src]
impl PartialOrd<(u64, usize)> for Rational
fn partial_cmp(&self, other: &(u64, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u64, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u64, usize)
[src]
impl PartialEq<Rational> for (u64, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u64, usize)
[src]
impl PartialOrd<Rational> for (u64, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, i8)> for Rational
[src]
impl PartialEq<(u128, i8)> for Rational
fn eq(&self, other: &(u128, i8)) -> bool
[src]
fn eq(&self, other: &(u128, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, i8)> for Rational
[src]
impl PartialOrd<(u128, i8)> for Rational
fn partial_cmp(&self, other: &(u128, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, i8)
[src]
impl PartialEq<Rational> for (u128, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, i8)
[src]
impl PartialOrd<Rational> for (u128, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, i16)> for Rational
[src]
impl PartialEq<(u128, i16)> for Rational
fn eq(&self, other: &(u128, i16)) -> bool
[src]
fn eq(&self, other: &(u128, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, i16)> for Rational
[src]
impl PartialOrd<(u128, i16)> for Rational
fn partial_cmp(&self, other: &(u128, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, i16)
[src]
impl PartialEq<Rational> for (u128, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, i16)
[src]
impl PartialOrd<Rational> for (u128, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, i32)> for Rational
[src]
impl PartialEq<(u128, i32)> for Rational
fn eq(&self, other: &(u128, i32)) -> bool
[src]
fn eq(&self, other: &(u128, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, i32)> for Rational
[src]
impl PartialOrd<(u128, i32)> for Rational
fn partial_cmp(&self, other: &(u128, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, i32)
[src]
impl PartialEq<Rational> for (u128, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, i32)
[src]
impl PartialOrd<Rational> for (u128, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, i64)> for Rational
[src]
impl PartialEq<(u128, i64)> for Rational
fn eq(&self, other: &(u128, i64)) -> bool
[src]
fn eq(&self, other: &(u128, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, i64)> for Rational
[src]
impl PartialOrd<(u128, i64)> for Rational
fn partial_cmp(&self, other: &(u128, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, i64)
[src]
impl PartialEq<Rational> for (u128, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, i64)
[src]
impl PartialOrd<Rational> for (u128, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, i128)> for Rational
[src]
impl PartialEq<(u128, i128)> for Rational
fn eq(&self, other: &(u128, i128)) -> bool
[src]
fn eq(&self, other: &(u128, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, i128)> for Rational
[src]
impl PartialOrd<(u128, i128)> for Rational
fn partial_cmp(&self, other: &(u128, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, i128)
[src]
impl PartialEq<Rational> for (u128, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, i128)
[src]
impl PartialOrd<Rational> for (u128, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, isize)> for Rational
[src]
impl PartialEq<(u128, isize)> for Rational
fn eq(&self, other: &(u128, isize)) -> bool
[src]
fn eq(&self, other: &(u128, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, isize)> for Rational
[src]
impl PartialOrd<(u128, isize)> for Rational
fn partial_cmp(&self, other: &(u128, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, isize)
[src]
impl PartialEq<Rational> for (u128, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, isize)
[src]
impl PartialOrd<Rational> for (u128, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, u8)> for Rational
[src]
impl PartialEq<(u128, u8)> for Rational
fn eq(&self, other: &(u128, u8)) -> bool
[src]
fn eq(&self, other: &(u128, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, u8)> for Rational
[src]
impl PartialOrd<(u128, u8)> for Rational
fn partial_cmp(&self, other: &(u128, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, u8)
[src]
impl PartialEq<Rational> for (u128, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, u8)
[src]
impl PartialOrd<Rational> for (u128, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, u16)> for Rational
[src]
impl PartialEq<(u128, u16)> for Rational
fn eq(&self, other: &(u128, u16)) -> bool
[src]
fn eq(&self, other: &(u128, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, u16)> for Rational
[src]
impl PartialOrd<(u128, u16)> for Rational
fn partial_cmp(&self, other: &(u128, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, u16)
[src]
impl PartialEq<Rational> for (u128, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, u16)
[src]
impl PartialOrd<Rational> for (u128, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, u32)> for Rational
[src]
impl PartialEq<(u128, u32)> for Rational
fn eq(&self, other: &(u128, u32)) -> bool
[src]
fn eq(&self, other: &(u128, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, u32)> for Rational
[src]
impl PartialOrd<(u128, u32)> for Rational
fn partial_cmp(&self, other: &(u128, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, u32)
[src]
impl PartialEq<Rational> for (u128, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, u32)
[src]
impl PartialOrd<Rational> for (u128, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, u64)> for Rational
[src]
impl PartialEq<(u128, u64)> for Rational
fn eq(&self, other: &(u128, u64)) -> bool
[src]
fn eq(&self, other: &(u128, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, u64)> for Rational
[src]
impl PartialOrd<(u128, u64)> for Rational
fn partial_cmp(&self, other: &(u128, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, u64)
[src]
impl PartialEq<Rational> for (u128, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, u64)
[src]
impl PartialOrd<Rational> for (u128, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, u128)> for Rational
[src]
impl PartialEq<(u128, u128)> for Rational
fn eq(&self, other: &(u128, u128)) -> bool
[src]
fn eq(&self, other: &(u128, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, u128)> for Rational
[src]
impl PartialOrd<(u128, u128)> for Rational
fn partial_cmp(&self, other: &(u128, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, u128)
[src]
impl PartialEq<Rational> for (u128, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, u128)
[src]
impl PartialOrd<Rational> for (u128, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(u128, usize)> for Rational
[src]
impl PartialEq<(u128, usize)> for Rational
fn eq(&self, other: &(u128, usize)) -> bool
[src]
fn eq(&self, other: &(u128, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(u128, usize)> for Rational
[src]
impl PartialOrd<(u128, usize)> for Rational
fn partial_cmp(&self, other: &(u128, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(u128, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (u128, usize)
[src]
impl PartialEq<Rational> for (u128, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (u128, usize)
[src]
impl PartialOrd<Rational> for (u128, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, i8)> for Rational
fn eq(&self, other: &(usize, i8)) -> bool
[src]
fn eq(&self, other: &(usize, i8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, i8)> for Rational
[src]
impl PartialOrd<(usize, i8)> for Rational
fn partial_cmp(&self, other: &(usize, i8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, i8)
[src]
impl PartialEq<Rational> for (usize, i8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, i8)
[src]
impl PartialOrd<Rational> for (usize, i8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, i16)> for Rational
fn eq(&self, other: &(usize, i16)) -> bool
[src]
fn eq(&self, other: &(usize, i16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, i16)> for Rational
[src]
impl PartialOrd<(usize, i16)> for Rational
fn partial_cmp(&self, other: &(usize, i16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, i16)
[src]
impl PartialEq<Rational> for (usize, i16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, i16)
[src]
impl PartialOrd<Rational> for (usize, i16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, i32)> for Rational
fn eq(&self, other: &(usize, i32)) -> bool
[src]
fn eq(&self, other: &(usize, i32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, i32)> for Rational
[src]
impl PartialOrd<(usize, i32)> for Rational
fn partial_cmp(&self, other: &(usize, i32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, i32)
[src]
impl PartialEq<Rational> for (usize, i32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, i32)
[src]
impl PartialOrd<Rational> for (usize, i32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, i64)> for Rational
fn eq(&self, other: &(usize, i64)) -> bool
[src]
fn eq(&self, other: &(usize, i64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, i64)> for Rational
[src]
impl PartialOrd<(usize, i64)> for Rational
fn partial_cmp(&self, other: &(usize, i64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, i64)
[src]
impl PartialEq<Rational> for (usize, i64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, i64)
[src]
impl PartialOrd<Rational> for (usize, i64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(usize, i128)> for Rational
[src]
impl PartialEq<(usize, i128)> for Rational
fn eq(&self, other: &(usize, i128)) -> bool
[src]
fn eq(&self, other: &(usize, i128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, i128)> for Rational
[src]
impl PartialOrd<(usize, i128)> for Rational
fn partial_cmp(&self, other: &(usize, i128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, i128)
[src]
impl PartialEq<Rational> for (usize, i128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, i128)
[src]
impl PartialOrd<Rational> for (usize, i128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, isize)> for Rational
fn eq(&self, other: &(usize, isize)) -> bool
[src]
fn eq(&self, other: &(usize, isize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, isize)> for Rational
[src]
impl PartialOrd<(usize, isize)> for Rational
fn partial_cmp(&self, other: &(usize, isize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, isize)
[src]
impl PartialEq<Rational> for (usize, isize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, isize)
[src]
impl PartialOrd<Rational> for (usize, isize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, u8)> for Rational
fn eq(&self, other: &(usize, u8)) -> bool
[src]
fn eq(&self, other: &(usize, u8)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, u8)> for Rational
[src]
impl PartialOrd<(usize, u8)> for Rational
fn partial_cmp(&self, other: &(usize, u8)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, u8)
[src]
impl PartialEq<Rational> for (usize, u8)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, u8)
[src]
impl PartialOrd<Rational> for (usize, u8)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, u16)> for Rational
fn eq(&self, other: &(usize, u16)) -> bool
[src]
fn eq(&self, other: &(usize, u16)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, u16)> for Rational
[src]
impl PartialOrd<(usize, u16)> for Rational
fn partial_cmp(&self, other: &(usize, u16)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, u16)
[src]
impl PartialEq<Rational> for (usize, u16)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, u16)
[src]
impl PartialOrd<Rational> for (usize, u16)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, u32)> for Rational
fn eq(&self, other: &(usize, u32)) -> bool
[src]
fn eq(&self, other: &(usize, u32)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, u32)> for Rational
[src]
impl PartialOrd<(usize, u32)> for Rational
fn partial_cmp(&self, other: &(usize, u32)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, u32)
[src]
impl PartialEq<Rational> for (usize, u32)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, u32)
[src]
impl PartialOrd<Rational> for (usize, u32)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, u64)> for Rational
fn eq(&self, other: &(usize, u64)) -> bool
[src]
fn eq(&self, other: &(usize, u64)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, u64)> for Rational
[src]
impl PartialOrd<(usize, u64)> for Rational
fn partial_cmp(&self, other: &(usize, u64)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, u64)
[src]
impl PartialEq<Rational> for (usize, u64)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, u64)
[src]
impl PartialOrd<Rational> for (usize, u64)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<(usize, u128)> for Rational
[src]
impl PartialEq<(usize, u128)> for Rational
fn eq(&self, other: &(usize, u128)) -> bool
[src]
fn eq(&self, other: &(usize, u128)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, u128)> for Rational
[src]
impl PartialOrd<(usize, u128)> for Rational
fn partial_cmp(&self, other: &(usize, u128)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, u128)
[src]
impl PartialEq<Rational> for (usize, u128)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, u128)
[src]
impl PartialOrd<Rational> for (usize, u128)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<(usize, usize)> for Rational
fn eq(&self, other: &(usize, usize)) -> bool
[src]
fn eq(&self, other: &(usize, usize)) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<(usize, usize)> for Rational
[src]
impl PartialOrd<(usize, usize)> for Rational
fn partial_cmp(&self, other: &(usize, usize)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(usize, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for (usize, usize)
[src]
impl PartialEq<Rational> for (usize, usize)
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for (usize, usize)
[src]
impl PartialOrd<Rational> for (usize, usize)
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<f32> for Rational
fn eq(&self, other: &f32) -> bool
[src]
fn eq(&self, other: &f32) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<f32> for Rational
[src]
impl PartialOrd<f32> for Rational
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for f32
[src]
impl PartialEq<Rational> for f32
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for f32
[src]
impl PartialOrd<Rational> for f32
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl PartialEq<f64> for Rational
fn eq(&self, other: &f64) -> bool
[src]
fn eq(&self, other: &f64) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<f64> for Rational
[src]
impl PartialOrd<f64> for Rational
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<Rational> for f64
[src]
impl PartialEq<Rational> for f64
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Rational> for f64
[src]
impl PartialOrd<Rational> for f64
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
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]
impl Serialize for Rational
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<'de> Deserialize<'de> for Rational
[src]
impl<'de> Deserialize<'de> for Rational
fn deserialize<D>(deserializer: D) -> Result<Rational, D::Error> where
D: Deserializer<'de>,
[src]
fn deserialize<D>(deserializer: D) -> Result<Rational, D::Error> where
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]
fn deserialize_in_place<D>(
deserializer: D,
place: &mut Rational
) -> Result<(), D::Error> where
D: Deserializer<'de>,
impl Default for Rational
[src]
impl Default for Rational
impl Clone for Rational
[src]
impl Clone for Rational
fn clone(&self) -> Rational
[src]
fn clone(&self) -> Rational
Returns a copy of the value. Read more
fn clone_from(&mut self, src: &Rational)
[src]
fn clone_from(&mut self, src: &Rational)
Performs copy-assignment from source
. Read more
impl Drop for Rational
[src]
impl Drop for Rational
impl Hash for Rational
[src]
impl Hash for Rational
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
fn hash<H>(&self, state: &mut H) where
H: Hasher,
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]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl FromStr for Rational
[src]
impl FromStr for Rational
type Err = ParseRationalError
The associated error which can be returned from parsing.
fn from_str(src: &str) -> Result<Rational, ParseRationalError>
[src]
fn from_str(src: &str) -> Result<Rational, ParseRationalError>
Parses a string s
to return a value of this type. Read more
impl Display for Rational
[src]
impl Display for Rational
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl Debug for Rational
[src]
impl Debug for Rational
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl Binary for Rational
[src]
impl Binary for Rational
impl Octal for Rational
[src]
impl Octal for Rational
impl LowerHex for Rational
[src]
impl LowerHex for Rational
impl UpperHex for Rational
[src]
impl UpperHex for Rational
impl Assign for Rational
[src]
impl Assign for Rational
impl<'a> Assign<&'a Rational> for Rational
[src]
impl<'a> Assign<&'a Rational> for Rational
impl<'a> From<&'a Rational> for Rational
[src]
impl<'a> From<&'a Rational> for Rational
impl<Num> Assign<Num> for Rational where
Integer: Assign<Num>,
[src]
impl<Num> Assign<Num> for Rational where
Integer: Assign<Num>,
impl<Num> From<Num> for Rational where
Integer: From<Num>,
[src]
impl<Num> From<Num> for Rational where
Integer: From<Num>,
impl<Num, Den> Assign<(Num, Den)> for Rational where
Integer: Assign<Num> + Assign<Den>,
[src]
impl<Num, Den> Assign<(Num, Den)> for Rational where
Integer: Assign<Num> + Assign<Den>,
impl<Num, Den> From<(Num, Den)> for Rational where
Integer: From<Num> + From<Den>,
[src]
impl<Num, Den> From<(Num, Den)> for Rational where
Integer: From<Num> + From<Den>,
impl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational where
Integer: Assign<&'a Num> + Assign<&'a Den>,
[src]
impl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational where
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]
impl<'a, Num, Den> From<&'a (Num, Den)> for Rational where
Integer: From<&'a Num> + From<&'a Den>,
impl TryFrom<f32> for Rational
[src]
impl TryFrom<f32> for Rational
type Error = TryFromFloatError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: f32) -> Result<Self, TryFromFloatError>
[src]
fn try_from(value: f32) -> Result<Self, TryFromFloatError>
try_from
)Performs the conversion.
impl TryFrom<f64> for Rational
[src]
impl TryFrom<f64> for Rational
type Error = TryFromFloatError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: f64) -> Result<Self, TryFromFloatError>
[src]
fn try_from(value: f64) -> Result<Self, TryFromFloatError>
try_from
)Performs the conversion.
impl Send for Rational
[src]
impl Send for Rational
impl Sync for Rational
[src]
impl Sync for Rational
impl Add<Rational> for Float
[src]
impl Add<Rational> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> Float
[src]
fn add(self, rhs: Rational) -> Float
Performs the +
operation.
impl<'a> Add<&'a Rational> for Float
[src]
impl<'a> Add<&'a Rational> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &Rational) -> Float
[src]
fn add(self, rhs: &Rational) -> Float
Performs the +
operation.
impl<'a> Add<&'a Rational> for &'a Float
[src]
impl<'a> Add<&'a Rational> for &'a Float
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Rational) -> AddRationalIncomplete
[src]
fn add(self, rhs: &'a Rational) -> AddRationalIncomplete
Performs the +
operation.
impl AddAssign<Rational> for Float
[src]
impl AddAssign<Rational> for Float
fn add_assign(&mut self, rhs: Rational)
[src]
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation.
impl<'a> AddAssign<&'a Rational> for Float
[src]
impl<'a> AddAssign<&'a Rational> for Float
fn add_assign(&mut self, rhs: &Rational)
[src]
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation.
impl AddAssignRound<Rational> for Float
[src]
impl AddAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Rational> for Float
[src]
impl<'a> AddAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn add_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> Add<Rational> for &'a Float
[src]
impl<'a> Add<Rational> for &'a Float
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>
[src]
fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>
Performs the +
operation.
impl Add<Float> for Rational
[src]
impl Add<Float> for Rational
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for Rational
[src]
impl<'a> Add<&'a Float> for Rational
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddOwnedRationalIncomplete
[src]
fn add(self, rhs: &Float) -> AddOwnedRationalIncomplete
Performs the +
operation.
impl<'a> Add<Float> for &'a Rational
[src]
impl<'a> Add<Float> for &'a Rational
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
fn add(self, rhs: Float) -> Float
Performs the +
operation.
impl<'a> Add<&'a Float> for &'a Rational
[src]
impl<'a> Add<&'a Float> for &'a Rational
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddRationalIncomplete
[src]
fn add(self, rhs: &'a Float) -> AddRationalIncomplete
Performs the +
operation.
impl AddFrom<Rational> for Float
[src]
impl AddFrom<Rational> for Float
impl<'a> AddFrom<&'a Rational> for Float
[src]
impl<'a> AddFrom<&'a Rational> for Float
impl AddFromRound<Rational> for Float
[src]
impl AddFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the addition. Read more
impl<'a> AddFromRound<&'a Rational> for Float
[src]
impl<'a> AddFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn add_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the addition. Read more
impl Sub<Rational> for Float
[src]
impl Sub<Rational> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> Float
[src]
fn sub(self, rhs: Rational) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Rational> for Float
[src]
impl<'a> Sub<&'a Rational> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &Rational) -> Float
[src]
fn sub(self, rhs: &Rational) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Rational> for &'a Float
[src]
impl<'a> Sub<&'a Rational> for &'a Float
type Output = SubRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete
[src]
fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete
Performs the -
operation.
impl SubAssign<Rational> for Float
[src]
impl SubAssign<Rational> for Float
fn sub_assign(&mut self, rhs: Rational)
[src]
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation.
impl<'a> SubAssign<&'a Rational> for Float
[src]
impl<'a> SubAssign<&'a Rational> for Float
fn sub_assign(&mut self, rhs: &Rational)
[src]
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation.
impl SubAssignRound<Rational> for Float
[src]
impl SubAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Rational> for Float
[src]
impl<'a> SubAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn sub_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> Sub<Rational> for &'a Float
[src]
impl<'a> Sub<Rational> for &'a Float
type Output = SubFromRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>
[src]
fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>
Performs the -
operation.
impl Sub<Float> for Rational
[src]
impl Sub<Float> for Rational
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for Rational
[src]
impl<'a> Sub<&'a Float> for Rational
type Output = SubFromOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromOwnedRationalIncomplete
[src]
fn sub(self, rhs: &Float) -> SubFromOwnedRationalIncomplete
Performs the -
operation.
impl<'a> Sub<Float> for &'a Rational
[src]
impl<'a> Sub<Float> for &'a Rational
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
fn sub(self, rhs: Float) -> Float
Performs the -
operation.
impl<'a> Sub<&'a Float> for &'a Rational
[src]
impl<'a> Sub<&'a Float> for &'a Rational
type Output = SubOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubOwnedRationalIncomplete
[src]
fn sub(self, rhs: &'a Float) -> SubOwnedRationalIncomplete
Performs the -
operation.
impl SubFrom<Rational> for Float
[src]
impl SubFrom<Rational> for Float
impl<'a> SubFrom<&'a Rational> for Float
[src]
impl<'a> SubFrom<&'a Rational> for Float
impl SubFromRound<Rational> for Float
[src]
impl SubFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Rational> for Float
[src]
impl<'a> SubFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn sub_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the subtraction. Read more
impl Mul<Rational> for Float
[src]
impl Mul<Rational> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> Float
[src]
fn mul(self, rhs: Rational) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Rational> for Float
[src]
impl<'a> Mul<&'a Rational> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &Rational) -> Float
[src]
fn mul(self, rhs: &Rational) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Rational> for &'a Float
[src]
impl<'a> Mul<&'a Rational> for &'a Float
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete
[src]
fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete
Performs the *
operation.
impl MulAssign<Rational> for Float
[src]
impl MulAssign<Rational> for Float
fn mul_assign(&mut self, rhs: Rational)
[src]
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation.
impl<'a> MulAssign<&'a Rational> for Float
[src]
impl<'a> MulAssign<&'a Rational> for Float
fn mul_assign(&mut self, rhs: &Rational)
[src]
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation.
impl MulAssignRound<Rational> for Float
[src]
impl MulAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Rational> for Float
[src]
impl<'a> MulAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn mul_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> Mul<Rational> for &'a Float
[src]
impl<'a> Mul<Rational> for &'a Float
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>
[src]
fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>
Performs the *
operation.
impl Mul<Float> for Rational
[src]
impl Mul<Float> for Rational
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for Rational
[src]
impl<'a> Mul<&'a Float> for Rational
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulOwnedRationalIncomplete
[src]
fn mul(self, rhs: &Float) -> MulOwnedRationalIncomplete
Performs the *
operation.
impl<'a> Mul<Float> for &'a Rational
[src]
impl<'a> Mul<Float> for &'a Rational
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
fn mul(self, rhs: Float) -> Float
Performs the *
operation.
impl<'a> Mul<&'a Float> for &'a Rational
[src]
impl<'a> Mul<&'a Float> for &'a Rational
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulRationalIncomplete
[src]
fn mul(self, rhs: &'a Float) -> MulRationalIncomplete
Performs the *
operation.
impl MulFrom<Rational> for Float
[src]
impl MulFrom<Rational> for Float
impl<'a> MulFrom<&'a Rational> for Float
[src]
impl<'a> MulFrom<&'a Rational> for Float
impl MulFromRound<Rational> for Float
[src]
impl MulFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Rational> for Float
[src]
impl<'a> MulFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn mul_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the multiplication. Read more
impl Div<Rational> for Float
[src]
impl Div<Rational> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> Float
[src]
fn div(self, rhs: Rational) -> Float
Performs the /
operation.
impl<'a> Div<&'a Rational> for Float
[src]
impl<'a> Div<&'a Rational> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &Rational) -> Float
[src]
fn div(self, rhs: &Rational) -> Float
Performs the /
operation.
impl<'a> Div<&'a Rational> for &'a Float
[src]
impl<'a> Div<&'a Rational> for &'a Float
type Output = DivRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Rational) -> DivRationalIncomplete
[src]
fn div(self, rhs: &'a Rational) -> DivRationalIncomplete
Performs the /
operation.
impl DivAssign<Rational> for Float
[src]
impl DivAssign<Rational> for Float
fn div_assign(&mut self, rhs: Rational)
[src]
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation.
impl<'a> DivAssign<&'a Rational> for Float
[src]
impl<'a> DivAssign<&'a Rational> for Float
fn div_assign(&mut self, rhs: &Rational)
[src]
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation.
impl DivAssignRound<Rational> for Float
[src]
impl DivAssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivAssignRound<&'a Rational> for Float
[src]
impl<'a> DivAssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
[src]
fn div_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering
Performs the division. Read more
impl<'a> Div<Rational> for &'a Float
[src]
impl<'a> Div<Rational> for &'a Float
type Output = DivFromRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> DivFromRationalIncomplete<'a>
[src]
fn div(self, rhs: Rational) -> DivFromRationalIncomplete<'a>
Performs the /
operation.
impl Div<Float> for Rational
[src]
impl Div<Float> for Rational
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for Rational
[src]
impl<'a> Div<&'a Float> for Rational
type Output = DivFromOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromOwnedRationalIncomplete
[src]
fn div(self, rhs: &Float) -> DivFromOwnedRationalIncomplete
Performs the /
operation.
impl<'a> Div<Float> for &'a Rational
[src]
impl<'a> Div<Float> for &'a Rational
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
fn div(self, rhs: Float) -> Float
Performs the /
operation.
impl<'a> Div<&'a Float> for &'a Rational
[src]
impl<'a> Div<&'a Float> for &'a Rational
type Output = DivOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivOwnedRationalIncomplete
[src]
fn div(self, rhs: &'a Float) -> DivOwnedRationalIncomplete
Performs the /
operation.
impl DivFrom<Rational> for Float
[src]
impl DivFrom<Rational> for Float
impl<'a> DivFrom<&'a Rational> for Float
[src]
impl<'a> DivFrom<&'a Rational> for Float
impl DivFromRound<Rational> for Float
[src]
impl DivFromRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: Rational, round: Round) -> Ordering
Performs the division. Read more
impl<'a> DivFromRound<&'a Rational> for Float
[src]
impl<'a> DivFromRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
[src]
fn div_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering
Performs the division. Read more
impl PartialEq<Rational> for Float
[src]
impl PartialEq<Rational> for Float
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Float> for Rational
[src]
impl PartialEq<Float> for Rational
fn eq(&self, other: &Float) -> bool
[src]
fn eq(&self, other: &Float) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialOrd<Float> for Rational
[src]
impl PartialOrd<Float> for Rational
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialOrd<Rational> for Float
[src]
impl PartialOrd<Rational> for Float
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn lt(&self, other: &Rhs) -> bool
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]
fn le(&self, other: &Rhs) -> bool
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]
fn gt(&self, other: &Rhs) -> bool
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]
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<'a> AssignRound<&'a Rational> for Float
[src]
impl<'a> AssignRound<&'a Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Rational, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: &Rational, round: Round) -> Ordering
Peforms the assignment. Read more
impl AssignRound<Rational> for Float
[src]
impl AssignRound<Rational> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Rational, round: Round) -> Ordering
[src]
fn assign_round(&mut self, src: Rational, round: Round) -> Ordering
Peforms the assignment. Read more
impl TryFrom<Float> for Rational
[src]
impl TryFrom<Float> for Rational
type Error = TryFromFloatError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Float) -> Result<Self, TryFromFloatError>
[src]
fn try_from(value: Float) -> Result<Self, TryFromFloatError>
try_from
)Performs the conversion.
impl<'a> TryFrom<&'a Float> for Rational
[src]
impl<'a> TryFrom<&'a Float> for Rational
type Error = TryFromFloatError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Float) -> Result<Self, TryFromFloatError>
[src]
fn try_from(value: &Float) -> Result<Self, TryFromFloatError>
try_from
)Performs the conversion.
impl Add<Rational> for Complex
[src]
impl Add<Rational> for Complex
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> Complex
[src]
fn add(self, rhs: Rational) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Rational> for Complex
[src]
impl<'a> Add<&'a Rational> for Complex
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: &Rational) -> Complex
[src]
fn add(self, rhs: &Rational) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Rational> for &'a Complex
[src]
impl<'a> Add<&'a Rational> for &'a Complex
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Rational) -> AddRationalIncomplete
[src]
fn add(self, rhs: &'a Rational) -> AddRationalIncomplete
Performs the +
operation.
impl AddAssign<Rational> for Complex
[src]
impl AddAssign<Rational> for Complex
fn add_assign(&mut self, rhs: Rational)
[src]
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation.
impl<'a> AddAssign<&'a Rational> for Complex
[src]
impl<'a> AddAssign<&'a Rational> for Complex
fn add_assign(&mut self, rhs: &Rational)
[src]
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation.
impl AddAssignRound<Rational> for Complex
[src]
impl AddAssignRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Rational> for Complex
[src]
impl<'a> AddAssignRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> Add<Rational> for &'a Complex
[src]
impl<'a> Add<Rational> for &'a Complex
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>
[src]
fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>
Performs the +
operation.
impl Add<Complex> for Rational
[src]
impl Add<Complex> for Rational
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
fn add(self, rhs: Complex) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Complex> for Rational
[src]
impl<'a> Add<&'a Complex> for Rational
type Output = AddOwnedRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Complex) -> AddOwnedRationalIncomplete
[src]
fn add(self, rhs: &Complex) -> AddOwnedRationalIncomplete
Performs the +
operation.
impl<'a> Add<Complex> for &'a Rational
[src]
impl<'a> Add<Complex> for &'a Rational
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
fn add(self, rhs: Complex) -> Complex
Performs the +
operation.
impl<'a> Add<&'a Complex> for &'a Rational
[src]
impl<'a> Add<&'a Complex> for &'a Rational
type Output = AddRationalIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> AddRationalIncomplete
[src]
fn add(self, rhs: &'a Complex) -> AddRationalIncomplete
Performs the +
operation.
impl AddFrom<Rational> for Complex
[src]
impl AddFrom<Rational> for Complex
impl<'a> AddFrom<&'a Rational> for Complex
[src]
impl<'a> AddFrom<&'a Rational> for Complex
impl AddFromRound<Rational> for Complex
[src]
impl AddFromRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round(
&mut self,
lhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_from_round(
&mut self,
lhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddFromRound<&'a Rational> for Complex
[src]
impl<'a> AddFromRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round(
&mut self,
lhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn add_from_round(
&mut self,
lhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl Sub<Rational> for Complex
[src]
impl Sub<Rational> for Complex
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> Complex
[src]
fn sub(self, rhs: Rational) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Rational> for Complex
[src]
impl<'a> Sub<&'a Rational> for Complex
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: &Rational) -> Complex
[src]
fn sub(self, rhs: &Rational) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Rational> for &'a Complex
[src]
impl<'a> Sub<&'a Rational> for &'a Complex
type Output = SubRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete
[src]
fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete
Performs the -
operation.
impl SubAssign<Rational> for Complex
[src]
impl SubAssign<Rational> for Complex
fn sub_assign(&mut self, rhs: Rational)
[src]
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation.
impl<'a> SubAssign<&'a Rational> for Complex
[src]
impl<'a> SubAssign<&'a Rational> for Complex
fn sub_assign(&mut self, rhs: &Rational)
[src]
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation.
impl SubAssignRound<Rational> for Complex
[src]
impl SubAssignRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Rational> for Complex
[src]
impl<'a> SubAssignRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> Sub<Rational> for &'a Complex
[src]
impl<'a> Sub<Rational> for &'a Complex
type Output = SubFromRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>
[src]
fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>
Performs the -
operation.
impl Sub<Complex> for Rational
[src]
impl Sub<Complex> for Rational
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
fn sub(self, rhs: Complex) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Complex> for Rational
[src]
impl<'a> Sub<&'a Complex> for Rational
type Output = SubFromOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Complex) -> SubFromOwnedRationalIncomplete
[src]
fn sub(self, rhs: &Complex) -> SubFromOwnedRationalIncomplete
Performs the -
operation.
impl<'a> Sub<Complex> for &'a Rational
[src]
impl<'a> Sub<Complex> for &'a Rational
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
fn sub(self, rhs: Complex) -> Complex
Performs the -
operation.
impl<'a> Sub<&'a Complex> for &'a Rational
[src]
impl<'a> Sub<&'a Complex> for &'a Rational
type Output = SubOwnedRationalIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> SubOwnedRationalIncomplete
[src]
fn sub(self, rhs: &'a Complex) -> SubOwnedRationalIncomplete
Performs the -
operation.
impl SubFrom<Rational> for Complex
[src]
impl SubFrom<Rational> for Complex
impl<'a> SubFrom<&'a Rational> for Complex
[src]
impl<'a> SubFrom<&'a Rational> for Complex
impl SubFromRound<Rational> for Complex
[src]
impl SubFromRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round(
&mut self,
lhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_from_round(
&mut self,
lhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Rational> for Complex
[src]
impl<'a> SubFromRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round(
&mut self,
lhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn sub_from_round(
&mut self,
lhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl Mul<Rational> for Complex
[src]
impl Mul<Rational> for Complex
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> Complex
[src]
fn mul(self, rhs: Rational) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Rational> for Complex
[src]
impl<'a> Mul<&'a Rational> for Complex
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: &Rational) -> Complex
[src]
fn mul(self, rhs: &Rational) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Rational> for &'a Complex
[src]
impl<'a> Mul<&'a Rational> for &'a Complex
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete
[src]
fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete
Performs the *
operation.
impl MulAssign<Rational> for Complex
[src]
impl MulAssign<Rational> for Complex
fn mul_assign(&mut self, rhs: Rational)
[src]
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation.
impl<'a> MulAssign<&'a Rational> for Complex
[src]
impl<'a> MulAssign<&'a Rational> for Complex
fn mul_assign(&mut self, rhs: &Rational)
[src]
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation.
impl MulAssignRound<Rational> for Complex
[src]
impl MulAssignRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Rational> for Complex
[src]
impl<'a> MulAssignRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> Mul<Rational> for &'a Complex
[src]
impl<'a> Mul<Rational> for &'a Complex
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>
[src]
fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>
Performs the *
operation.
impl Mul<Complex> for Rational
[src]
impl Mul<Complex> for Rational
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
fn mul(self, rhs: Complex) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Complex> for Rational
[src]
impl<'a> Mul<&'a Complex> for Rational
type Output = MulOwnedRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Complex) -> MulOwnedRationalIncomplete
[src]
fn mul(self, rhs: &Complex) -> MulOwnedRationalIncomplete
Performs the *
operation.
impl<'a> Mul<Complex> for &'a Rational
[src]
impl<'a> Mul<Complex> for &'a Rational
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
fn mul(self, rhs: Complex) -> Complex
Performs the *
operation.
impl<'a> Mul<&'a Complex> for &'a Rational
[src]
impl<'a> Mul<&'a Complex> for &'a Rational
type Output = MulRationalIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> MulRationalIncomplete
[src]
fn mul(self, rhs: &'a Complex) -> MulRationalIncomplete
Performs the *
operation.
impl MulFrom<Rational> for Complex
[src]
impl MulFrom<Rational> for Complex
impl<'a> MulFrom<&'a Rational> for Complex
[src]
impl<'a> MulFrom<&'a Rational> for Complex
impl MulFromRound<Rational> for Complex
[src]
impl MulFromRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_from_round(
&mut self,
lhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_from_round(
&mut self,
lhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Rational> for Complex
[src]
impl<'a> MulFromRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_from_round(
&mut self,
lhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn mul_from_round(
&mut self,
lhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl Div<Rational> for Complex
[src]
impl Div<Rational> for Complex
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> Complex
[src]
fn div(self, rhs: Rational) -> Complex
Performs the /
operation.
impl<'a> Div<&'a Rational> for Complex
[src]
impl<'a> Div<&'a Rational> for Complex
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: &Rational) -> Complex
[src]
fn div(self, rhs: &Rational) -> Complex
Performs the /
operation.
impl<'a> Div<&'a Rational> for &'a Complex
[src]
impl<'a> Div<&'a Rational> for &'a Complex
type Output = DivRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Rational) -> DivRationalIncomplete
[src]
fn div(self, rhs: &'a Rational) -> DivRationalIncomplete
Performs the /
operation.
impl DivAssign<Rational> for Complex
[src]
impl DivAssign<Rational> for Complex
fn div_assign(&mut self, rhs: Rational)
[src]
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation.
impl<'a> DivAssign<&'a Rational> for Complex
[src]
impl<'a> DivAssign<&'a Rational> for Complex
fn div_assign(&mut self, rhs: &Rational)
[src]
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation.
impl DivAssignRound<Rational> for Complex
[src]
impl DivAssignRound<Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn div_assign_round(
&mut self,
rhs: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivAssignRound<&'a Rational> for Complex
[src]
impl<'a> DivAssignRound<&'a Rational> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
fn div_assign_round(
&mut self,
rhs: &Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> Div<Rational> for &'a Complex
[src]
impl<'a> Div<Rational> for &'a Complex
type Output = DivOwnedRationalIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Rational) -> DivOwnedRationalIncomplete<'a>
[src]
fn div(self, rhs: Rational) -> DivOwnedRationalIncomplete<'a>
Performs the /
operation.
impl PartialEq<Rational> for Complex
[src]
impl PartialEq<Rational> for Complex
fn eq(&self, other: &Rational) -> bool
[src]
fn eq(&self, other: &Rational) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl PartialEq<Complex> for Rational
[src]
impl PartialEq<Complex> for Rational