#[repr(transparent)]pub struct Rational { /* private fields */ }
Expand description
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));
Implementations
sourceimpl Rational
impl Rational
sourcepub const unsafe fn from_raw(raw: mpq_t) -> Self
pub const unsafe fn from_raw(raw: mpq_t) -> Self
Creates a Rational
number from an initialized GMP rational
number.
Safety
- The function must not be used to create a constant
Rational
number, though it can be used to create a staticRational
number. This is because constant values are copied on use, leading to undefined behavior when they are dropped. - The value must be initialized.
- The
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
use core::mem::MaybeUninit;
use gmp_mpfr_sys::gmp;
use rug::Rational;
let r = unsafe {
let mut q = MaybeUninit::uninit();
gmp::mpq_init(q.as_mut_ptr());
let mut q = q.assume_init();
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
This can be used to create a static Rational
number using
MPZ_ROINIT_N
to initialize the raw numerator and
denominator values. See the GMP documentation for details.
use gmp_mpfr_sys::gmp::{self, limb_t, mpq_t};
use rug::{Integer, Rational};
const NUMER_LIMBS: [limb_t; 2] = [0, 5];
const DENOM_LIMBS: [limb_t; 1] = [3];
const MPQ: mpq_t = unsafe {
mpq_t {
num: gmp::MPZ_ROINIT_N(NUMER_LIMBS.as_ptr() as *mut limb_t, -2),
den: gmp::MPZ_ROINIT_N(DENOM_LIMBS.as_ptr() as *mut limb_t, 1),
}
};
// Must *not* be const, otherwise it would lead to undefined
// behavior on use, as it would create a copy that is dropped.
static R: Rational = unsafe { Rational::from_raw(MPQ) };
let numer_check =
-((Integer::from(NUMER_LIMBS[1]) << gmp::NUMB_BITS) + NUMER_LIMBS[0]);
let denom_check = Integer::from(DENOM_LIMBS[0]);
assert_eq!(*R.numer(), numer_check);
assert_eq!(*R.denom(), denom_check);
let check = Rational::from((&numer_check, &denom_check));
assert_eq!(R, check);
assert_eq!(*R.numer(), *check.numer());
assert_eq!(*R.denom(), *check.denom());
sourcepub fn into_raw(self) -> mpq_t
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
use gmp_mpfr_sys::gmp;
use rug::Rational;
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);
}
sourcepub fn as_raw(&self) -> *const mpq_t
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
use gmp_mpfr_sys::gmp;
use rug::Rational;
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));
sourcepub fn as_raw_mut(&mut self) -> *mut mpq_t
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
use gmp_mpfr_sys::gmp;
use rug::Rational;
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));
sourcepub fn from_f32(value: f32) -> Option<Self>
pub fn from_f32(value: f32) -> Option<Self>
Creates a Rational
number from an f32
if it is
finite, losing no precision.
This conversion can also be performed using
Rational::try_from(value)
value.checked_as::<Rational>()
Examples
use core::f32;
use rug::Rational;
// -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());
sourcepub fn from_f64(value: f64) -> Option<Self>
pub fn from_f64(value: f64) -> Option<Self>
Creates a Rational
number from an f64
if it is
finite, losing no precision.
This conversion can also be performed using
Rational::try_from(value)
value.checked_as::<Rational>()
Examples
use core::f64;
use rug::Rational;
// -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());
sourcepub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseRationalError>
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);
sourcepub fn parse<S: AsRef<[u8]>>(
src: S
) -> Result<ParseIncomplete, ParseRationalError>
pub fn parse<S: AsRef<[u8]>>(
src: S
) -> Result<ParseIncomplete, ParseRationalError>
Parses a decimal string slice (&str
) or byte slice
(&[u8]
) into a Rational
number.
The following 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::{Complete, Rational};
assert_eq!(Rational::parse("-12/23").unwrap().complete(), (-12, 23));
assert_eq!(Rational::parse("+ 12 / 23").unwrap().complete(), (12, 23));
let invalid = Rational::parse("12/");
assert!(invalid.is_err());
sourcepub fn parse_radix<S: AsRef<[u8]>>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseRationalError>
pub fn parse_radix<S: AsRef<[u8]>>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseRationalError>
Parses a string slice (&str
) or byte slice
(&[u8]
) into a Rational
number.
The following 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::{Complete, Rational};
let valid1 = Rational::parse_radix("12/23", 4);
assert_eq!(valid1.unwrap().complete(), (2 + 4 * 1, 3 + 4 * 2));
let valid2 = Rational::parse_radix("12 / yz", 36);
assert_eq!(valid2.unwrap().complete(), (2 + 36 * 1, 35 + 36 * 34));
let invalid = Rational::parse_radix("12/23", 3);
assert!(invalid.is_err());
sourcepub fn to_f32(&self) -> f32
pub fn to_f32(&self) -> f32
Converts to an f32
, rounding towards zero.
This conversion can also be performed using
Examples
use core::f32;
use rug::{rational::SmallRational, Rational};
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);
sourcepub fn to_f64(&self) -> f64
pub fn to_f64(&self) -> f64
Converts to an f64
, rounding towards zero.
This conversion can also be performed using
Examples
use core::f64;
use rug::{rational::SmallRational, Rational};
// 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);
sourcepub fn to_string_radix(&self, radix: i32) -> String
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");
sourcepub unsafe fn from_canonical<Num, Den>(num: Num, den: Den) -> Self where
Integer: From<Num> + From<Den>,
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.
There are a few methods that can be called on Rational
numbers that
are not in canonical form:
numer
anddenom
, which treat the numerator and denominator separately- assignment methods, which overwrite the previous value and leave the number in canonical form
mutate_numer_denom
, which treats the numerator and denominator seprarately, and leaves the number in canoncial form
Examples
use rug::Rational;
// -3/5 is in canonical form
let r = unsafe { Rational::from_canonical(-3, 5) };
assert_eq!(r, (-3, 5));
sourcepub unsafe fn assign_canonical<Num, Den>(&mut self, num: Num, den: Den) where
Integer: Assign<Num> + Assign<Den>,
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.
There are a few methods that can be called on Rational
numbers that
are not in canonical form:
numer
anddenom
, which treat the numerator and denominator separately- assignment methods, which overwrite the previous value and leave the number in canonical form
mutate_numer_denom
, which treats the numerator and denominator seprarately, and leaves the number in canoncial form
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));
sourcepub fn mutate_numer_denom<F>(&mut self, func: F) where
F: FnOnce(&mut Integer, &mut Integer),
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);
sourcepub unsafe fn as_mut_numer_denom_no_canonicalization(
&mut self
) -> (&mut Integer, &mut Integer)
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.
There are a few methods that can be called on Rational
numbers that
are not in canonical form:
numer
anddenom
, which treat the numerator and denominator separately- assignment methods, which overwrite the previous value and leave the number in canonical form
mutate_numer_denom
, which treats the numerator and denominator seprarately, and leaves the number in canoncial form
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);
sourcepub fn into_numer_denom(self) -> (Integer, Integer)
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);
sourcepub fn as_neg(&self) -> BorrowRational<'_>
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);
sourcepub fn as_abs(&self) -> BorrowRational<'_>
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);
sourcepub fn as_recip(&self) -> BorrowRational<'_>
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);
sourcepub fn cmp_abs(&self, other: &Self) -> Ordering
pub fn cmp_abs(&self, other: &Self) -> Ordering
Compares the absolute values.
Examples
use core::cmp::Ordering;
use rug::Rational;
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);
sourcepub fn is_integer(&self) -> bool
pub fn is_integer(&self) -> bool
sourcepub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Adds a list of Rational
values.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Rational
From<Src> for Rational
Complete<Completed = Rational> for Src
AddAssign<Src> for Rational
Add<Src> for Rational
,Add<Rational> for Src
SubAssign<Src> for Rational
,SubFrom<Src> for Rational
Sub<Src> for Rational
,Sub<Rational> for Src
Examples
use rug::{Complete, Rational};
let values = [
Rational::from((5, 2)),
Rational::from((-100_000, 7)),
Rational::from(-4),
];
let sum = Rational::sum(values.iter()).complete();
let expected = (5 * 7 - 100_000 * 2 - 4 * 14, 14);
assert_eq!(sum, expected);
sourcepub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
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.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Rational
From<Src> for Rational
Complete<Completed = Rational> for Src
AddAssign<Src> for Rational
Add<Src> for Rational
,Add<Rational> for Src
SubAssign<Src> for Rational
,SubFrom<Src> for Rational
Sub<Src> for Rational
,Sub<Rational> for Src
Examples
use rug::{Complete, Rational};
let a = [Rational::from((270, 7)), Rational::from((-11, 10))];
let b = [Rational::from(7), Rational::from((1, 2))];
let dot = Rational::dot(a.iter().zip(b.iter())).complete();
let expected = (270 * 20 - 11, 20);
assert_eq!(dot, expected);
sourcepub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
pub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Multiplies a list of Rational
values.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Rational
From<Src> for Rational
Complete<Completed = Rational> for Src
MulAssign<Src> for Rational
Mul<Src> for Rational
,Mul<Rational> for Src
Examples
use rug::{Complete, Rational};
let values = [
Rational::from((5, 2)),
Rational::from((-100_000, 7)),
Rational::from(-4),
];
let product = Rational::product(values.iter()).complete();
let expected = (5 * -100_000 * -4, 2 * 7);
assert_eq!(product, expected);
sourcepub fn abs(self) -> Self
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));
sourcepub fn abs_mut(&mut self)
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));
sourcepub fn abs_ref(&self) -> AbsIncomplete<'_>
pub fn abs_ref(&self) -> AbsIncomplete<'_>
Computes the absolute value.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Rational};
let r = Rational::from((-100, 17));
let abs = r.abs_ref().complete();
assert_eq!(abs, (100, 17));
sourcepub fn signum(self) -> Self
pub fn signum(self) -> 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 r = Rational::from((-100, 17));
let signum = r.signum();
assert_eq!(signum, -1);
sourcepub fn signum_mut(&mut self)
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);
sourcepub fn signum_ref(&self) -> SignumIncomplete<'_>
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
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
Assign<Src> for Rational
From<Src> for Integer
From<Src> for Rational
Complete<Completed = Rational> for 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);
sourcepub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
pub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a 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));
sourcepub fn clamp_mut<Min, Max>(&mut self, min: &Min, max: &Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
pub fn clamp_mut<Min, Max>(&mut self, min: &Min, max: &Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a 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));
sourcepub fn clamp_ref<'min, 'max, Min, Max>(
&self,
min: &'min Min,
max: &'max Max
) -> ClampIncomplete<'_, 'min, 'max, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
pub fn clamp_ref<'min, 'max, Min, Max>(
&self,
min: &'min Min,
max: &'max Max
) -> ClampIncomplete<'_, 'min, 'max, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
Clamps the value within the specified bounds.
The following 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::{Assign, Complete, Rational};
let min = (-3, 2);
let max = (3, 2);
let too_small = Rational::from((-5, 2));
let mut clamped = too_small.clamp_ref(&min, &max).complete();
assert_eq!(clamped, (-3, 2));
let in_range = Rational::from((1, 2));
clamped.assign(in_range.clamp_ref(&min, &max));
assert_eq!(clamped, (1, 2));
sourcepub fn recip_mut(&mut self)
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));
sourcepub fn recip_ref(&self) -> RecipIncomplete<'_>
pub fn recip_ref(&self) -> RecipIncomplete<'_>
Computes the reciprocal.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Rational};
let r = Rational::from((-100, 17));
assert_eq!(r.recip_ref().complete(), (-17, 100));
sourcepub fn trunc(self) -> Self
pub fn trunc(self) -> Self
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);
sourcepub fn trunc_mut(&mut self)
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);
sourcepub fn trunc_ref(&self) -> TruncIncomplete<'_>
pub fn trunc_ref(&self) -> TruncIncomplete<'_>
Rounds the number towards zero.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
Assign<Src> for Rational
From<Src> for Integer
From<Src> for Rational
Complete<Completed = Rational> for 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);
sourcepub fn rem_trunc(self) -> Self
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));
sourcepub fn rem_trunc_mut(&mut self)
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));
sourcepub fn rem_trunc_ref(&self) -> RemTruncIncomplete<'_>
pub fn rem_trunc_ref(&self) -> RemTruncIncomplete<'_>
Computes the fractional part of the number.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Rational};
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
assert_eq!(r.rem_trunc_ref().complete(), (-15, 17));
sourcepub fn fract_trunc(self, trunc: Integer) -> (Self, Integer)
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);
sourcepub fn fract_trunc_mut(&mut self, trunc: &mut Integer)
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);
sourcepub fn fract_trunc_ref(&self) -> FractTruncIncomplete<'_>
pub fn fract_trunc_ref(&self) -> FractTruncIncomplete<'_>
Computes the fractional and truncated parts of the number.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for 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);
sourcepub fn ceil(self) -> Self
pub fn ceil(self) -> Self
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);
sourcepub fn ceil_mut(&mut self)
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);
sourcepub fn ceil_ref(&self) -> CeilIncomplete<'_>
pub fn ceil_ref(&self) -> CeilIncomplete<'_>
Rounds the number upwards (towards plus infinity).
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
Assign<Src> for Rational
From<Src> for Integer
From<Src> for Rational
Complete<Completed = Rational> for 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);
sourcepub fn rem_ceil(self) -> Self
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));
sourcepub fn rem_ceil_mut(&mut self)
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));
sourcepub fn rem_ceil_ref(&self) -> RemCeilIncomplete<'_>
pub fn rem_ceil_ref(&self) -> RemCeilIncomplete<'_>
Computes the non-positive remainder after rounding up.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Rational};
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
assert_eq!(r.rem_ceil_ref().complete(), (-2, 17));
sourcepub fn fract_ceil(self, ceil: Integer) -> (Self, Integer)
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);
sourcepub fn fract_ceil_mut(&mut self, ceil: &mut Integer)
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);
sourcepub fn fract_ceil_ref(&self) -> FractCeilIncomplete<'_>
pub fn fract_ceil_ref(&self) -> FractCeilIncomplete<'_>
Computes the fractional and ceil parts of the number.
The fractional part cannot be greater than zero.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for 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);
sourcepub fn floor(self) -> Self
pub fn floor(self) -> Self
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);
sourcepub fn floor_mut(&mut self)
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);
sourcepub fn floor_ref(&self) -> FloorIncomplete<'_>
pub fn floor_ref(&self) -> FloorIncomplete<'_>
Rounds the number downwards (towards minus infinity).
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
Assign<Src> for Rational
From<Src> for Integer
From<Src> for Rational
Complete<Completed = Rational> for 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);
sourcepub fn rem_floor(self) -> Self
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));
sourcepub fn rem_floor_mut(&mut self)
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));
sourcepub fn rem_floor_ref(&self) -> RemFloorIncomplete<'_>
pub fn rem_floor_ref(&self) -> RemFloorIncomplete<'_>
Computes the non-negative remainder after rounding down.
The following are implemented with the returned
incomplete-computation value as Src
:
Examples
use rug::{Complete, Rational};
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
assert_eq!(r.rem_floor_ref().complete(), (2, 17));
sourcepub fn fract_floor(self, floor: Integer) -> (Self, Integer)
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);
sourcepub fn fract_floor_mut(&mut self, floor: &mut Integer)
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);
sourcepub fn fract_floor_ref(&self) -> FractFloorIncomplete<'_>
pub fn fract_floor_ref(&self) -> FractFloorIncomplete<'_>
Computes the fractional and floor parts of the number.
The fractional part cannot be negative.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for 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);
sourcepub fn round(self) -> Self
pub fn round(self) -> 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::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);
sourcepub fn round_mut(&mut self)
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);
sourcepub fn round_ref(&self) -> RoundIncomplete<'_>
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.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer`
Assign<Src> for Rational
From<Src> for Integer
From<Src> for Rational
Complete<Completed = Rational> for 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);
sourcepub fn rem_round(self) -> Self
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));
sourcepub fn rem_round_mut(&mut self)
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));
sourcepub fn rem_round_ref(&self) -> RemRoundIncomplete<'_>
pub fn rem_round_ref(&self) -> RemRoundIncomplete<'_>
Computes the remainder after rounding to the nearest integer.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Assign, Complete, Rational};
// -3.5 = -4 + 0.5 = -4 + 1/2
let r1 = Rational::from((-35, 10));
let mut rem = r1.rem_round_ref().complete();
assert_eq!(rem, (1, 2));
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
rem.assign(r2.rem_round_ref());
assert_eq!(rem, (-3, 10));
sourcepub fn fract_round(self, round: Integer) -> (Self, Integer)
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.
The initial value of round
is ignored.
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);
sourcepub fn fract_round_mut(&mut self, round: &mut Integer)
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.
The initial value of round
is ignored.
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);
sourcepub fn fract_round_ref(&self) -> FractRoundIncomplete<'_>
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.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for 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);
sourcepub fn square(self) -> Self
pub fn square(self) -> Self
Computes the square.
This method cannot be replaced by a multiplication using the *
operator: r * r
and r * &r
are both errors.
Examples
use rug::Rational;
let r = Rational::from((-13, 2));
let square = r.square();
assert_eq!(square, (169, 4));
sourcepub fn square_mut(&mut self)
pub fn square_mut(&mut self)
Computes the square.
This method cannot be replaced by a compound multiplication and
assignment using the *=
operataor: r *= r;
and r *= &r;
are both
errors.
Examples
use rug::Rational;
let mut r = Rational::from((-13, 2));
r.square_mut();
assert_eq!(r, (169, 4));
sourcepub fn square_ref(&self) -> MulIncomplete<'_>
pub fn square_ref(&self) -> MulIncomplete<'_>
Computes the square.
The following are implemented with the returned incomplete-computation
value as Src
:
r.square_ref()
produces the exact same result as &r * &r
.
Examples
use rug::{Complete, Rational};
let r = Rational::from((-13, 2));
assert_eq!(r.square_ref().complete(), (169, 4));
Trait Implementations
sourceimpl AddAssign<&'_ Integer> for Rational
impl AddAssign<&'_ Integer> for Rational
sourcefn add_assign(&mut self, rhs: &Integer)
fn add_assign(&mut self, rhs: &Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ Rational> for Rational
impl AddAssign<&'_ Rational> for Rational
sourcefn add_assign(&mut self, rhs: &Rational)
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ Rational> for Float
impl AddAssign<&'_ Rational> for Float
sourcefn add_assign(&mut self, rhs: &Rational)
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ Rational> for Complex
impl AddAssign<&'_ Rational> for Complex
sourcefn add_assign(&mut self, rhs: &Rational)
fn add_assign(&mut self, rhs: &Rational)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ i128> for Rational
impl AddAssign<&'_ i128> for Rational
sourcefn add_assign(&mut self, rhs: &i128)
fn add_assign(&mut self, rhs: &i128)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ i16> for Rational
impl AddAssign<&'_ i16> for Rational
sourcefn add_assign(&mut self, rhs: &i16)
fn add_assign(&mut self, rhs: &i16)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ i32> for Rational
impl AddAssign<&'_ i32> for Rational
sourcefn add_assign(&mut self, rhs: &i32)
fn add_assign(&mut self, rhs: &i32)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ i64> for Rational
impl AddAssign<&'_ i64> for Rational
sourcefn add_assign(&mut self, rhs: &i64)
fn add_assign(&mut self, rhs: &i64)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ i8> for Rational
impl AddAssign<&'_ i8> for Rational
sourcefn add_assign(&mut self, rhs: &i8)
fn add_assign(&mut self, rhs: &i8)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ isize> for Rational
impl AddAssign<&'_ isize> for Rational
sourcefn add_assign(&mut self, rhs: &isize)
fn add_assign(&mut self, rhs: &isize)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ u128> for Rational
impl AddAssign<&'_ u128> for Rational
sourcefn add_assign(&mut self, rhs: &u128)
fn add_assign(&mut self, rhs: &u128)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ u16> for Rational
impl AddAssign<&'_ u16> for Rational
sourcefn add_assign(&mut self, rhs: &u16)
fn add_assign(&mut self, rhs: &u16)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ u32> for Rational
impl AddAssign<&'_ u32> for Rational
sourcefn add_assign(&mut self, rhs: &u32)
fn add_assign(&mut self, rhs: &u32)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ u64> for Rational
impl AddAssign<&'_ u64> for Rational
sourcefn add_assign(&mut self, rhs: &u64)
fn add_assign(&mut self, rhs: &u64)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ u8> for Rational
impl AddAssign<&'_ u8> for Rational
sourcefn add_assign(&mut self, rhs: &u8)
fn add_assign(&mut self, rhs: &u8)
Performs the +=
operation. Read more
sourceimpl AddAssign<&'_ usize> for Rational
impl AddAssign<&'_ usize> for Rational
sourcefn add_assign(&mut self, rhs: &usize)
fn add_assign(&mut self, rhs: &usize)
Performs the +=
operation. Read more
sourceimpl AddAssign<Integer> for Rational
impl AddAssign<Integer> for Rational
sourcefn add_assign(&mut self, rhs: Integer)
fn add_assign(&mut self, rhs: Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<Rational> for Rational
impl AddAssign<Rational> for Rational
sourcefn add_assign(&mut self, rhs: Rational)
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation. Read more
sourceimpl AddAssign<Rational> for Float
impl AddAssign<Rational> for Float
sourcefn add_assign(&mut self, rhs: Rational)
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation. Read more
sourceimpl AddAssign<Rational> for Complex
impl AddAssign<Rational> for Complex
sourcefn add_assign(&mut self, rhs: Rational)
fn add_assign(&mut self, rhs: Rational)
Performs the +=
operation. Read more
sourceimpl AddAssign<i128> for Rational
impl AddAssign<i128> for Rational
sourcefn add_assign(&mut self, rhs: i128)
fn add_assign(&mut self, rhs: i128)
Performs the +=
operation. Read more
sourceimpl AddAssign<i16> for Rational
impl AddAssign<i16> for Rational
sourcefn add_assign(&mut self, rhs: i16)
fn add_assign(&mut self, rhs: i16)
Performs the +=
operation. Read more
sourceimpl AddAssign<i32> for Rational
impl AddAssign<i32> for Rational
sourcefn add_assign(&mut self, rhs: i32)
fn add_assign(&mut self, rhs: i32)
Performs the +=
operation. Read more
sourceimpl AddAssign<i64> for Rational
impl AddAssign<i64> for Rational
sourcefn add_assign(&mut self, rhs: i64)
fn add_assign(&mut self, rhs: i64)
Performs the +=
operation. Read more
sourceimpl AddAssign<i8> for Rational
impl AddAssign<i8> for Rational
sourcefn add_assign(&mut self, rhs: i8)
fn add_assign(&mut self, rhs: i8)
Performs the +=
operation. Read more
sourceimpl AddAssign<isize> for Rational
impl AddAssign<isize> for Rational
sourcefn add_assign(&mut self, rhs: isize)
fn add_assign(&mut self, rhs: isize)
Performs the +=
operation. Read more
sourceimpl AddAssign<u128> for Rational
impl AddAssign<u128> for Rational
sourcefn add_assign(&mut self, rhs: u128)
fn add_assign(&mut self, rhs: u128)
Performs the +=
operation. Read more
sourceimpl AddAssign<u16> for Rational
impl AddAssign<u16> for Rational
sourcefn add_assign(&mut self, rhs: u16)
fn add_assign(&mut self, rhs: u16)
Performs the +=
operation. Read more
sourceimpl AddAssign<u32> for Rational
impl AddAssign<u32> for Rational
sourcefn add_assign(&mut self, rhs: u32)
fn add_assign(&mut self, rhs: u32)
Performs the +=
operation. Read more
sourceimpl AddAssign<u64> for Rational
impl AddAssign<u64> for Rational
sourcefn add_assign(&mut self, rhs: u64)
fn add_assign(&mut self, rhs: u64)
Performs the +=
operation. Read more
sourceimpl AddAssign<u8> for Rational
impl AddAssign<u8> for Rational
sourcefn add_assign(&mut self, rhs: u8)
fn add_assign(&mut self, rhs: u8)
Performs the +=
operation. Read more
sourceimpl AddAssign<usize> for Rational
impl AddAssign<usize> for Rational
sourcefn add_assign(&mut self, rhs: usize)
fn add_assign(&mut self, rhs: usize)
Performs the +=
operation. Read more
sourceimpl AddAssignRound<&'_ Rational> for Float
impl AddAssignRound<&'_ Rational> for Float
sourceimpl AddAssignRound<&'_ Rational> for Complex
impl AddAssignRound<&'_ Rational> for Complex
sourceimpl AddAssignRound<Rational> for Float
impl AddAssignRound<Rational> for Float
sourceimpl AddAssignRound<Rational> for Complex
impl AddAssignRound<Rational> for Complex
sourceimpl AddFromRound<&'_ Rational> for Float
impl AddFromRound<&'_ Rational> for Float
sourceimpl AddFromRound<&'_ Rational> for Complex
impl AddFromRound<&'_ Rational> for Complex
sourceimpl AddFromRound<Rational> for Float
impl AddFromRound<Rational> for Float
sourceimpl AddFromRound<Rational> for Complex
impl AddFromRound<Rational> for Complex
sourceimpl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational where
Integer: Assign<&'a Num> + Assign<&'a Den>,
impl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational where
Integer: Assign<&'a Num> + Assign<&'a Den>,
sourceimpl AssignRound<&'_ Rational> for Float
impl AssignRound<&'_ Rational> for Float
sourceimpl AssignRound<Rational> for Float
impl AssignRound<Rational> for Float
sourceimpl CheckedCast<Rational> for f32
impl CheckedCast<Rational> for f32
sourcefn checked_cast(self) -> Option<Rational>
fn checked_cast(self) -> Option<Rational>
Casts the value.
sourceimpl CheckedCast<Rational> for f64
impl CheckedCast<Rational> for f64
sourcefn checked_cast(self) -> Option<Rational>
fn checked_cast(self) -> Option<Rational>
Casts the value.
sourceimpl CheckedCast<Rational> for Float
impl CheckedCast<Rational> for Float
sourcefn checked_cast(self) -> Option<Rational>
fn checked_cast(self) -> Option<Rational>
Casts the value.
sourceimpl CheckedCast<Rational> for &Float
impl CheckedCast<Rational> for &Float
sourcefn checked_cast(self) -> Option<Rational>
fn checked_cast(self) -> Option<Rational>
Casts the value.
sourceimpl<'de> Deserialize<'de> for Rational
impl<'de> Deserialize<'de> for Rational
sourcefn deserialize<D: Deserializer<'de>>(
deserializer: D
) -> Result<Rational, D::Error>
fn deserialize<D: Deserializer<'de>>(
deserializer: D
) -> Result<Rational, D::Error>
Deserialize this value from the given Serde deserializer. Read more
sourceimpl DivAssign<&'_ Integer> for Rational
impl DivAssign<&'_ Integer> for Rational
sourcefn div_assign(&mut self, rhs: &Integer)
fn div_assign(&mut self, rhs: &Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ Rational> for Rational
impl DivAssign<&'_ Rational> for Rational
sourcefn div_assign(&mut self, rhs: &Rational)
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ Rational> for Float
impl DivAssign<&'_ Rational> for Float
sourcefn div_assign(&mut self, rhs: &Rational)
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ Rational> for Complex
impl DivAssign<&'_ Rational> for Complex
sourcefn div_assign(&mut self, rhs: &Rational)
fn div_assign(&mut self, rhs: &Rational)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ i128> for Rational
impl DivAssign<&'_ i128> for Rational
sourcefn div_assign(&mut self, rhs: &i128)
fn div_assign(&mut self, rhs: &i128)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ i16> for Rational
impl DivAssign<&'_ i16> for Rational
sourcefn div_assign(&mut self, rhs: &i16)
fn div_assign(&mut self, rhs: &i16)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ i32> for Rational
impl DivAssign<&'_ i32> for Rational
sourcefn div_assign(&mut self, rhs: &i32)
fn div_assign(&mut self, rhs: &i32)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ i64> for Rational
impl DivAssign<&'_ i64> for Rational
sourcefn div_assign(&mut self, rhs: &i64)
fn div_assign(&mut self, rhs: &i64)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ i8> for Rational
impl DivAssign<&'_ i8> for Rational
sourcefn div_assign(&mut self, rhs: &i8)
fn div_assign(&mut self, rhs: &i8)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ isize> for Rational
impl DivAssign<&'_ isize> for Rational
sourcefn div_assign(&mut self, rhs: &isize)
fn div_assign(&mut self, rhs: &isize)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ u128> for Rational
impl DivAssign<&'_ u128> for Rational
sourcefn div_assign(&mut self, rhs: &u128)
fn div_assign(&mut self, rhs: &u128)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ u16> for Rational
impl DivAssign<&'_ u16> for Rational
sourcefn div_assign(&mut self, rhs: &u16)
fn div_assign(&mut self, rhs: &u16)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ u32> for Rational
impl DivAssign<&'_ u32> for Rational
sourcefn div_assign(&mut self, rhs: &u32)
fn div_assign(&mut self, rhs: &u32)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ u64> for Rational
impl DivAssign<&'_ u64> for Rational
sourcefn div_assign(&mut self, rhs: &u64)
fn div_assign(&mut self, rhs: &u64)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ u8> for Rational
impl DivAssign<&'_ u8> for Rational
sourcefn div_assign(&mut self, rhs: &u8)
fn div_assign(&mut self, rhs: &u8)
Performs the /=
operation. Read more
sourceimpl DivAssign<&'_ usize> for Rational
impl DivAssign<&'_ usize> for Rational
sourcefn div_assign(&mut self, rhs: &usize)
fn div_assign(&mut self, rhs: &usize)
Performs the /=
operation. Read more
sourceimpl DivAssign<Integer> for Rational
impl DivAssign<Integer> for Rational
sourcefn div_assign(&mut self, rhs: Integer)
fn div_assign(&mut self, rhs: Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<Rational> for Rational
impl DivAssign<Rational> for Rational
sourcefn div_assign(&mut self, rhs: Rational)
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation. Read more
sourceimpl DivAssign<Rational> for Float
impl DivAssign<Rational> for Float
sourcefn div_assign(&mut self, rhs: Rational)
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation. Read more
sourceimpl DivAssign<Rational> for Complex
impl DivAssign<Rational> for Complex
sourcefn div_assign(&mut self, rhs: Rational)
fn div_assign(&mut self, rhs: Rational)
Performs the /=
operation. Read more
sourceimpl DivAssign<i128> for Rational
impl DivAssign<i128> for Rational
sourcefn div_assign(&mut self, rhs: i128)
fn div_assign(&mut self, rhs: i128)
Performs the /=
operation. Read more
sourceimpl DivAssign<i16> for Rational
impl DivAssign<i16> for Rational
sourcefn div_assign(&mut self, rhs: i16)
fn div_assign(&mut self, rhs: i16)
Performs the /=
operation. Read more
sourceimpl DivAssign<i32> for Rational
impl DivAssign<i32> for Rational
sourcefn div_assign(&mut self, rhs: i32)
fn div_assign(&mut self, rhs: i32)
Performs the /=
operation. Read more
sourceimpl DivAssign<i64> for Rational
impl DivAssign<i64> for Rational
sourcefn div_assign(&mut self, rhs: i64)
fn div_assign(&mut self, rhs: i64)
Performs the /=
operation. Read more
sourceimpl DivAssign<i8> for Rational
impl DivAssign<i8> for Rational
sourcefn div_assign(&mut self, rhs: i8)
fn div_assign(&mut self, rhs: i8)
Performs the /=
operation. Read more
sourceimpl DivAssign<isize> for Rational
impl DivAssign<isize> for Rational
sourcefn div_assign(&mut self, rhs: isize)
fn div_assign(&mut self, rhs: isize)
Performs the /=
operation. Read more
sourceimpl DivAssign<u128> for Rational
impl DivAssign<u128> for Rational
sourcefn div_assign(&mut self, rhs: u128)
fn div_assign(&mut self, rhs: u128)
Performs the /=
operation. Read more
sourceimpl DivAssign<u16> for Rational
impl DivAssign<u16> for Rational
sourcefn div_assign(&mut self, rhs: u16)
fn div_assign(&mut self, rhs: u16)
Performs the /=
operation. Read more
sourceimpl DivAssign<u32> for Rational
impl DivAssign<u32> for Rational
sourcefn div_assign(&mut self, rhs: u32)
fn div_assign(&mut self, rhs: u32)
Performs the /=
operation. Read more
sourceimpl DivAssign<u64> for Rational
impl DivAssign<u64> for Rational
sourcefn div_assign(&mut self, rhs: u64)
fn div_assign(&mut self, rhs: u64)
Performs the /=
operation. Read more
sourceimpl DivAssign<u8> for Rational
impl DivAssign<u8> for Rational
sourcefn div_assign(&mut self, rhs: u8)
fn div_assign(&mut self, rhs: u8)
Performs the /=
operation. Read more
sourceimpl DivAssign<usize> for Rational
impl DivAssign<usize> for Rational
sourcefn div_assign(&mut self, rhs: usize)
fn div_assign(&mut self, rhs: usize)
Performs the /=
operation. Read more
sourceimpl DivAssignRound<&'_ Rational> for Float
impl DivAssignRound<&'_ Rational> for Float
sourceimpl DivAssignRound<&'_ Rational> for Complex
impl DivAssignRound<&'_ Rational> for Complex
sourceimpl DivAssignRound<Rational> for Float
impl DivAssignRound<Rational> for Float
sourceimpl DivAssignRound<Rational> for Complex
impl DivAssignRound<Rational> for Complex
sourceimpl DivFromRound<&'_ Rational> for Float
impl DivFromRound<&'_ Rational> for Float
sourceimpl DivFromRound<Rational> for Float
impl DivFromRound<Rational> for Float
sourceimpl<'a, Num, Den> From<&'a (Num, Den)> for Rational where
Integer: From<&'a Num> + From<&'a Den>,
impl<'a, Num, Den> From<&'a (Num, Den)> for Rational where
Integer: From<&'a Num> + From<&'a Den>,
sourceimpl FromPrimitive for Rational
impl FromPrimitive for Rational
sourcefn from_i64(n: i64) -> Option<Self>
fn from_i64(n: i64) -> Option<Self>
Converts an i64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u64(n: u64) -> Option<Self>
fn from_u64(n: u64) -> Option<Self>
Converts an u64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_isize(n: isize) -> Option<Self>
fn from_isize(n: isize) -> Option<Self>
Converts an isize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i8(n: i8) -> Option<Self>
fn from_i8(n: i8) -> Option<Self>
Converts an i8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i16(n: i16) -> Option<Self>
fn from_i16(n: i16) -> Option<Self>
Converts an i16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i32(n: i32) -> Option<Self>
fn from_i32(n: i32) -> Option<Self>
Converts an i32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i128(n: i128) -> Option<Self>
fn from_i128(n: i128) -> Option<Self>
Converts an i128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_usize(n: usize) -> Option<Self>
fn from_usize(n: usize) -> Option<Self>
Converts a usize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u8(n: u8) -> Option<Self>
fn from_u8(n: u8) -> Option<Self>
Converts an u8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u16(n: u16) -> Option<Self>
fn from_u16(n: u16) -> Option<Self>
Converts an u16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u32(n: u32) -> Option<Self>
fn from_u32(n: u32) -> Option<Self>
Converts an u32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u128(n: u128) -> Option<Self>
fn from_u128(n: u128) -> Option<Self>
Converts an u128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourceimpl FromStr for Rational
impl FromStr for Rational
type Err = ParseRationalError
type Err = ParseRationalError
The associated error which can be returned from parsing.
sourceimpl MulAddAssign<&'_ Rational, &'_ Rational> for Rational
impl MulAddAssign<&'_ Rational, &'_ Rational> for Rational
sourcefn mul_add_assign(&mut self, a: &Rational, b: &Rational)
fn mul_add_assign(&mut self, a: &Rational, b: &Rational)
Performs the fused multiply-add operation.
sourceimpl MulAddAssign<Rational, Rational> for Rational
impl MulAddAssign<Rational, Rational> for Rational
sourcefn mul_add_assign(&mut self, a: Rational, b: Rational)
fn mul_add_assign(&mut self, a: Rational, b: Rational)
Performs the fused multiply-add operation.
sourceimpl MulAssign<&'_ Integer> for Rational
impl MulAssign<&'_ Integer> for Rational
sourcefn mul_assign(&mut self, rhs: &Integer)
fn mul_assign(&mut self, rhs: &Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ Rational> for Rational
impl MulAssign<&'_ Rational> for Rational
sourcefn mul_assign(&mut self, rhs: &Rational)
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ Rational> for Float
impl MulAssign<&'_ Rational> for Float
sourcefn mul_assign(&mut self, rhs: &Rational)
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ Rational> for Complex
impl MulAssign<&'_ Rational> for Complex
sourcefn mul_assign(&mut self, rhs: &Rational)
fn mul_assign(&mut self, rhs: &Rational)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ i128> for Rational
impl MulAssign<&'_ i128> for Rational
sourcefn mul_assign(&mut self, rhs: &i128)
fn mul_assign(&mut self, rhs: &i128)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ i16> for Rational
impl MulAssign<&'_ i16> for Rational
sourcefn mul_assign(&mut self, rhs: &i16)
fn mul_assign(&mut self, rhs: &i16)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ i32> for Rational
impl MulAssign<&'_ i32> for Rational
sourcefn mul_assign(&mut self, rhs: &i32)
fn mul_assign(&mut self, rhs: &i32)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ i64> for Rational
impl MulAssign<&'_ i64> for Rational
sourcefn mul_assign(&mut self, rhs: &i64)
fn mul_assign(&mut self, rhs: &i64)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ i8> for Rational
impl MulAssign<&'_ i8> for Rational
sourcefn mul_assign(&mut self, rhs: &i8)
fn mul_assign(&mut self, rhs: &i8)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ isize> for Rational
impl MulAssign<&'_ isize> for Rational
sourcefn mul_assign(&mut self, rhs: &isize)
fn mul_assign(&mut self, rhs: &isize)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ u128> for Rational
impl MulAssign<&'_ u128> for Rational
sourcefn mul_assign(&mut self, rhs: &u128)
fn mul_assign(&mut self, rhs: &u128)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ u16> for Rational
impl MulAssign<&'_ u16> for Rational
sourcefn mul_assign(&mut self, rhs: &u16)
fn mul_assign(&mut self, rhs: &u16)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ u32> for Rational
impl MulAssign<&'_ u32> for Rational
sourcefn mul_assign(&mut self, rhs: &u32)
fn mul_assign(&mut self, rhs: &u32)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ u64> for Rational
impl MulAssign<&'_ u64> for Rational
sourcefn mul_assign(&mut self, rhs: &u64)
fn mul_assign(&mut self, rhs: &u64)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ u8> for Rational
impl MulAssign<&'_ u8> for Rational
sourcefn mul_assign(&mut self, rhs: &u8)
fn mul_assign(&mut self, rhs: &u8)
Performs the *=
operation. Read more
sourceimpl MulAssign<&'_ usize> for Rational
impl MulAssign<&'_ usize> for Rational
sourcefn mul_assign(&mut self, rhs: &usize)
fn mul_assign(&mut self, rhs: &usize)
Performs the *=
operation. Read more
sourceimpl MulAssign<Integer> for Rational
impl MulAssign<Integer> for Rational
sourcefn mul_assign(&mut self, rhs: Integer)
fn mul_assign(&mut self, rhs: Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<Rational> for Rational
impl MulAssign<Rational> for Rational
sourcefn mul_assign(&mut self, rhs: Rational)
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation. Read more
sourceimpl MulAssign<Rational> for Float
impl MulAssign<Rational> for Float
sourcefn mul_assign(&mut self, rhs: Rational)
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation. Read more
sourceimpl MulAssign<Rational> for Complex
impl MulAssign<Rational> for Complex
sourcefn mul_assign(&mut self, rhs: Rational)
fn mul_assign(&mut self, rhs: Rational)
Performs the *=
operation. Read more
sourceimpl MulAssign<i128> for Rational
impl MulAssign<i128> for Rational
sourcefn mul_assign(&mut self, rhs: i128)
fn mul_assign(&mut self, rhs: i128)
Performs the *=
operation. Read more
sourceimpl MulAssign<i16> for Rational
impl MulAssign<i16> for Rational
sourcefn mul_assign(&mut self, rhs: i16)
fn mul_assign(&mut self, rhs: i16)
Performs the *=
operation. Read more
sourceimpl MulAssign<i32> for Rational
impl MulAssign<i32> for Rational
sourcefn mul_assign(&mut self, rhs: i32)
fn mul_assign(&mut self, rhs: i32)
Performs the *=
operation. Read more
sourceimpl MulAssign<i64> for Rational
impl MulAssign<i64> for Rational
sourcefn mul_assign(&mut self, rhs: i64)
fn mul_assign(&mut self, rhs: i64)
Performs the *=
operation. Read more
sourceimpl MulAssign<i8> for Rational
impl MulAssign<i8> for Rational
sourcefn mul_assign(&mut self, rhs: i8)
fn mul_assign(&mut self, rhs: i8)
Performs the *=
operation. Read more
sourceimpl MulAssign<isize> for Rational
impl MulAssign<isize> for Rational
sourcefn mul_assign(&mut self, rhs: isize)
fn mul_assign(&mut self, rhs: isize)
Performs the *=
operation. Read more
sourceimpl MulAssign<u128> for Rational
impl MulAssign<u128> for Rational
sourcefn mul_assign(&mut self, rhs: u128)
fn mul_assign(&mut self, rhs: u128)
Performs the *=
operation. Read more
sourceimpl MulAssign<u16> for Rational
impl MulAssign<u16> for Rational
sourcefn mul_assign(&mut self, rhs: u16)
fn mul_assign(&mut self, rhs: u16)
Performs the *=
operation. Read more
sourceimpl MulAssign<u32> for Rational
impl MulAssign<u32> for Rational
sourcefn mul_assign(&mut self, rhs: u32)
fn mul_assign(&mut self, rhs: u32)
Performs the *=
operation. Read more
sourceimpl MulAssign<u64> for Rational
impl MulAssign<u64> for Rational
sourcefn mul_assign(&mut self, rhs: u64)
fn mul_assign(&mut self, rhs: u64)
Performs the *=
operation. Read more
sourceimpl MulAssign<u8> for Rational
impl MulAssign<u8> for Rational
sourcefn mul_assign(&mut self, rhs: u8)
fn mul_assign(&mut self, rhs: u8)
Performs the *=
operation. Read more
sourceimpl MulAssign<usize> for Rational
impl MulAssign<usize> for Rational
sourcefn mul_assign(&mut self, rhs: usize)
fn mul_assign(&mut self, rhs: usize)
Performs the *=
operation. Read more
sourceimpl MulAssignRound<&'_ Rational> for Float
impl MulAssignRound<&'_ Rational> for Float
sourceimpl MulAssignRound<&'_ Rational> for Complex
impl MulAssignRound<&'_ Rational> for Complex
sourceimpl MulAssignRound<Rational> for Float
impl MulAssignRound<Rational> for Float
sourceimpl MulAssignRound<Rational> for Complex
impl MulAssignRound<Rational> for Complex
sourceimpl MulFromRound<&'_ Rational> for Float
impl MulFromRound<&'_ Rational> for Float
sourceimpl MulFromRound<&'_ Rational> for Complex
impl MulFromRound<&'_ Rational> for Complex
sourceimpl MulFromRound<Rational> for Float
impl MulFromRound<Rational> for Float
sourceimpl MulFromRound<Rational> for Complex
impl MulFromRound<Rational> for Complex
sourceimpl Ord for Rational
impl Ord for Rational
sourceimpl PartialOrd<(i128, i128)> for Rational
impl PartialOrd<(i128, i128)> for Rational
sourcefn partial_cmp(&self, other: &(i128, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, i16)> for Rational
impl PartialOrd<(i128, i16)> for Rational
sourcefn partial_cmp(&self, other: &(i128, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, i32)> for Rational
impl PartialOrd<(i128, i32)> for Rational
sourcefn partial_cmp(&self, other: &(i128, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, i64)> for Rational
impl PartialOrd<(i128, i64)> for Rational
sourcefn partial_cmp(&self, other: &(i128, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, i8)> for Rational
impl PartialOrd<(i128, i8)> for Rational
sourcefn partial_cmp(&self, other: &(i128, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, isize)> for Rational
impl PartialOrd<(i128, isize)> for Rational
sourcefn partial_cmp(&self, other: &(i128, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, u128)> for Rational
impl PartialOrd<(i128, u128)> for Rational
sourcefn partial_cmp(&self, other: &(i128, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, u16)> for Rational
impl PartialOrd<(i128, u16)> for Rational
sourcefn partial_cmp(&self, other: &(i128, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, u32)> for Rational
impl PartialOrd<(i128, u32)> for Rational
sourcefn partial_cmp(&self, other: &(i128, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, u64)> for Rational
impl PartialOrd<(i128, u64)> for Rational
sourcefn partial_cmp(&self, other: &(i128, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, u8)> for Rational
impl PartialOrd<(i128, u8)> for Rational
sourcefn partial_cmp(&self, other: &(i128, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i128, usize)> for Rational
impl PartialOrd<(i128, usize)> for Rational
sourcefn partial_cmp(&self, other: &(i128, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i128, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, i128)> for Rational
impl PartialOrd<(i16, i128)> for Rational
sourcefn partial_cmp(&self, other: &(i16, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, i16)> for Rational
impl PartialOrd<(i16, i16)> for Rational
sourcefn partial_cmp(&self, other: &(i16, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, i32)> for Rational
impl PartialOrd<(i16, i32)> for Rational
sourcefn partial_cmp(&self, other: &(i16, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, i64)> for Rational
impl PartialOrd<(i16, i64)> for Rational
sourcefn partial_cmp(&self, other: &(i16, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, i8)> for Rational
impl PartialOrd<(i16, i8)> for Rational
sourcefn partial_cmp(&self, other: &(i16, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, isize)> for Rational
impl PartialOrd<(i16, isize)> for Rational
sourcefn partial_cmp(&self, other: &(i16, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, u128)> for Rational
impl PartialOrd<(i16, u128)> for Rational
sourcefn partial_cmp(&self, other: &(i16, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, u16)> for Rational
impl PartialOrd<(i16, u16)> for Rational
sourcefn partial_cmp(&self, other: &(i16, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, u32)> for Rational
impl PartialOrd<(i16, u32)> for Rational
sourcefn partial_cmp(&self, other: &(i16, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, u64)> for Rational
impl PartialOrd<(i16, u64)> for Rational
sourcefn partial_cmp(&self, other: &(i16, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, u8)> for Rational
impl PartialOrd<(i16, u8)> for Rational
sourcefn partial_cmp(&self, other: &(i16, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i16, usize)> for Rational
impl PartialOrd<(i16, usize)> for Rational
sourcefn partial_cmp(&self, other: &(i16, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i16, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, i128)> for Rational
impl PartialOrd<(i32, i128)> for Rational
sourcefn partial_cmp(&self, other: &(i32, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, i16)> for Rational
impl PartialOrd<(i32, i16)> for Rational
sourcefn partial_cmp(&self, other: &(i32, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, i32)> for Rational
impl PartialOrd<(i32, i32)> for Rational
sourcefn partial_cmp(&self, other: &(i32, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, i64)> for Rational
impl PartialOrd<(i32, i64)> for Rational
sourcefn partial_cmp(&self, other: &(i32, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, i8)> for Rational
impl PartialOrd<(i32, i8)> for Rational
sourcefn partial_cmp(&self, other: &(i32, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, isize)> for Rational
impl PartialOrd<(i32, isize)> for Rational
sourcefn partial_cmp(&self, other: &(i32, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, u128)> for Rational
impl PartialOrd<(i32, u128)> for Rational
sourcefn partial_cmp(&self, other: &(i32, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, u16)> for Rational
impl PartialOrd<(i32, u16)> for Rational
sourcefn partial_cmp(&self, other: &(i32, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, u32)> for Rational
impl PartialOrd<(i32, u32)> for Rational
sourcefn partial_cmp(&self, other: &(i32, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, u64)> for Rational
impl PartialOrd<(i32, u64)> for Rational
sourcefn partial_cmp(&self, other: &(i32, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, u8)> for Rational
impl PartialOrd<(i32, u8)> for Rational
sourcefn partial_cmp(&self, other: &(i32, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i32, usize)> for Rational
impl PartialOrd<(i32, usize)> for Rational
sourcefn partial_cmp(&self, other: &(i32, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i32, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, i128)> for Rational
impl PartialOrd<(i64, i128)> for Rational
sourcefn partial_cmp(&self, other: &(i64, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, i16)> for Rational
impl PartialOrd<(i64, i16)> for Rational
sourcefn partial_cmp(&self, other: &(i64, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, i32)> for Rational
impl PartialOrd<(i64, i32)> for Rational
sourcefn partial_cmp(&self, other: &(i64, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, i64)> for Rational
impl PartialOrd<(i64, i64)> for Rational
sourcefn partial_cmp(&self, other: &(i64, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, i8)> for Rational
impl PartialOrd<(i64, i8)> for Rational
sourcefn partial_cmp(&self, other: &(i64, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, isize)> for Rational
impl PartialOrd<(i64, isize)> for Rational
sourcefn partial_cmp(&self, other: &(i64, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, u128)> for Rational
impl PartialOrd<(i64, u128)> for Rational
sourcefn partial_cmp(&self, other: &(i64, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, u16)> for Rational
impl PartialOrd<(i64, u16)> for Rational
sourcefn partial_cmp(&self, other: &(i64, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, u32)> for Rational
impl PartialOrd<(i64, u32)> for Rational
sourcefn partial_cmp(&self, other: &(i64, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, u64)> for Rational
impl PartialOrd<(i64, u64)> for Rational
sourcefn partial_cmp(&self, other: &(i64, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, u8)> for Rational
impl PartialOrd<(i64, u8)> for Rational
sourcefn partial_cmp(&self, other: &(i64, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i64, usize)> for Rational
impl PartialOrd<(i64, usize)> for Rational
sourcefn partial_cmp(&self, other: &(i64, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i64, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, i128)> for Rational
impl PartialOrd<(i8, i128)> for Rational
sourcefn partial_cmp(&self, other: &(i8, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, i16)> for Rational
impl PartialOrd<(i8, i16)> for Rational
sourcefn partial_cmp(&self, other: &(i8, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, i32)> for Rational
impl PartialOrd<(i8, i32)> for Rational
sourcefn partial_cmp(&self, other: &(i8, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, i64)> for Rational
impl PartialOrd<(i8, i64)> for Rational
sourcefn partial_cmp(&self, other: &(i8, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, i8)> for Rational
impl PartialOrd<(i8, i8)> for Rational
sourcefn partial_cmp(&self, other: &(i8, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, isize)> for Rational
impl PartialOrd<(i8, isize)> for Rational
sourcefn partial_cmp(&self, other: &(i8, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, u128)> for Rational
impl PartialOrd<(i8, u128)> for Rational
sourcefn partial_cmp(&self, other: &(i8, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, u16)> for Rational
impl PartialOrd<(i8, u16)> for Rational
sourcefn partial_cmp(&self, other: &(i8, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, u32)> for Rational
impl PartialOrd<(i8, u32)> for Rational
sourcefn partial_cmp(&self, other: &(i8, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, u64)> for Rational
impl PartialOrd<(i8, u64)> for Rational
sourcefn partial_cmp(&self, other: &(i8, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, u8)> for Rational
impl PartialOrd<(i8, u8)> for Rational
sourcefn partial_cmp(&self, other: &(i8, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(i8, usize)> for Rational
impl PartialOrd<(i8, usize)> for Rational
sourcefn partial_cmp(&self, other: &(i8, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(i8, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, i128)> for Rational
impl PartialOrd<(isize, i128)> for Rational
sourcefn partial_cmp(&self, other: &(isize, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, i16)> for Rational
impl PartialOrd<(isize, i16)> for Rational
sourcefn partial_cmp(&self, other: &(isize, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, i32)> for Rational
impl PartialOrd<(isize, i32)> for Rational
sourcefn partial_cmp(&self, other: &(isize, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, i64)> for Rational
impl PartialOrd<(isize, i64)> for Rational
sourcefn partial_cmp(&self, other: &(isize, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, i8)> for Rational
impl PartialOrd<(isize, i8)> for Rational
sourcefn partial_cmp(&self, other: &(isize, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, isize)> for Rational
impl PartialOrd<(isize, isize)> for Rational
sourcefn partial_cmp(&self, other: &(isize, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, u128)> for Rational
impl PartialOrd<(isize, u128)> for Rational
sourcefn partial_cmp(&self, other: &(isize, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, u16)> for Rational
impl PartialOrd<(isize, u16)> for Rational
sourcefn partial_cmp(&self, other: &(isize, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, u32)> for Rational
impl PartialOrd<(isize, u32)> for Rational
sourcefn partial_cmp(&self, other: &(isize, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, u64)> for Rational
impl PartialOrd<(isize, u64)> for Rational
sourcefn partial_cmp(&self, other: &(isize, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, u8)> for Rational
impl PartialOrd<(isize, u8)> for Rational
sourcefn partial_cmp(&self, other: &(isize, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(isize, usize)> for Rational
impl PartialOrd<(isize, usize)> for Rational
sourcefn partial_cmp(&self, other: &(isize, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(isize, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, i128)> for Rational
impl PartialOrd<(u128, i128)> for Rational
sourcefn partial_cmp(&self, other: &(u128, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, i16)> for Rational
impl PartialOrd<(u128, i16)> for Rational
sourcefn partial_cmp(&self, other: &(u128, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, i32)> for Rational
impl PartialOrd<(u128, i32)> for Rational
sourcefn partial_cmp(&self, other: &(u128, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, i64)> for Rational
impl PartialOrd<(u128, i64)> for Rational
sourcefn partial_cmp(&self, other: &(u128, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, i8)> for Rational
impl PartialOrd<(u128, i8)> for Rational
sourcefn partial_cmp(&self, other: &(u128, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, isize)> for Rational
impl PartialOrd<(u128, isize)> for Rational
sourcefn partial_cmp(&self, other: &(u128, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, u128)> for Rational
impl PartialOrd<(u128, u128)> for Rational
sourcefn partial_cmp(&self, other: &(u128, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, u16)> for Rational
impl PartialOrd<(u128, u16)> for Rational
sourcefn partial_cmp(&self, other: &(u128, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, u32)> for Rational
impl PartialOrd<(u128, u32)> for Rational
sourcefn partial_cmp(&self, other: &(u128, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, u64)> for Rational
impl PartialOrd<(u128, u64)> for Rational
sourcefn partial_cmp(&self, other: &(u128, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, u8)> for Rational
impl PartialOrd<(u128, u8)> for Rational
sourcefn partial_cmp(&self, other: &(u128, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u128, usize)> for Rational
impl PartialOrd<(u128, usize)> for Rational
sourcefn partial_cmp(&self, other: &(u128, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u128, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, i128)> for Rational
impl PartialOrd<(u16, i128)> for Rational
sourcefn partial_cmp(&self, other: &(u16, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, i16)> for Rational
impl PartialOrd<(u16, i16)> for Rational
sourcefn partial_cmp(&self, other: &(u16, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, i32)> for Rational
impl PartialOrd<(u16, i32)> for Rational
sourcefn partial_cmp(&self, other: &(u16, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, i64)> for Rational
impl PartialOrd<(u16, i64)> for Rational
sourcefn partial_cmp(&self, other: &(u16, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, i8)> for Rational
impl PartialOrd<(u16, i8)> for Rational
sourcefn partial_cmp(&self, other: &(u16, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, isize)> for Rational
impl PartialOrd<(u16, isize)> for Rational
sourcefn partial_cmp(&self, other: &(u16, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, u128)> for Rational
impl PartialOrd<(u16, u128)> for Rational
sourcefn partial_cmp(&self, other: &(u16, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, u16)> for Rational
impl PartialOrd<(u16, u16)> for Rational
sourcefn partial_cmp(&self, other: &(u16, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, u32)> for Rational
impl PartialOrd<(u16, u32)> for Rational
sourcefn partial_cmp(&self, other: &(u16, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, u64)> for Rational
impl PartialOrd<(u16, u64)> for Rational
sourcefn partial_cmp(&self, other: &(u16, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, u8)> for Rational
impl PartialOrd<(u16, u8)> for Rational
sourcefn partial_cmp(&self, other: &(u16, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u16, usize)> for Rational
impl PartialOrd<(u16, usize)> for Rational
sourcefn partial_cmp(&self, other: &(u16, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u16, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, i128)> for Rational
impl PartialOrd<(u32, i128)> for Rational
sourcefn partial_cmp(&self, other: &(u32, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, i16)> for Rational
impl PartialOrd<(u32, i16)> for Rational
sourcefn partial_cmp(&self, other: &(u32, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, i32)> for Rational
impl PartialOrd<(u32, i32)> for Rational
sourcefn partial_cmp(&self, other: &(u32, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, i64)> for Rational
impl PartialOrd<(u32, i64)> for Rational
sourcefn partial_cmp(&self, other: &(u32, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, i8)> for Rational
impl PartialOrd<(u32, i8)> for Rational
sourcefn partial_cmp(&self, other: &(u32, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, isize)> for Rational
impl PartialOrd<(u32, isize)> for Rational
sourcefn partial_cmp(&self, other: &(u32, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, u128)> for Rational
impl PartialOrd<(u32, u128)> for Rational
sourcefn partial_cmp(&self, other: &(u32, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, u16)> for Rational
impl PartialOrd<(u32, u16)> for Rational
sourcefn partial_cmp(&self, other: &(u32, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, u32)> for Rational
impl PartialOrd<(u32, u32)> for Rational
sourcefn partial_cmp(&self, other: &(u32, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, u64)> for Rational
impl PartialOrd<(u32, u64)> for Rational
sourcefn partial_cmp(&self, other: &(u32, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, u8)> for Rational
impl PartialOrd<(u32, u8)> for Rational
sourcefn partial_cmp(&self, other: &(u32, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u32, usize)> for Rational
impl PartialOrd<(u32, usize)> for Rational
sourcefn partial_cmp(&self, other: &(u32, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u32, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, i128)> for Rational
impl PartialOrd<(u64, i128)> for Rational
sourcefn partial_cmp(&self, other: &(u64, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, i16)> for Rational
impl PartialOrd<(u64, i16)> for Rational
sourcefn partial_cmp(&self, other: &(u64, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, i32)> for Rational
impl PartialOrd<(u64, i32)> for Rational
sourcefn partial_cmp(&self, other: &(u64, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, i64)> for Rational
impl PartialOrd<(u64, i64)> for Rational
sourcefn partial_cmp(&self, other: &(u64, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, i8)> for Rational
impl PartialOrd<(u64, i8)> for Rational
sourcefn partial_cmp(&self, other: &(u64, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, isize)> for Rational
impl PartialOrd<(u64, isize)> for Rational
sourcefn partial_cmp(&self, other: &(u64, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, u128)> for Rational
impl PartialOrd<(u64, u128)> for Rational
sourcefn partial_cmp(&self, other: &(u64, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, u16)> for Rational
impl PartialOrd<(u64, u16)> for Rational
sourcefn partial_cmp(&self, other: &(u64, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, u32)> for Rational
impl PartialOrd<(u64, u32)> for Rational
sourcefn partial_cmp(&self, other: &(u64, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, u64)> for Rational
impl PartialOrd<(u64, u64)> for Rational
sourcefn partial_cmp(&self, other: &(u64, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, u8)> for Rational
impl PartialOrd<(u64, u8)> for Rational
sourcefn partial_cmp(&self, other: &(u64, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u64, usize)> for Rational
impl PartialOrd<(u64, usize)> for Rational
sourcefn partial_cmp(&self, other: &(u64, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u64, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, i128)> for Rational
impl PartialOrd<(u8, i128)> for Rational
sourcefn partial_cmp(&self, other: &(u8, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, i16)> for Rational
impl PartialOrd<(u8, i16)> for Rational
sourcefn partial_cmp(&self, other: &(u8, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, i32)> for Rational
impl PartialOrd<(u8, i32)> for Rational
sourcefn partial_cmp(&self, other: &(u8, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, i64)> for Rational
impl PartialOrd<(u8, i64)> for Rational
sourcefn partial_cmp(&self, other: &(u8, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, i8)> for Rational
impl PartialOrd<(u8, i8)> for Rational
sourcefn partial_cmp(&self, other: &(u8, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, isize)> for Rational
impl PartialOrd<(u8, isize)> for Rational
sourcefn partial_cmp(&self, other: &(u8, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, u128)> for Rational
impl PartialOrd<(u8, u128)> for Rational
sourcefn partial_cmp(&self, other: &(u8, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, u16)> for Rational
impl PartialOrd<(u8, u16)> for Rational
sourcefn partial_cmp(&self, other: &(u8, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, u32)> for Rational
impl PartialOrd<(u8, u32)> for Rational
sourcefn partial_cmp(&self, other: &(u8, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, u64)> for Rational
impl PartialOrd<(u8, u64)> for Rational
sourcefn partial_cmp(&self, other: &(u8, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, u8)> for Rational
impl PartialOrd<(u8, u8)> for Rational
sourcefn partial_cmp(&self, other: &(u8, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(u8, usize)> for Rational
impl PartialOrd<(u8, usize)> for Rational
sourcefn partial_cmp(&self, other: &(u8, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(u8, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, i128)> for Rational
impl PartialOrd<(usize, i128)> for Rational
sourcefn partial_cmp(&self, other: &(usize, i128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, i128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, i16)> for Rational
impl PartialOrd<(usize, i16)> for Rational
sourcefn partial_cmp(&self, other: &(usize, i16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, i16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, i32)> for Rational
impl PartialOrd<(usize, i32)> for Rational
sourcefn partial_cmp(&self, other: &(usize, i32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, i32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, i64)> for Rational
impl PartialOrd<(usize, i64)> for Rational
sourcefn partial_cmp(&self, other: &(usize, i64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, i64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, i8)> for Rational
impl PartialOrd<(usize, i8)> for Rational
sourcefn partial_cmp(&self, other: &(usize, i8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, i8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, isize)> for Rational
impl PartialOrd<(usize, isize)> for Rational
sourcefn partial_cmp(&self, other: &(usize, isize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, isize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, u128)> for Rational
impl PartialOrd<(usize, u128)> for Rational
sourcefn partial_cmp(&self, other: &(usize, u128)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, u128)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, u16)> for Rational
impl PartialOrd<(usize, u16)> for Rational
sourcefn partial_cmp(&self, other: &(usize, u16)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, u16)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, u32)> for Rational
impl PartialOrd<(usize, u32)> for Rational
sourcefn partial_cmp(&self, other: &(usize, u32)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, u32)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, u64)> for Rational
impl PartialOrd<(usize, u64)> for Rational
sourcefn partial_cmp(&self, other: &(usize, u64)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, u64)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, u8)> for Rational
impl PartialOrd<(usize, u8)> for Rational
sourcefn partial_cmp(&self, other: &(usize, u8)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, u8)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<(usize, usize)> for Rational
impl PartialOrd<(usize, usize)> for Rational
sourcefn partial_cmp(&self, other: &(usize, usize)) -> Option<Ordering>
fn partial_cmp(&self, other: &(usize, usize)) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Float> for Rational
impl PartialOrd<Float> for Rational
sourcefn partial_cmp(&self, other: &Float) -> Option<Ordering>
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for Rational
impl PartialOrd<Integer> for Rational
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for Rational
impl PartialOrd<Rational> for Rational
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for Integer
impl PartialOrd<Rational> for Integer
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for u32
impl PartialOrd<Rational> for u32
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, i32)
impl PartialOrd<Rational> for (u16, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, i64)
impl PartialOrd<Rational> for (u16, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, i128)
impl PartialOrd<Rational> for (u16, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, isize)
impl PartialOrd<Rational> for (u16, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, u8)
impl PartialOrd<Rational> for (u16, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, u16)
impl PartialOrd<Rational> for (u16, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, u32)
impl PartialOrd<Rational> for (u16, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, u64)
impl PartialOrd<Rational> for (u16, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, u128)
impl PartialOrd<Rational> for (u16, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, usize)
impl PartialOrd<Rational> for (u16, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for u64
impl PartialOrd<Rational> for u64
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, i8)
impl PartialOrd<Rational> for (u32, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, i16)
impl PartialOrd<Rational> for (u32, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, i32)
impl PartialOrd<Rational> for (u32, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, i64)
impl PartialOrd<Rational> for (u32, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, i128)
impl PartialOrd<Rational> for (u32, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, isize)
impl PartialOrd<Rational> for (u32, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, u8)
impl PartialOrd<Rational> for (u32, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, u16)
impl PartialOrd<Rational> for (u32, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, u32)
impl PartialOrd<Rational> for (u32, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, u64)
impl PartialOrd<Rational> for (u32, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for u128
impl PartialOrd<Rational> for u128
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, u128)
impl PartialOrd<Rational> for (u32, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u32, usize)
impl PartialOrd<Rational> for (u32, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, i8)
impl PartialOrd<Rational> for (u64, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, i16)
impl PartialOrd<Rational> for (u64, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, i32)
impl PartialOrd<Rational> for (u64, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, i64)
impl PartialOrd<Rational> for (u64, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, i128)
impl PartialOrd<Rational> for (u64, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, isize)
impl PartialOrd<Rational> for (u64, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, u8)
impl PartialOrd<Rational> for (u64, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, u16)
impl PartialOrd<Rational> for (u64, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for usize
impl PartialOrd<Rational> for usize
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, u32)
impl PartialOrd<Rational> for (u64, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, u64)
impl PartialOrd<Rational> for (u64, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, u128)
impl PartialOrd<Rational> for (u64, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u64, usize)
impl PartialOrd<Rational> for (u64, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, i8)
impl PartialOrd<Rational> for (u128, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, i16)
impl PartialOrd<Rational> for (u128, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, i32)
impl PartialOrd<Rational> for (u128, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, i64)
impl PartialOrd<Rational> for (u128, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, i128)
impl PartialOrd<Rational> for (u128, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, isize)
impl PartialOrd<Rational> for (u128, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, i8)
impl PartialOrd<Rational> for (i8, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, u8)
impl PartialOrd<Rational> for (u128, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, u16)
impl PartialOrd<Rational> for (u128, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, u32)
impl PartialOrd<Rational> for (u128, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, u64)
impl PartialOrd<Rational> for (u128, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, u128)
impl PartialOrd<Rational> for (u128, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u128, usize)
impl PartialOrd<Rational> for (u128, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, i8)
impl PartialOrd<Rational> for (usize, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, i16)
impl PartialOrd<Rational> for (usize, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, i32)
impl PartialOrd<Rational> for (usize, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, i64)
impl PartialOrd<Rational> for (usize, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, i16)
impl PartialOrd<Rational> for (i8, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, i128)
impl PartialOrd<Rational> for (usize, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, isize)
impl PartialOrd<Rational> for (usize, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, u8)
impl PartialOrd<Rational> for (usize, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, u16)
impl PartialOrd<Rational> for (usize, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, u32)
impl PartialOrd<Rational> for (usize, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, u64)
impl PartialOrd<Rational> for (usize, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, u128)
impl PartialOrd<Rational> for (usize, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (usize, usize)
impl PartialOrd<Rational> for (usize, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for f32
impl PartialOrd<Rational> for f32
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for f64
impl PartialOrd<Rational> for f64
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, i32)
impl PartialOrd<Rational> for (i8, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for Float
impl PartialOrd<Rational> for Float
sourcefn partial_cmp(&self, q: &Rational) -> Option<Ordering>
fn partial_cmp(&self, q: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, i64)
impl PartialOrd<Rational> for (i8, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, i128)
impl PartialOrd<Rational> for (i8, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, isize)
impl PartialOrd<Rational> for (i8, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for i8
impl PartialOrd<Rational> for i8
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, u8)
impl PartialOrd<Rational> for (i8, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, u16)
impl PartialOrd<Rational> for (i8, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, u32)
impl PartialOrd<Rational> for (i8, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, u64)
impl PartialOrd<Rational> for (i8, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, u128)
impl PartialOrd<Rational> for (i8, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i8, usize)
impl PartialOrd<Rational> for (i8, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, i8)
impl PartialOrd<Rational> for (i16, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, i16)
impl PartialOrd<Rational> for (i16, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, i32)
impl PartialOrd<Rational> for (i16, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, i64)
impl PartialOrd<Rational> for (i16, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for i16
impl PartialOrd<Rational> for i16
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, i128)
impl PartialOrd<Rational> for (i16, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, isize)
impl PartialOrd<Rational> for (i16, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, u8)
impl PartialOrd<Rational> for (i16, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, u16)
impl PartialOrd<Rational> for (i16, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, u32)
impl PartialOrd<Rational> for (i16, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, u64)
impl PartialOrd<Rational> for (i16, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, u128)
impl PartialOrd<Rational> for (i16, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i16, usize)
impl PartialOrd<Rational> for (i16, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, i8)
impl PartialOrd<Rational> for (i32, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, i16)
impl PartialOrd<Rational> for (i32, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for i32
impl PartialOrd<Rational> for i32
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, i32)
impl PartialOrd<Rational> for (i32, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, i64)
impl PartialOrd<Rational> for (i32, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, i128)
impl PartialOrd<Rational> for (i32, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, isize)
impl PartialOrd<Rational> for (i32, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, u8)
impl PartialOrd<Rational> for (i32, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, u16)
impl PartialOrd<Rational> for (i32, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, u32)
impl PartialOrd<Rational> for (i32, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, u64)
impl PartialOrd<Rational> for (i32, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, u128)
impl PartialOrd<Rational> for (i32, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i32, usize)
impl PartialOrd<Rational> for (i32, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for i64
impl PartialOrd<Rational> for i64
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, i8)
impl PartialOrd<Rational> for (i64, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, i16)
impl PartialOrd<Rational> for (i64, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, i32)
impl PartialOrd<Rational> for (i64, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, i64)
impl PartialOrd<Rational> for (i64, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, i128)
impl PartialOrd<Rational> for (i64, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, isize)
impl PartialOrd<Rational> for (i64, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, u8)
impl PartialOrd<Rational> for (i64, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, u16)
impl PartialOrd<Rational> for (i64, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, u32)
impl PartialOrd<Rational> for (i64, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, u64)
impl PartialOrd<Rational> for (i64, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for i128
impl PartialOrd<Rational> for i128
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, u128)
impl PartialOrd<Rational> for (i64, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i64, usize)
impl PartialOrd<Rational> for (i64, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, i8)
impl PartialOrd<Rational> for (i128, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, i16)
impl PartialOrd<Rational> for (i128, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, i32)
impl PartialOrd<Rational> for (i128, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, i64)
impl PartialOrd<Rational> for (i128, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, i128)
impl PartialOrd<Rational> for (i128, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, isize)
impl PartialOrd<Rational> for (i128, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, u8)
impl PartialOrd<Rational> for (i128, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, u16)
impl PartialOrd<Rational> for (i128, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for isize
impl PartialOrd<Rational> for isize
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, u32)
impl PartialOrd<Rational> for (i128, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, u64)
impl PartialOrd<Rational> for (i128, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, u128)
impl PartialOrd<Rational> for (i128, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (i128, usize)
impl PartialOrd<Rational> for (i128, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, i8)
impl PartialOrd<Rational> for (isize, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, i16)
impl PartialOrd<Rational> for (isize, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, i32)
impl PartialOrd<Rational> for (isize, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, i64)
impl PartialOrd<Rational> for (isize, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, i128)
impl PartialOrd<Rational> for (isize, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, isize)
impl PartialOrd<Rational> for (isize, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for u8
impl PartialOrd<Rational> for u8
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, u8)
impl PartialOrd<Rational> for (isize, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, u16)
impl PartialOrd<Rational> for (isize, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, u32)
impl PartialOrd<Rational> for (isize, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, u64)
impl PartialOrd<Rational> for (isize, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, u128)
impl PartialOrd<Rational> for (isize, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (isize, usize)
impl PartialOrd<Rational> for (isize, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, i8)
impl PartialOrd<Rational> for (u8, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, i16)
impl PartialOrd<Rational> for (u8, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, i32)
impl PartialOrd<Rational> for (u8, i32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, i64)
impl PartialOrd<Rational> for (u8, i64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for u16
impl PartialOrd<Rational> for u16
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, i128)
impl PartialOrd<Rational> for (u8, i128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, isize)
impl PartialOrd<Rational> for (u8, isize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, u8)
impl PartialOrd<Rational> for (u8, u8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, u16)
impl PartialOrd<Rational> for (u8, u16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, u32)
impl PartialOrd<Rational> for (u8, u32)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, u64)
impl PartialOrd<Rational> for (u8, u64)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, u128)
impl PartialOrd<Rational> for (u8, u128)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u8, usize)
impl PartialOrd<Rational> for (u8, usize)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, i8)
impl PartialOrd<Rational> for (u16, i8)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for (u16, i16)
impl PartialOrd<Rational> for (u16, i16)
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<f32> for Rational
impl PartialOrd<f32> for Rational
sourcefn partial_cmp(&self, other: &f32) -> Option<Ordering>
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<f64> for Rational
impl PartialOrd<f64> for Rational
sourcefn partial_cmp(&self, other: &f64) -> Option<Ordering>
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i128> for Rational
impl PartialOrd<i128> for Rational
sourcefn partial_cmp(&self, other: &i128) -> Option<Ordering>
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i16> for Rational
impl PartialOrd<i16> for Rational
sourcefn partial_cmp(&self, other: &i16) -> Option<Ordering>
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i32> for Rational
impl PartialOrd<i32> for Rational
sourcefn partial_cmp(&self, other: &i32) -> Option<Ordering>
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i64> for Rational
impl PartialOrd<i64> for Rational
sourcefn partial_cmp(&self, other: &i64) -> Option<Ordering>
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i8> for Rational
impl PartialOrd<i8> for Rational
sourcefn partial_cmp(&self, other: &i8) -> Option<Ordering>
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<isize> for Rational
impl PartialOrd<isize> for Rational
sourcefn partial_cmp(&self, other: &isize) -> Option<Ordering>
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u128> for Rational
impl PartialOrd<u128> for Rational
sourcefn partial_cmp(&self, other: &u128) -> Option<Ordering>
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u16> for Rational
impl PartialOrd<u16> for Rational
sourcefn partial_cmp(&self, other: &u16) -> Option<Ordering>
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u32> for Rational
impl PartialOrd<u32> for Rational
sourcefn partial_cmp(&self, other: &u32) -> Option<Ordering>
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u64> for Rational
impl PartialOrd<u64> for Rational
sourcefn partial_cmp(&self, other: &u64) -> Option<Ordering>
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u8> for Rational
impl PartialOrd<u8> for Rational
sourcefn partial_cmp(&self, other: &u8) -> Option<Ordering>
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<usize> for Rational
impl PartialOrd<usize> for Rational
sourcefn partial_cmp(&self, other: &usize) -> Option<Ordering>
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PowAssign<&'_ i32> for Rational
impl PowAssign<&'_ i32> for Rational
sourcefn pow_assign(&mut self, rhs: &i32)
fn pow_assign(&mut self, rhs: &i32)
Peforms the power operation. Read more
sourceimpl PowAssign<&'_ u32> for Rational
impl PowAssign<&'_ u32> for Rational
sourcefn pow_assign(&mut self, rhs: &u32)
fn pow_assign(&mut self, rhs: &u32)
Peforms the power operation. Read more
sourceimpl PowAssign<i32> for Rational
impl PowAssign<i32> for Rational
sourcefn pow_assign(&mut self, rhs: i32)
fn pow_assign(&mut self, rhs: i32)
Peforms the power operation. Read more
sourceimpl PowAssign<u32> for Rational
impl PowAssign<u32> for Rational
sourcefn pow_assign(&mut self, rhs: u32)
fn pow_assign(&mut self, rhs: u32)
Peforms the power operation. Read more
sourceimpl ShlAssign<&'_ i32> for Rational
impl ShlAssign<&'_ i32> for Rational
sourcefn shl_assign(&mut self, rhs: &i32)
fn shl_assign(&mut self, rhs: &i32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<&'_ isize> for Rational
impl ShlAssign<&'_ isize> for Rational
sourcefn shl_assign(&mut self, rhs: &isize)
fn shl_assign(&mut self, rhs: &isize)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<&'_ u32> for Rational
impl ShlAssign<&'_ u32> for Rational
sourcefn shl_assign(&mut self, rhs: &u32)
fn shl_assign(&mut self, rhs: &u32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<&'_ usize> for Rational
impl ShlAssign<&'_ usize> for Rational
sourcefn shl_assign(&mut self, rhs: &usize)
fn shl_assign(&mut self, rhs: &usize)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<i32> for Rational
impl ShlAssign<i32> for Rational
sourcefn shl_assign(&mut self, rhs: i32)
fn shl_assign(&mut self, rhs: i32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<isize> for Rational
impl ShlAssign<isize> for Rational
sourcefn shl_assign(&mut self, rhs: isize)
fn shl_assign(&mut self, rhs: isize)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<u32> for Rational
impl ShlAssign<u32> for Rational
sourcefn shl_assign(&mut self, rhs: u32)
fn shl_assign(&mut self, rhs: u32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<usize> for Rational
impl ShlAssign<usize> for Rational
sourcefn shl_assign(&mut self, rhs: usize)
fn shl_assign(&mut self, rhs: usize)
Performs the <<=
operation. Read more
sourceimpl ShrAssign<&'_ i32> for Rational
impl ShrAssign<&'_ i32> for Rational
sourcefn shr_assign(&mut self, rhs: &i32)
fn shr_assign(&mut self, rhs: &i32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<&'_ isize> for Rational
impl ShrAssign<&'_ isize> for Rational
sourcefn shr_assign(&mut self, rhs: &isize)
fn shr_assign(&mut self, rhs: &isize)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<&'_ u32> for Rational
impl ShrAssign<&'_ u32> for Rational
sourcefn shr_assign(&mut self, rhs: &u32)
fn shr_assign(&mut self, rhs: &u32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<&'_ usize> for Rational
impl ShrAssign<&'_ usize> for Rational
sourcefn shr_assign(&mut self, rhs: &usize)
fn shr_assign(&mut self, rhs: &usize)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<i32> for Rational
impl ShrAssign<i32> for Rational
sourcefn shr_assign(&mut self, rhs: i32)
fn shr_assign(&mut self, rhs: i32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<isize> for Rational
impl ShrAssign<isize> for Rational
sourcefn shr_assign(&mut self, rhs: isize)
fn shr_assign(&mut self, rhs: isize)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<u32> for Rational
impl ShrAssign<u32> for Rational
sourcefn shr_assign(&mut self, rhs: u32)
fn shr_assign(&mut self, rhs: u32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<usize> for Rational
impl ShrAssign<usize> for Rational
sourcefn shr_assign(&mut self, rhs: usize)
fn shr_assign(&mut self, rhs: usize)
Performs the >>=
operation. Read more
sourceimpl SubAssign<&'_ Integer> for Rational
impl SubAssign<&'_ Integer> for Rational
sourcefn sub_assign(&mut self, rhs: &Integer)
fn sub_assign(&mut self, rhs: &Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ Rational> for Rational
impl SubAssign<&'_ Rational> for Rational
sourcefn sub_assign(&mut self, rhs: &Rational)
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ Rational> for Float
impl SubAssign<&'_ Rational> for Float
sourcefn sub_assign(&mut self, rhs: &Rational)
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ Rational> for Complex
impl SubAssign<&'_ Rational> for Complex
sourcefn sub_assign(&mut self, rhs: &Rational)
fn sub_assign(&mut self, rhs: &Rational)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ i128> for Rational
impl SubAssign<&'_ i128> for Rational
sourcefn sub_assign(&mut self, rhs: &i128)
fn sub_assign(&mut self, rhs: &i128)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ i16> for Rational
impl SubAssign<&'_ i16> for Rational
sourcefn sub_assign(&mut self, rhs: &i16)
fn sub_assign(&mut self, rhs: &i16)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ i32> for Rational
impl SubAssign<&'_ i32> for Rational
sourcefn sub_assign(&mut self, rhs: &i32)
fn sub_assign(&mut self, rhs: &i32)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ i64> for Rational
impl SubAssign<&'_ i64> for Rational
sourcefn sub_assign(&mut self, rhs: &i64)
fn sub_assign(&mut self, rhs: &i64)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ i8> for Rational
impl SubAssign<&'_ i8> for Rational
sourcefn sub_assign(&mut self, rhs: &i8)
fn sub_assign(&mut self, rhs: &i8)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ isize> for Rational
impl SubAssign<&'_ isize> for Rational
sourcefn sub_assign(&mut self, rhs: &isize)
fn sub_assign(&mut self, rhs: &isize)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ u128> for Rational
impl SubAssign<&'_ u128> for Rational
sourcefn sub_assign(&mut self, rhs: &u128)
fn sub_assign(&mut self, rhs: &u128)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ u16> for Rational
impl SubAssign<&'_ u16> for Rational
sourcefn sub_assign(&mut self, rhs: &u16)
fn sub_assign(&mut self, rhs: &u16)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ u32> for Rational
impl SubAssign<&'_ u32> for Rational
sourcefn sub_assign(&mut self, rhs: &u32)
fn sub_assign(&mut self, rhs: &u32)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ u64> for Rational
impl SubAssign<&'_ u64> for Rational
sourcefn sub_assign(&mut self, rhs: &u64)
fn sub_assign(&mut self, rhs: &u64)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ u8> for Rational
impl SubAssign<&'_ u8> for Rational
sourcefn sub_assign(&mut self, rhs: &u8)
fn sub_assign(&mut self, rhs: &u8)
Performs the -=
operation. Read more
sourceimpl SubAssign<&'_ usize> for Rational
impl SubAssign<&'_ usize> for Rational
sourcefn sub_assign(&mut self, rhs: &usize)
fn sub_assign(&mut self, rhs: &usize)
Performs the -=
operation. Read more
sourceimpl SubAssign<Integer> for Rational
impl SubAssign<Integer> for Rational
sourcefn sub_assign(&mut self, rhs: Integer)
fn sub_assign(&mut self, rhs: Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<Rational> for Rational
impl SubAssign<Rational> for Rational
sourcefn sub_assign(&mut self, rhs: Rational)
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation. Read more
sourceimpl SubAssign<Rational> for Float
impl SubAssign<Rational> for Float
sourcefn sub_assign(&mut self, rhs: Rational)
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation. Read more
sourceimpl SubAssign<Rational> for Complex
impl SubAssign<Rational> for Complex
sourcefn sub_assign(&mut self, rhs: Rational)
fn sub_assign(&mut self, rhs: Rational)
Performs the -=
operation. Read more
sourceimpl SubAssign<i128> for Rational
impl SubAssign<i128> for Rational
sourcefn sub_assign(&mut self, rhs: i128)
fn sub_assign(&mut self, rhs: i128)
Performs the -=
operation. Read more
sourceimpl SubAssign<i16> for Rational
impl SubAssign<i16> for Rational
sourcefn sub_assign(&mut self, rhs: i16)
fn sub_assign(&mut self, rhs: i16)
Performs the -=
operation. Read more
sourceimpl SubAssign<i32> for Rational
impl SubAssign<i32> for Rational
sourcefn sub_assign(&mut self, rhs: i32)
fn sub_assign(&mut self, rhs: i32)
Performs the -=
operation. Read more
sourceimpl SubAssign<i64> for Rational
impl SubAssign<i64> for Rational
sourcefn sub_assign(&mut self, rhs: i64)
fn sub_assign(&mut self, rhs: i64)
Performs the -=
operation. Read more
sourceimpl SubAssign<i8> for Rational
impl SubAssign<i8> for Rational
sourcefn sub_assign(&mut self, rhs: i8)
fn sub_assign(&mut self, rhs: i8)
Performs the -=
operation. Read more
sourceimpl SubAssign<isize> for Rational
impl SubAssign<isize> for Rational
sourcefn sub_assign(&mut self, rhs: isize)
fn sub_assign(&mut self, rhs: isize)
Performs the -=
operation. Read more
sourceimpl SubAssign<u128> for Rational
impl SubAssign<u128> for Rational
sourcefn sub_assign(&mut self, rhs: u128)
fn sub_assign(&mut self, rhs: u128)
Performs the -=
operation. Read more
sourceimpl SubAssign<u16> for Rational
impl SubAssign<u16> for Rational
sourcefn sub_assign(&mut self, rhs: u16)
fn sub_assign(&mut self, rhs: u16)
Performs the -=
operation. Read more
sourceimpl SubAssign<u32> for Rational
impl SubAssign<u32> for Rational
sourcefn sub_assign(&mut self, rhs: u32)
fn sub_assign(&mut self, rhs: u32)
Performs the -=
operation. Read more
sourceimpl SubAssign<u64> for Rational
impl SubAssign<u64> for Rational
sourcefn sub_assign(&mut self, rhs: u64)
fn sub_assign(&mut self, rhs: u64)
Performs the -=
operation. Read more
sourceimpl SubAssign<u8> for Rational
impl SubAssign<u8> for Rational
sourcefn sub_assign(&mut self, rhs: u8)
fn sub_assign(&mut self, rhs: u8)
Performs the -=
operation. Read more
sourceimpl SubAssign<usize> for Rational
impl SubAssign<usize> for Rational
sourcefn sub_assign(&mut self, rhs: usize)
fn sub_assign(&mut self, rhs: usize)
Performs the -=
operation. Read more
sourceimpl SubAssignRound<&'_ Rational> for Float
impl SubAssignRound<&'_ Rational> for Float
sourceimpl SubAssignRound<&'_ Rational> for Complex
impl SubAssignRound<&'_ Rational> for Complex
sourceimpl SubAssignRound<Rational> for Float
impl SubAssignRound<Rational> for Float
sourceimpl SubAssignRound<Rational> for Complex
impl SubAssignRound<Rational> for Complex
sourceimpl SubFromRound<&'_ Rational> for Float
impl SubFromRound<&'_ Rational> for Float
sourceimpl SubFromRound<&'_ Rational> for Complex
impl SubFromRound<&'_ Rational> for Complex
sourceimpl SubFromRound<Rational> for Float
impl SubFromRound<Rational> for Float
sourceimpl SubFromRound<Rational> for Complex
impl SubFromRound<Rational> for Complex
sourceimpl ToPrimitive for Rational
impl ToPrimitive for Rational
sourcefn to_i64(&self) -> Option<i64>
fn to_i64(&self) -> Option<i64>
Converts the value of self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned. Read more
sourcefn to_u64(&self) -> Option<u64>
fn to_u64(&self) -> Option<u64>
Converts the value of self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned. Read more
sourcefn to_isize(&self) -> Option<isize>
fn to_isize(&self) -> Option<isize>
Converts the value of self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned. Read more
sourcefn to_i8(&self) -> Option<i8>
fn to_i8(&self) -> Option<i8>
Converts the value of self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned. Read more
sourcefn to_i16(&self) -> Option<i16>
fn to_i16(&self) -> Option<i16>
Converts the value of self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned. Read more
sourcefn to_i32(&self) -> Option<i32>
fn to_i32(&self) -> Option<i32>
Converts the value of self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned. Read more
sourcefn to_i128(&self) -> Option<i128>
fn to_i128(&self) -> Option<i128>
Converts the value of self
to an i128
. If the value cannot be
represented by an i128
(i64
under the default implementation), then
None
is returned. Read more
sourcefn to_usize(&self) -> Option<usize>
fn to_usize(&self) -> Option<usize>
Converts the value of self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned. Read more
sourcefn to_u8(&self) -> Option<u8>
fn to_u8(&self) -> Option<u8>
Converts the value of self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned. Read more
sourcefn to_u16(&self) -> Option<u16>
fn to_u16(&self) -> Option<u16>
Converts the value of self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned. Read more
sourcefn to_u32(&self) -> Option<u32>
fn to_u32(&self) -> Option<u32>
Converts the value of self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned. Read more
sourcefn to_u128(&self) -> Option<u128>
fn to_u128(&self) -> Option<u128>
Converts the value of self
to a u128
. If the value cannot be
represented by a u128
(u64
under the default implementation), then
None
is returned. Read more
sourceimpl TryFrom<&'_ Float> for Rational
impl TryFrom<&'_ Float> for Rational
type Error = TryFromFloatError
type Error = TryFromFloatError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Float) -> Result<Self, TryFromFloatError>
fn try_from(value: &Float) -> Result<Self, TryFromFloatError>
Performs the conversion.
sourceimpl TryFrom<Float> for Rational
impl TryFrom<Float> for Rational
type Error = TryFromFloatError
type Error = TryFromFloatError
The type returned in the event of a conversion error.
sourcefn try_from(value: Float) -> Result<Self, TryFromFloatError>
fn try_from(value: Float) -> Result<Self, TryFromFloatError>
Performs the conversion.
sourceimpl TryFrom<f32> for Rational
impl TryFrom<f32> for Rational
type Error = TryFromFloatError
type Error = TryFromFloatError
The type returned in the event of a conversion error.
sourcefn try_from(value: f32) -> Result<Self, TryFromFloatError>
fn try_from(value: f32) -> Result<Self, TryFromFloatError>
Performs the conversion.
sourceimpl TryFrom<f64> for Rational
impl TryFrom<f64> for Rational
type Error = TryFromFloatError
type Error = TryFromFloatError
The type returned in the event of a conversion error.
sourcefn try_from(value: f64) -> Result<Self, TryFromFloatError>
fn try_from(value: f64) -> Result<Self, TryFromFloatError>
Performs the conversion.
sourceimpl UnwrappedCast<Rational> for f32
impl UnwrappedCast<Rational> for f32
sourcefn unwrapped_cast(self) -> Rational
fn unwrapped_cast(self) -> Rational
Casts the value.
sourceimpl UnwrappedCast<Rational> for f64
impl UnwrappedCast<Rational> for f64
sourcefn unwrapped_cast(self) -> Rational
fn unwrapped_cast(self) -> Rational
Casts the value.
sourceimpl UnwrappedCast<Rational> for Float
impl UnwrappedCast<Rational> for Float
sourcefn unwrapped_cast(self) -> Rational
fn unwrapped_cast(self) -> Rational
Casts the value.
sourceimpl UnwrappedCast<Rational> for &Float
impl UnwrappedCast<Rational> for &Float
sourcefn unwrapped_cast(self) -> Rational
fn unwrapped_cast(self) -> Rational
Casts the value.
impl Eq for Rational
impl Send for Rational
impl Sync for Rational
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> CheckedAs for T
impl<T> CheckedAs for T
sourcefn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,
fn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> CheckedCastFrom<Src> for Dst where
Src: CheckedCast<Dst>,
impl<Src, Dst> CheckedCastFrom<Src> for Dst where
Src: CheckedCast<Dst>,
sourcefn checked_cast_from(src: Src) -> Option<Dst>
fn checked_cast_from(src: Src) -> Option<Dst>
Casts the value.
sourceimpl<T> OverflowingAs for T
impl<T> OverflowingAs for T
sourcefn overflowing_as<Dst>(self) -> (Dst, bool) where
T: OverflowingCast<Dst>,
fn overflowing_as<Dst>(self) -> (Dst, bool) where
T: OverflowingCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> OverflowingCastFrom<Src> for Dst where
Src: OverflowingCast<Dst>,
impl<Src, Dst> OverflowingCastFrom<Src> for Dst where
Src: OverflowingCast<Dst>,
sourcefn overflowing_cast_from(src: Src) -> (Dst, bool)
fn overflowing_cast_from(src: Src) -> (Dst, bool)
OverflowingCasts the value.
sourceimpl<T> SaturatingAs for T
impl<T> SaturatingAs for T
sourcefn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,
fn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> SaturatingCastFrom<Src> for Dst where
Src: SaturatingCast<Dst>,
impl<Src, Dst> SaturatingCastFrom<Src> for Dst where
Src: SaturatingCast<Dst>,
sourcefn saturating_cast_from(src: Src) -> Dst
fn saturating_cast_from(src: Src) -> Dst
Casts the value.
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
sourceimpl<T> UnwrappedAs for T
impl<T> UnwrappedAs for T
sourcefn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,
fn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> UnwrappedCastFrom<Src> for Dst where
Src: UnwrappedCast<Dst>,
impl<Src, Dst> UnwrappedCastFrom<Src> for Dst where
Src: UnwrappedCast<Dst>,
sourcefn unwrapped_cast_from(src: Src) -> Dst
fn unwrapped_cast_from(src: Src) -> Dst
UnwrappedCasts the value.
sourceimpl<T> WrappingAs for T
impl<T> WrappingAs for T
sourcefn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,
fn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> WrappingCastFrom<Src> for Dst where
Src: WrappingCast<Dst>,
impl<Src, Dst> WrappingCastFrom<Src> for Dst where
Src: WrappingCast<Dst>,
sourcefn wrapping_cast_from(src: Src) -> Dst
fn wrapping_cast_from(src: Src) -> Dst
WrappingCasts the value.