Struct rug::Rational

pub struct Rational { /* private fields */ }

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, Rational::from((-5, 4)));
assert_eq!(recip, -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);

When comparing Rational numbers, it is sometimes convenient to compare to a pair of primitive integers, like in the comparison to Rational::from((-5, 4)) in the example above. Rational::from((-5, 4)) requires memory allocation, which can be an expensive operation. To avoid this allocation, when both the numerator and denominator fit in a primitive integer, we can use MiniRational instead, which does not require heap memory allocation.

use rug::rational::MiniRational;
use rug::Rational;
let r = Rational::from((-12, 15));
let recip = Rational::from(r.recip_ref());
assert_eq!(recip, MiniRational::from((-5, 4)));

The Rational number type supports various functions. Most methods have three versions:

1. The first method consumes the operand.
2. The second method has a “_mut” suffix and mutates the operand.
3. The third method has a “_ref” suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to a Rational number.

use rug::rational::MiniRational;
use rug::Rational;

// 1. consume the operand
let a = Rational::from((-15, 2));
let abs_a = a.abs();
assert_eq!(abs_a, MiniRational::from((15, 2)));

// 2. mutate the operand
let mut b = Rational::from((-17, 2));
b.abs_mut();
assert_eq!(b, MiniRational::from((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, MiniRational::from((19, 2)));
// c was not consumed
assert_eq!(c, MiniRational::from((-19, 2)));

Implementations

impl Rational

pub const ZERO: &'static Rational = _

Zero.

Examples

use rug::Rational;
assert_eq!(*Rational::ZERO, 0);

pub const ONE: &'static Rational = _

One.

Examples

use rug::Rational;
assert_eq!(*Rational::ONE, 1);

pub const NEG_ONE: &'static Rational = _

Negative one (−1).

Examples

use rug::Rational;
assert_eq!(*Rational::NEG_ONE, -1);

pub fn new() -> Self

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

Examples

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

pub 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 static Rational number. This is because constant values are copied on use, leading to undefined behavior when they are dropped.
• The value must be initialized as a valid mpq_t.
• 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::MiniRational;
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, MiniRational::from((-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;
use gmp_mpfr_sys::gmp::{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().cast_mut(), -2),
        den: gmp::MPZ_ROINIT_N(DENOM_LIMBS.as_ptr().cast_mut(), 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());

pub const 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);
}

pub const 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::MiniRational;
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, MiniRational::from((-145, 10)));

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::MiniRational;
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, MiniRational::from((-10, 145)));

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 rug::rational::MiniRational;
use rug::Rational;
// -17.125 can be stored exactly as f32
let r = Rational::from_f32(-17.125).unwrap();
assert_eq!(r, MiniRational::from((-17125, 1000)));
let inf = Rational::from_f32(f32::INFINITY);
assert!(inf.is_none());

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 rug::rational::MiniRational;
use rug::Rational;
// -17.125 can be stored exactly as f64
let r = Rational::from_f64(-17.125).unwrap();
assert_eq!(r, MiniRational::from((-17125, 1000)));
let inf = Rational::from_f64(f64::INFINITY);
assert!(inf.is_none());

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

Parses a Rational number.

Panics

Panics if radix is less than 2 or greater than 36.

Examples

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

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for Src

The string must contain a numerator, and may contain a denominator; the numerator and denominator are separated with a “/”. The numerator can start with an optional minus or plus sign.

ASCII whitespace is ignored everywhere in the string. Underscores are ignored anywhere except before the first digit of the numerator and between the “/” and the the first digit of the denominator.

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};

assert_eq!(
    Rational::parse("-12/23").unwrap().complete(),
    MiniRational::from((-12, 23))
);
assert_eq!(
    Rational::parse("+ 12 / 23").unwrap().complete(),
    MiniRational::from((12, 23))
);

let invalid = Rational::parse("12/");
assert!(invalid.is_err());

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for 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.

If parsing is already done by an external function, the unsafe low-level Integer::assign_bytes_radix_unchecked method can be used in conjunction with the mutate_numer_denom method.

Panics

Panics if radix is less than 2 or greater than 36.

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};

let valid1 = Rational::parse_radix("12/23", 4);
assert_eq!(
    valid1.unwrap().complete(),
    MiniRational::from((2 + 4 * 1, 3 + 4 * 2))
);
let valid2 = Rational::parse_radix("12 / yz", 36);
assert_eq!(
    valid2.unwrap().complete(),
    MiniRational::from((2 + 36 * 1, 35 + 36 * 34))
);

let invalid = Rational::parse_radix("12/23", 3);
assert!(invalid.is_err());

If parsing is done externally, low-level code can be used.

use rug::rational::MiniRational;
use rug::Rational;

let num_bytes = &[1, 2];
let den_bytes = &[2, 3];
let radix = 10;
let neg = true;
let mut r = Rational::new();
// SAFETY: radix and the bytes are in the required ranges
r.mutate_numer_denom(|num, den| unsafe {
    num.assign_bytes_radix_unchecked(num_bytes, radix, neg);
    den.assign_bytes_radix_unchecked(den_bytes, radix, false);
});
// -12/23
assert_eq!(r, MiniRational::from((-12, 23)));

pub fn to_f32(&self) -> f32

Converts to an f32, rounding towards zero.

This conversion can also be performed using

• (&rational).az::<f32>()
• rational.borrow().az::<f32>()
• rational.az::<f32>()

Examples

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

pub fn to_f64(&self) -> f64

Converts to an f64, rounding towards zero.

This conversion can also be performed using

• (&rational).az::<f64>()
• rational.borrow().az::<f64>()
• rational.az::<f64>()

Examples

use rug::rational::MiniRational;
use rug::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 + MiniRational::from((7, 2)).borrow_excl();
// plus_small is truncated to f64::MAX
assert_eq!(plus_small.to_f64(), f64::MAX);
let times_three_two = plus_small * MiniRational::from((3, 2)).borrow_excl();
// times_three_two is too large
assert_eq!(times_three_two.to_f64(), f64::INFINITY);

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

Returns a string representation for the specified radix.

Panics

Panics if radix is less than 2 or greater than 36.

Examples

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

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

Assigns from an f32 if it is finite, losing no precision.

Examples

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

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

Assigns from an f64 if it is finite, losing no precision.

Examples

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

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 and denom, 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::MiniRational;
use rug::Rational;

// -3/5 is in canonical form
let r = unsafe { Rational::from_canonical(-3, 5) };
assert_eq!(r, MiniRational::from((-3, 5)));

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 and denom, 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::MiniRational;
use rug::Rational;

let mut r = Rational::new();
// -3/5 is in canonical form
unsafe {
    r.assign_canonical(-3, 5);
}
assert_eq!(r, MiniRational::from((-3, 5)));

pub const fn numer(&self) -> &Integer

Borrows the numerator as an Integer.

Examples

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

pub const fn denom(&self) -> &Integer

Borrows the denominator as an Integer.

Examples

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

pub fn mutate_numer_denom<F>(&mut self, func: F)

where F: FnOnce(&mut Integer, &mut Integer),

Calls a function with mutable references to the numerator and denominator, then canonicalizes the number.

The denominator must not be zero when the function returns.

Panics

Panics if the denominator is zero when the function returns.

Examples

use rug::Rational;
let mut r = Rational::from((3, 5));
r.mutate_numer_denom(|num, den| {
    // change r from 3/5 to 4/8, which is equal to 1/2
    *num += 1;
    *den += 3;
});
assert_eq!(*r.numer(), 1);
assert_eq!(*r.denom(), 2);

This method does not check that the numerator and denominator are in canonical form before calling func. This means that this method can be used to canonicalize the number after some unsafe methods that do not leave the number in cononical form.

use rug::Rational;
let mut r = Rational::from((3, 5));
unsafe {
    // leave r in non-canonical form
    *r.as_mut_numer_denom_no_canonicalization().0 += 1;
    *r.as_mut_numer_denom_no_canonicalization().1 -= 13;
}
// At this point, r is still not canonical: 4 / -8
assert_eq!(*r.numer(), 4);
assert_eq!(*r.denom(), -8);
r.mutate_numer_denom(|_, _| {});
// Now r is in canonical form: -1 / 2
assert_eq!(*r.numer(), -1);
assert_eq!(*r.denom(), 2);

pub unsafe fn as_mut_numer_denom_no_canonicalization( &mut self ) -> (&mut Integer, &mut Integer)

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 and denom, 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::MiniRational;
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, MiniRational::from((8, 5)));

This method can also be used to group some operations before canonicalization. This is usually not beneficial, as early canonicalization usually means subsequent arithmetic operations have less work to do.

use rug::Rational;
let mut r = Rational::from((3, 5));
unsafe {
    // first operation: add 1 to numerator
    *r.as_mut_numer_denom_no_canonicalization().0 += 1;
    // second operation: subtract 13 from denominator
    *r.as_mut_numer_denom_no_canonicalization().1 -= 13;
}
// At this point, r is still not canonical: 4 / -8
assert_eq!(*r.numer(), 4);
assert_eq!(*r.denom(), -8);
r.mutate_numer_denom(|_, _| {});
// Now r is in canonical form: -1 / 2
assert_eq!(*r.numer(), -1);
assert_eq!(*r.denom(), 2);

pub const fn into_numer_denom(self) -> (Integer, Integer)

Converts into numerator and denominator Integer values.

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

Examples

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

pub const 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::MiniRational;
use rug::Rational;
let r = Rational::from((7, 11));
let neg_r = r.as_neg();
assert_eq!(*neg_r, MiniRational::from((-7, 11)));
// methods taking &self can be used on the returned object
let reneg_r = neg_r.as_neg();
assert_eq!(*reneg_r, MiniRational::from((7, 11)));
assert_eq!(*reneg_r, r);

pub const 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::MiniRational;
use rug::Rational;
let r = Rational::from((-7, 11));
let abs_r = r.as_abs();
assert_eq!(*abs_r, MiniRational::from((7, 11)));
// methods taking &self can be used on the returned object
let reabs_r = abs_r.as_abs();
assert_eq!(*reabs_r, MiniRational::from((7, 11)));
assert_eq!(*reabs_r, *abs_r);

pub const 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::MiniRational;
use rug::Rational;
let r = Rational::from((-7, 11));
let recip_r = r.as_recip();
assert_eq!(*recip_r, MiniRational::from((-11, 7)));
// methods taking &self can be used on the returned object
let rerecip_r = recip_r.as_recip();
assert_eq!(*rerecip_r, MiniRational::from((-7, 11)));
assert_eq!(*rerecip_r, r);

pub const fn is_zero(&self) -> bool

Returns true if the number is zero.

Examples

use rug::Rational;
assert!(Rational::from(0).is_zero());
assert!(!(Rational::from((1, 2)).is_zero()));

pub const fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

Examples

use rug::Rational;
assert!(Rational::from((1, 2)).is_positive());
assert!(!(Rational::from((-1, 2)).is_positive()));

pub const fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

Examples

use rug::Rational;
assert!(Rational::from((-1, 2)).is_negative());
assert!(!(Rational::from((1, 2)).is_negative()));

pub const fn cmp0(&self) -> Ordering

Returns the same result as self.cmp(&0.into()), but is faster.

Examples

use core::cmp::Ordering;
use rug::Rational;
assert_eq!(Rational::from((-5, 7)).cmp0(), Ordering::Less);
assert_eq!(Rational::from(0).cmp0(), Ordering::Equal);
assert_eq!(Rational::from((5, 7)).cmp0(), Ordering::Greater);

pub fn cmp_abs(&self, other: &Self) -> Ordering

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

pub const fn is_integer(&self) -> bool

Returns true if the number is an integer.

Examples

use rug::Rational;
assert!(!(Rational::from((5, 2)).is_integer()));
assert!(Rational::from(3).is_integer());

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::rational::MiniRational;
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 = MiniRational::from((5 * 7 - 100_000 * 2 - 4 * 14, 14));
assert_eq!(sum, expected);

pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I>

where I: Iterator<Item = (&'a Self, &'a Self)>,

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::rational::MiniRational;
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 = MiniRational::from((270 * 20 - 11, 20));
assert_eq!(dot, expected);

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::rational::MiniRational;
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 = MiniRational::from((5 * -100_000 * -4, 2 * 7));
assert_eq!(product, expected);

pub fn abs(self) -> Self

Computes the absolute value.

Examples

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

pub fn abs_mut(&mut self)

Computes the absolute value.

Examples

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

pub fn abs_ref(&self) -> AbsIncomplete<'_>

Computes the absolute value.

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

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};
let r = Rational::from((-100, 17));
let abs = r.abs_ref().complete();
assert_eq!(abs, MiniRational::from((100, 17)));

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

pub fn signum_mut(&mut self)

Computes the signum.

• 0 if the value is zero
• 1 if the value is positive
• −1 if the value is negative

Examples

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

pub fn signum_ref(&self) -> SignumIncomplete<'_>

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

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::MiniRational;
use rug::Rational;
let min = MiniRational::from((-3, 2));
let max = MiniRational::from((3, 2));
let min_borrow = &*min.borrow();
let max_borrow = &*max.borrow();
let too_small = Rational::from((-5, 2));
let clamped1 = too_small.clamp(min_borrow, max_borrow);
assert_eq!(clamped1, MiniRational::from((-3, 2)));
let in_range = Rational::from((1, 2));
let clamped2 = in_range.clamp(min_borrow, max_borrow);
assert_eq!(clamped2, MiniRational::from((1, 2)));

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::MiniRational;
use rug::Rational;
let min = MiniRational::from((-3, 2));
let max = MiniRational::from((3, 2));
let min_borrow = &*min.borrow();
let max_borrow = &*max.borrow();
let mut too_small = Rational::from((-5, 2));
too_small.clamp_mut(min_borrow, max_borrow);
assert_eq!(too_small, MiniRational::from((-3, 2)));
let mut in_range = Rational::from((1, 2));
in_range.clamp_mut(min_borrow, max_borrow);
assert_eq!(in_range, MiniRational::from((1, 2)));

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for Src

Panics

Panics if the maximum value is less than the minimum value.

Examples

use rug::rational::MiniRational;
use rug::{Assign, Complete, Rational};
let min = MiniRational::from((-3, 2));
let max = MiniRational::from((3, 2));
let min_borrow = &*min.borrow();
let max_borrow = &*max.borrow();
let too_small = Rational::from((-5, 2));
let mut clamped = too_small.clamp_ref(min_borrow, max_borrow).complete();
assert_eq!(clamped, MiniRational::from((-3, 2)));
let in_range = Rational::from((1, 2));
clamped.assign(in_range.clamp_ref(min_borrow, max_borrow));
assert_eq!(clamped, MiniRational::from((1, 2)));

pub fn recip(self) -> Self

Computes the reciprocal.

Panics

Panics if the value is zero.

Examples

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

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::MiniRational;
use rug::Rational;
let mut r = Rational::from((-100, 17));
r.recip_mut();
assert_eq!(r, MiniRational::from((-17, 100)));

pub fn recip_ref(&self) -> RecipIncomplete<'_>

Computes the reciprocal.

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

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};
let r = Rational::from((-100, 17));
assert_eq!(r.recip_ref().complete(), MiniRational::from((-17, 100)));

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

pub fn trunc_mut(&mut self)

Rounds the number towards zero.

Examples

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

pub fn trunc_ref(&self) -> TruncIncomplete<'_>

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

pub fn rem_trunc(self) -> Self

Computes the fractional part of the number.

Examples

use rug::rational::MiniRational;
use rug::Rational;
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
let rem = r.rem_trunc();
assert_eq!(rem, MiniRational::from((-15, 17)));

pub fn rem_trunc_mut(&mut self)

Computes the fractional part of the number.

Examples

use rug::rational::MiniRational;
use rug::Rational;
// -100/17 = -5 - 15/17
let mut r = Rational::from((-100, 17));
r.rem_trunc_mut();
assert_eq!(r, MiniRational::from((-15, 17)));

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for Src

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
assert_eq!(r.rem_trunc_ref().complete(), MiniRational::from((-15, 17)));

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::rational::MiniRational;
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, MiniRational::from((-15, 17)));
assert_eq!(trunc, -5);

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::rational::MiniRational;
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, MiniRational::from((-15, 17)));
assert_eq!(whole, -5);

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::rational::MiniRational;
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, MiniRational::from((-15, 17)));
assert_eq!(trunc, -5);

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

pub fn ceil_mut(&mut self)

Rounds the number upwards (towards plus infinity).

Examples

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

pub fn ceil_ref(&self) -> CeilIncomplete<'_>

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

pub fn rem_ceil(self) -> Self

Computes the non-positive remainder after rounding up.

Examples

use rug::rational::MiniRational;
use rug::Rational;
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
let rem = r.rem_ceil();
assert_eq!(rem, MiniRational::from((-2, 17)));

pub fn rem_ceil_mut(&mut self)

Computes the non-positive remainder after rounding up.

Examples

use rug::rational::MiniRational;
use rug::Rational;
// 100/17 = 6 - 2/17
let mut r = Rational::from((100, 17));
r.rem_ceil_mut();
assert_eq!(r, MiniRational::from((-2, 17)));

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for Src

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
assert_eq!(r.rem_ceil_ref().complete(), MiniRational::from((-2, 17)));

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::rational::MiniRational;
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, MiniRational::from((-2, 17)));
assert_eq!(ceil, 6);

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::rational::MiniRational;
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, MiniRational::from((-2, 17)));
assert_eq!(ceil, 6);

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::rational::MiniRational;
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, MiniRational::from((-2, 17)));
assert_eq!(ceil, 6);

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

pub fn floor_mut(&mut self)

Rounds the number downwards (towards minus infinity).

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

pub fn floor_ref(&self) -> FloorIncomplete<'_>

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

pub fn rem_floor(self) -> Self

Computes the non-negative remainder after rounding down.

Examples

use rug::rational::MiniRational;
use rug::Rational;
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
let rem = r.rem_floor();
assert_eq!(rem, MiniRational::from((2, 17)));

pub fn rem_floor_mut(&mut self)

Computes the non-negative remainder after rounding down.

Examples

use rug::rational::MiniRational;
use rug::Rational;
// -100/17 = -6 + 2/17
let mut r = Rational::from((-100, 17));
r.rem_floor_mut();
assert_eq!(r, MiniRational::from((2, 17)));

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for Src

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
assert_eq!(r.rem_floor_ref().complete(), MiniRational::from((2, 17)));

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::rational::MiniRational;
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, MiniRational::from((2, 17)));
assert_eq!(floor, -6);

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::rational::MiniRational;
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, MiniRational::from((2, 17)));
assert_eq!(floor, -6);

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::rational::MiniRational;
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, MiniRational::from((2, 17)));
assert_eq!(floor, -6);

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

pub fn round_mut(&mut self)

Rounds the number to the nearest integer.

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

Examples

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

pub fn round_ref(&self) -> RoundIncomplete<'_>

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

pub fn rem_round(self) -> Self

Computes the remainder after rounding to the nearest integer.

Examples

use rug::rational::MiniRational;
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, MiniRational::from((1, 2)));
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
let rem2 = r2.rem_round();
assert_eq!(rem2, MiniRational::from((-3, 10)));

pub fn rem_round_mut(&mut self)

Computes the remainder after rounding to the nearest integer.

Examples

use rug::rational::MiniRational;
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, MiniRational::from((1, 2)));
// 3.7 = 4 - 0.3 = 4 - 3/10
let mut r2 = Rational::from((37, 10));
r2.rem_round_mut();
assert_eq!(r2, MiniRational::from((-3, 10)));

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:

• Assign<Src> for Rational
• From<Src> for Rational
• Complete<Completed = Rational> for Src

Examples

use rug::rational::MiniRational;
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, MiniRational::from((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, MiniRational::from((-3, 10)));

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::rational::MiniRational;
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, MiniRational::from((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, MiniRational::from((-3, 10)));
assert_eq!(round2, 4);

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::rational::MiniRational;
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, MiniRational::from((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, MiniRational::from((-3, 10)));
assert_eq!(round2, 4);

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::rational::MiniRational;
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, MiniRational::from((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, MiniRational::from((-3, 10)));
assert_eq!(round2, 4);

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::MiniRational;
use rug::Rational;
let r = Rational::from((-13, 2));
let square = r.square();
assert_eq!(square, MiniRational::from((169, 4)));

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::MiniRational;
use rug::Rational;
let mut r = Rational::from((-13, 2));
r.square_mut();
assert_eq!(r, MiniRational::from((169, 4)));

pub fn square_ref(&self) -> MulIncomplete<'_>

Computes the square.

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

r.square_ref() produces the exact same result as &r * &r.

Examples

use rug::rational::MiniRational;
use rug::{Complete, Rational};
let r = Rational::from((-13, 2));
assert_eq!(r.square_ref().complete(), MiniRational::from((169, 4)));

Trait Implementations

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

type Output = AddRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Complex) -> AddRationalIncomplete<'_>

Performs the + operation.

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

type Output = AddOwnedRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &Complex) -> AddOwnedRationalIncomplete<'_>

Performs the + operation.

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

type Output = AddRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Float) -> AddRationalIncomplete<'_>

Performs the + operation.

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

type Output = AddOwnedRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &Float) -> AddOwnedRationalIncomplete<'_>

Performs the + operation.

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

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl Add<&Integer> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> Rational

Performs the + operation.

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

type Output = AddRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddRationalIncomplete<'_>

Performs the + operation.

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

type Output = AddRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddRationalIncomplete<'_>

Performs the + operation.

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

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &i128

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &i16

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &i32

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &i64

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &i8

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &isize

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddIsizeIncomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &u128

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &u16

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &u32

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &u64

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &u8

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for &usize

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddUsizeIncomplete<'_>

Performs the + operation.

impl Add<&Rational> for Complex

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> Complex

Performs the + operation.

impl Add<&Rational> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> Float

Performs the + operation.

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

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl Add<&Rational> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&'b Rational> for i128

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for i16

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for i32

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for i64

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for i8

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddI8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for isize

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddIsizeIncomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for u128

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for u16

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for u32

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for u64

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for u8

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddU8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Rational> for usize

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> AddUsizeIncomplete<'_>

Performs the + operation.

impl<'b> Add<&i128> for &'b Rational

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> AddI128Incomplete<'b>

Performs the + operation.

impl Add<&i128> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> Rational

Performs the + operation.

impl<'b> Add<&i16> for &'b Rational

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> AddI16Incomplete<'b>

Performs the + operation.

impl Add<&i16> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Rational

Performs the + operation.

impl<'b> Add<&i32> for &'b Rational

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> AddI32Incomplete<'b>

Performs the + operation.

impl Add<&i32> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Rational

Performs the + operation.

impl<'b> Add<&i64> for &'b Rational

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> AddI64Incomplete<'b>

Performs the + operation.

impl Add<&i64> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Rational

Performs the + operation.

impl<'b> Add<&i8> for &'b Rational

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> AddI8Incomplete<'b>

Performs the + operation.

impl Add<&i8> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> Rational

Performs the + operation.

impl<'b> Add<&isize> for &'b Rational

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> AddIsizeIncomplete<'b>

Performs the + operation.

impl Add<&isize> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Rational

Performs the + operation.

impl<'b> Add<&u128> for &'b Rational

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> AddU128Incomplete<'b>

Performs the + operation.

impl Add<&u128> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> Rational

Performs the + operation.

impl<'b> Add<&u16> for &'b Rational

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> AddU16Incomplete<'b>

Performs the + operation.

impl Add<&u16> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Rational

Performs the + operation.

impl<'b> Add<&u32> for &'b Rational

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> AddU32Incomplete<'b>

Performs the + operation.

impl Add<&u32> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Rational

Performs the + operation.

impl<'b> Add<&u64> for &'b Rational

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> AddU64Incomplete<'b>

Performs the + operation.

impl Add<&u64> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Rational

Performs the + operation.

impl<'b> Add<&u8> for &'b Rational

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> AddU8Incomplete<'b>

Performs the + operation.

impl Add<&u8> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> Rational

Performs the + operation.

impl<'b> Add<&usize> for &'b Rational

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> AddUsizeIncomplete<'b>

Performs the + operation.

impl Add<&usize> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Rational

Performs the + operation.

impl Add<Complex> for &Rational

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: Complex) -> Complex

Performs the + operation.

impl Add<Complex> for Rational

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: Complex) -> Complex

Performs the + operation.

impl Add<Float> for &Rational

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Float> for Rational

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl Add<Integer> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddOwnedRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>

Performs the + operation.

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

type Output = AddOwnedRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>

Performs the + operation.

impl Add<Rational> for &Integer

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &i128

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &i16

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &i32

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &i64

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &i8

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &isize

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &u128

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &u16

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &u32

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &u64

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &u8

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &usize

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for Integer

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for i128

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for i16

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for i32

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for i64

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for i8

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for isize

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for u128

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for u16

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for u32

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for u64

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for u8

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for usize

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i128> for &'b Rational

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> AddI128Incomplete<'b>

Performs the + operation.

impl Add<i128> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i16> for &'b Rational

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> AddI16Incomplete<'b>

Performs the + operation.

impl Add<i16> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i32> for &'b Rational

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> AddI32Incomplete<'b>

Performs the + operation.

impl Add<i32> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i64> for &'b Rational

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> AddI64Incomplete<'b>

Performs the + operation.

impl Add<i64> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i8> for &'b Rational

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> AddI8Incomplete<'b>

Performs the + operation.

impl Add<i8> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<isize> for &'b Rational

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> AddIsizeIncomplete<'b>

Performs the + operation.

impl Add<isize> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u128> for &'b Rational

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> AddU128Incomplete<'b>

Performs the + operation.

impl Add<u128> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u16> for &'b Rational

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> AddU16Incomplete<'b>

Performs the + operation.

impl Add<u16> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u32> for &'b Rational

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> AddU32Incomplete<'b>

Performs the + operation.

impl Add<u32> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u64> for &'b Rational

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> AddU64Incomplete<'b>

Performs the + operation.

impl Add<u64> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u8> for &'b Rational

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> AddU8Incomplete<'b>

Performs the + operation.

impl Add<u8> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<usize> for &'b Rational

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> AddUsizeIncomplete<'b>

Performs the + operation.

impl Add<usize> for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add for &'a Rational

type Output = AddIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddIncomplete<'_>

Performs the + operation.

impl Add for Rational

type Output = Rational

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Integer> for Rational

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddAssign<&Rational> for Complex

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

Performs the += operation.

impl AddAssign<&Rational> for Float

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

Performs the += operation.

impl AddAssign<&Rational> for Rational

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

Performs the += operation.

impl AddAssign<&i128> for Rational

fn add_assign(&mut self, rhs: &i128)

Performs the += operation.

impl AddAssign<&i16> for Rational

fn add_assign(&mut self, rhs: &i16)

Performs the += operation.

impl AddAssign<&i32> for Rational

fn add_assign(&mut self, rhs: &i32)

Performs the += operation.

impl AddAssign<&i64> for Rational

fn add_assign(&mut self, rhs: &i64)

Performs the += operation.

impl AddAssign<&i8> for Rational

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl AddAssign<&isize> for Rational

fn add_assign(&mut self, rhs: &isize)

Performs the += operation.

impl AddAssign<&u128> for Rational

fn add_assign(&mut self, rhs: &u128)

Performs the += operation.

impl AddAssign<&u16> for Rational

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl AddAssign<&u32> for Rational

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl AddAssign<&u64> for Rational

fn add_assign(&mut self, rhs: &u64)

Performs the += operation.

impl AddAssign<&u8> for Rational

fn add_assign(&mut self, rhs: &u8)

Performs the += operation.

impl AddAssign<&usize> for Rational

fn add_assign(&mut self, rhs: &usize)

Performs the += operation.

impl AddAssign<Integer> for Rational

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssign<Rational> for Complex

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

impl AddAssign<Rational> for Float

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

impl AddAssign<i128> for Rational

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl AddAssign<i16> for Rational

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for Rational

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for Rational

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for Rational

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<isize> for Rational

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl AddAssign<u128> for Rational

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for Rational

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for Rational

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for Rational

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for Rational

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign<usize> for Rational

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl AddAssign for Rational

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

impl AddAssignRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round( &mut self, rhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddAssignRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round( &mut self, rhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering

Performs the addition.

impl AddFrom<&Integer> for Rational

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

impl AddFrom<&Rational> for Complex

fn add_from(&mut self, lhs: &Rational)

Peforms the addition.

impl AddFrom<&Rational> for Float

fn add_from(&mut self, lhs: &Rational)

Peforms the addition.

impl AddFrom<&Rational> for Rational

fn add_from(&mut self, lhs: &Rational)

Peforms the addition.

impl AddFrom<&i128> for Rational

fn add_from(&mut self, lhs: &i128)

Peforms the addition.

impl AddFrom<&i16> for Rational

fn add_from(&mut self, lhs: &i16)

Peforms the addition.

impl AddFrom<&i32> for Rational

fn add_from(&mut self, lhs: &i32)

Peforms the addition.

impl AddFrom<&i64> for Rational

fn add_from(&mut self, lhs: &i64)

Peforms the addition.

impl AddFrom<&i8> for Rational

fn add_from(&mut self, lhs: &i8)

Peforms the addition.

impl AddFrom<&isize> for Rational

fn add_from(&mut self, lhs: &isize)

Peforms the addition.

impl AddFrom<&u128> for Rational

fn add_from(&mut self, lhs: &u128)

Peforms the addition.

impl AddFrom<&u16> for Rational

fn add_from(&mut self, lhs: &u16)

Peforms the addition.

impl AddFrom<&u32> for Rational

fn add_from(&mut self, lhs: &u32)

Peforms the addition.

impl AddFrom<&u64> for Rational

fn add_from(&mut self, lhs: &u64)

Peforms the addition.

impl AddFrom<&u8> for Rational

fn add_from(&mut self, lhs: &u8)

Peforms the addition.

impl AddFrom<&usize> for Rational

fn add_from(&mut self, lhs: &usize)

Peforms the addition.

impl AddFrom<Integer> for Rational

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl AddFrom<Rational> for Complex

fn add_from(&mut self, lhs: Rational)

Peforms the addition.

impl AddFrom<Rational> for Float

fn add_from(&mut self, lhs: Rational)

Peforms the addition.

impl AddFrom<i128> for Rational

fn add_from(&mut self, lhs: i128)

Peforms the addition.

impl AddFrom<i16> for Rational

fn add_from(&mut self, lhs: i16)

Peforms the addition.

impl AddFrom<i32> for Rational

fn add_from(&mut self, lhs: i32)

Peforms the addition.

impl AddFrom<i64> for Rational

fn add_from(&mut self, lhs: i64)

Peforms the addition.

impl AddFrom<i8> for Rational

fn add_from(&mut self, lhs: i8)

Peforms the addition.

impl AddFrom<isize> for Rational

fn add_from(&mut self, lhs: isize)

Peforms the addition.

impl AddFrom<u128> for Rational

fn add_from(&mut self, lhs: u128)

Peforms the addition.

impl AddFrom<u16> for Rational

fn add_from(&mut self, lhs: u16)

Peforms the addition.

impl AddFrom<u32> for Rational

fn add_from(&mut self, lhs: u32)

Peforms the addition.

impl AddFrom<u64> for Rational

fn add_from(&mut self, lhs: u64)

Peforms the addition.

impl AddFrom<u8> for Rational

fn add_from(&mut self, lhs: u8)

Peforms the addition.

impl AddFrom<usize> for Rational

fn add_from(&mut self, lhs: usize)

Peforms the addition.

impl AddFrom for Rational

fn add_from(&mut self, lhs: Rational)

Peforms the addition.

impl AddFromRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round( &mut self, lhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddFromRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round( &mut self, lhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: Rational, round: Round) -> Ordering

Performs the addition.

impl<'a, Num, Den> Assign<&'a (Num, Den)> for Rational

where Integer: Assign<&'a Num> + Assign<&'a Den>,

fn assign(&mut self, src: &'a (Num, Den))

Peforms the assignement.

impl Assign<&MiniRational> for Rational

fn assign(&mut self, src: &MiniRational)

Peforms the assignement.

impl Assign<&Rational> for Rational

fn assign(&mut self, src: &Rational)

Peforms the assignement.

impl Assign<&SmallRational> for Rational

fn assign(&mut self, src: &SmallRational)

Peforms the assignement.

impl<Num, Den> Assign<(Num, Den)> for Rational

where Integer: Assign<Num> + Assign<Den>,

fn assign(&mut self, src: (Num, Den))

Peforms the assignement.

impl Assign<MiniRational> for Rational

fn assign(&mut self, src: MiniRational)

Peforms the assignement.

impl<Num> Assign<Num> for Rational

where Integer: Assign<Num>,

fn assign(&mut self, src: Num)

Peforms the assignement.

impl Assign<SmallRational> for Rational

fn assign(&mut self, src: SmallRational)

Peforms the assignement.

impl Assign for Rational

fn assign(&mut self, src: Rational)

Peforms the assignement.

impl AssignRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: &Rational, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Rational, round: Round) -> Ordering

Peforms the assignment.

impl Binary for Rational

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Cast<Rational> for &Float

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for &Integer

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for Float

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for Integer

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for bool

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for f32

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for f64

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for i128

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for i16

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for i32

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for i64

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for i8

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for isize

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for u128

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for u16

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for u32

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for u64

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for u8

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for usize

fn cast(self) -> Rational

Casts the value.

impl Cast<f32> for &Rational

fn cast(self) -> f32

Casts the value.

impl Cast<f32> for Rational

fn cast(self) -> f32

Casts the value.

impl Cast<f64> for &Rational

fn cast(self) -> f64

Casts the value.

impl Cast<f64> for Rational

fn cast(self) -> f64

Casts the value.

impl CheckedCast<Rational> for &Float

fn checked_cast(self) -> Option<Rational>

Casts the value.

impl CheckedCast<Rational> for Float

fn checked_cast(self) -> Option<Rational>

Casts the value.

impl CheckedCast<Rational> for f32

fn checked_cast(self) -> Option<Rational>

Casts the value.

impl CheckedCast<Rational> for f64

fn checked_cast(self) -> Option<Rational>

Casts the value.

impl Clone for Rational

fn clone(&self) -> Rational

Returns a copy of the value.

fn clone_from(&mut self, src: &Rational)

Performs copy-assignment from source.

impl Debug for Rational

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Default for Rational

fn default() -> Rational

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rational

fn deserialize<D: Deserializer<'de>>( deserializer: D ) -> Result<Rational, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Rational

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

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

type Output = DivFromRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivFromRationalIncomplete<'_>

Performs the / operation.

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

type Output = DivFromOwnedRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &Float) -> DivFromOwnedRationalIncomplete<'_>

Performs the / operation.

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

type Output = DivIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete<'_>

Performs the / operation.

impl Div<&Integer> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> Rational

Performs the / operation.

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

type Output = DivRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivRationalIncomplete<'_>

Performs the / operation.

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

type Output = DivRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivRationalIncomplete<'_>

Performs the / operation.

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

type Output = DivFromIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivFromIntegerIncomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for &i128

type Output = DivFromI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromI128Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &i16

type Output = DivFromI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromI16Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &i32

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromI32Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &i64

type Output = DivFromI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromI64Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &i8

type Output = DivFromI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromI8Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &isize

type Output = DivFromIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromIsizeIncomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &u128

type Output = DivFromU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromU128Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &u16

type Output = DivFromU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromU16Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &u32

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromU32Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &u64

type Output = DivFromU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromU64Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &u8

type Output = DivFromU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromU8Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Rational> for &usize

type Output = DivFromUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rational) -> DivFromUsizeIncomplete<'b>

Performs the / operation.

impl Div<&Rational> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> Complex

Performs the / operation.

impl Div<&Rational> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> Float

Performs the / operation.

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

type Output = DivFromOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromOwnedIntegerIncomplete<'_>

Performs the / operation.

impl Div<&Rational> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&'b Rational> for i128

type Output = DivFromI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromI128Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for i16

type Output = DivFromI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromI16Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for i32

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromI32Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for i64

type Output = DivFromI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromI64Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for i8

type Output = DivFromI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromI8Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for isize

type Output = DivFromIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromIsizeIncomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for u128

type Output = DivFromU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromU128Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for u16

type Output = DivFromU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromU16Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for u32

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromU32Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for u64

type Output = DivFromU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromU64Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for u8

type Output = DivFromU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromU8Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Rational> for usize

type Output = DivFromUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromUsizeIncomplete<'_>

Performs the / operation.

impl<'b> Div<&i128> for &'b Rational

type Output = DivI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> DivI128Incomplete<'b>

Performs the / operation.

impl Div<&i128> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> Rational

Performs the / operation.

impl<'b> Div<&i16> for &'b Rational

type Output = DivI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> DivI16Incomplete<'b>

Performs the / operation.

impl Div<&i16> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Rational

Performs the / operation.

impl<'b> Div<&i32> for &'b Rational

type Output = DivI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> DivI32Incomplete<'b>

Performs the / operation.

impl Div<&i32> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Rational

Performs the / operation.

impl<'b> Div<&i64> for &'b Rational

type Output = DivI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> DivI64Incomplete<'b>

Performs the / operation.

impl Div<&i64> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Rational

Performs the / operation.

impl<'b> Div<&i8> for &'b Rational

type Output = DivI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> DivI8Incomplete<'b>

Performs the / operation.

impl Div<&i8> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Rational

Performs the / operation.

impl<'b> Div<&isize> for &'b Rational

type Output = DivIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> DivIsizeIncomplete<'b>

Performs the / operation.

impl Div<&isize> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Rational

Performs the / operation.

impl<'b> Div<&u128> for &'b Rational

type Output = DivU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> DivU128Incomplete<'b>

Performs the / operation.

impl Div<&u128> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> Rational

Performs the / operation.

impl<'b> Div<&u16> for &'b Rational

type Output = DivU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> DivU16Incomplete<'b>

Performs the / operation.

impl Div<&u16> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Rational

Performs the / operation.

impl<'b> Div<&u32> for &'b Rational

type Output = DivU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> DivU32Incomplete<'b>

Performs the / operation.

impl Div<&u32> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Rational

Performs the / operation.

impl<'b> Div<&u64> for &'b Rational

type Output = DivU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> DivU64Incomplete<'b>

Performs the / operation.

impl Div<&u64> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Rational

Performs the / operation.

impl<'b> Div<&u8> for &'b Rational

type Output = DivU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> DivU8Incomplete<'b>

Performs the / operation.

impl Div<&u8> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> Rational

Performs the / operation.

impl<'b> Div<&usize> for &'b Rational

type Output = DivUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> DivUsizeIncomplete<'b>

Performs the / operation.

impl Div<&usize> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Rational

Performs the / operation.

impl Div<Float> for &Rational

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Float> for Rational

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a>

Performs the / operation.

impl Div<Integer> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivOwnedRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> DivOwnedRationalIncomplete<'a>

Performs the / operation.

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

type Output = DivOwnedRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> DivOwnedRationalIncomplete<'a>

Performs the / operation.

impl Div<Rational> for &Integer

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &i128

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &i16

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &i32

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &i64

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &i8

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &isize

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &u128

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &u16

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &u32

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &u64

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &u8

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &usize

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for Integer

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for i128

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for i16

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for i32

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for i64

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for i8

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for isize

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for u128

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for u16

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for u32

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for u64

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for u8

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for usize

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i128> for &'b Rational

type Output = DivI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> DivI128Incomplete<'b>

Performs the / operation.

impl Div<i128> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i16> for &'b Rational

type Output = DivI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> DivI16Incomplete<'b>

Performs the / operation.

impl Div<i16> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i32> for &'b Rational

type Output = DivI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DivI32Incomplete<'b>

Performs the / operation.

impl Div<i32> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i64> for &'b Rational

type Output = DivI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DivI64Incomplete<'b>

Performs the / operation.

impl Div<i64> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i8> for &'b Rational

type Output = DivI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> DivI8Incomplete<'b>

Performs the / operation.

impl Div<i8> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<isize> for &'b Rational

type Output = DivIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> DivIsizeIncomplete<'b>

Performs the / operation.

impl Div<isize> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u128> for &'b Rational

type Output = DivU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> DivU128Incomplete<'b>

Performs the / operation.

impl Div<u128> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u16> for &'b Rational

type Output = DivU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> DivU16Incomplete<'b>

Performs the / operation.

impl Div<u16> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u32> for &'b Rational

type Output = DivU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DivU32Incomplete<'b>

Performs the / operation.

impl Div<u32> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u64> for &'b Rational

type Output = DivU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DivU64Incomplete<'b>

Performs the / operation.

impl Div<u64> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u8> for &'b Rational

type Output = DivU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> DivU8Incomplete<'b>

Performs the / operation.

impl Div<u8> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<usize> for &'b Rational

type Output = DivUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> DivUsizeIncomplete<'b>

Performs the / operation.

impl Div<usize> for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div for &'a Rational

type Output = DivIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivIncomplete<'_>

Performs the / operation.

impl Div for Rational

type Output = Rational

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<&Integer> for Rational

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivAssign<&Rational> for Complex

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

Performs the /= operation.

impl DivAssign<&Rational> for Float

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

Performs the /= operation.

impl DivAssign<&Rational> for Rational

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

Performs the /= operation.

impl DivAssign<&i128> for Rational

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl DivAssign<&i16> for Rational

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl DivAssign<&i32> for Rational

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl DivAssign<&i64> for Rational

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl DivAssign<&i8> for Rational

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl DivAssign<&isize> for Rational

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl DivAssign<&u128> for Rational

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl DivAssign<&u16> for Rational

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl DivAssign<&u32> for Rational

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl DivAssign<&u64> for Rational

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl DivAssign<&u8> for Rational

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl DivAssign<&usize> for Rational

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl DivAssign<Integer> for Rational

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssign<Rational> for Complex

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl DivAssign<Rational> for Float

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl DivAssign<i128> for Rational

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl DivAssign<i16> for Rational

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for Rational

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for Rational

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for Rational

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<isize> for Rational

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl DivAssign<u128> for Rational

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for Rational

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for Rational

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for Rational

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for Rational

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign<usize> for Rational

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl DivAssign for Rational

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl DivAssignRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round( &mut self, rhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the division.

impl DivAssignRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round( &mut self, rhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the division.

impl DivAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering

Performs the division.

impl DivFrom<&Integer> for Rational

fn div_from(&mut self, lhs: &Integer)

Peforms the division.

impl DivFrom<&Rational> for Float

fn div_from(&mut self, lhs: &Rational)

Peforms the division.

impl DivFrom<&Rational> for Rational

fn div_from(&mut self, lhs: &Rational)

Peforms the division.

impl DivFrom<&i128> for Rational

fn div_from(&mut self, lhs: &i128)

Peforms the division.

impl DivFrom<&i16> for Rational

fn div_from(&mut self, lhs: &i16)

Peforms the division.

impl DivFrom<&i32> for Rational

fn div_from(&mut self, lhs: &i32)

Peforms the division.

impl DivFrom<&i64> for Rational

fn div_from(&mut self, lhs: &i64)

Peforms the division.

impl DivFrom<&i8> for Rational

fn div_from(&mut self, lhs: &i8)

Peforms the division.

impl DivFrom<&isize> for Rational

fn div_from(&mut self, lhs: &isize)

Peforms the division.

impl DivFrom<&u128> for Rational

fn div_from(&mut self, lhs: &u128)

Peforms the division.

impl DivFrom<&u16> for Rational

fn div_from(&mut self, lhs: &u16)

Peforms the division.

impl DivFrom<&u32> for Rational

fn div_from(&mut self, lhs: &u32)

Peforms the division.

impl DivFrom<&u64> for Rational

fn div_from(&mut self, lhs: &u64)

Peforms the division.

impl DivFrom<&u8> for Rational

fn div_from(&mut self, lhs: &u8)

Peforms the division.

impl DivFrom<&usize> for Rational

fn div_from(&mut self, lhs: &usize)

Peforms the division.

impl DivFrom<Integer> for Rational

fn div_from(&mut self, lhs: Integer)

Peforms the division.

impl DivFrom<Rational> for Float

fn div_from(&mut self, lhs: Rational)

Peforms the division.

impl DivFrom<i128> for Rational

fn div_from(&mut self, lhs: i128)

Peforms the division.

impl DivFrom<i16> for Rational

fn div_from(&mut self, lhs: i16)

Peforms the division.

impl DivFrom<i32> for Rational

fn div_from(&mut self, lhs: i32)

Peforms the division.

impl DivFrom<i64> for Rational

fn div_from(&mut self, lhs: i64)

Peforms the division.

impl DivFrom<i8> for Rational

fn div_from(&mut self, lhs: i8)

Peforms the division.

impl DivFrom<isize> for Rational

fn div_from(&mut self, lhs: isize)

Peforms the division.

impl DivFrom<u128> for Rational

fn div_from(&mut self, lhs: u128)

Peforms the division.

impl DivFrom<u16> for Rational

fn div_from(&mut self, lhs: u16)

Peforms the division.

impl DivFrom<u32> for Rational

fn div_from(&mut self, lhs: u32)

Peforms the division.

impl DivFrom<u64> for Rational

fn div_from(&mut self, lhs: u64)

Peforms the division.

impl DivFrom<u8> for Rational

fn div_from(&mut self, lhs: u8)

Peforms the division.

impl DivFrom<usize> for Rational

fn div_from(&mut self, lhs: usize)

Peforms the division.

impl DivFrom for Rational

fn div_from(&mut self, lhs: Rational)

Peforms the division.

impl DivFromRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering

Performs the division.

impl DivFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: Rational, round: Round) -> Ordering

Performs the division.

impl Drop for Rational

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, Num, Den> From<&'a (Num, Den)> for Rational

where Integer: From<&'a Num> + From<&'a Den>,

fn from(src: &'a (Num, Den)) -> Self

Converts to this type from the input type.

impl From<&MiniRational> for Rational

fn from(src: &MiniRational) -> Self

Converts to this type from the input type.

impl From<&Rational> for Rational

fn from(src: &Rational) -> Self

Converts to this type from the input type.

impl From<&SmallRational> for Rational

fn from(src: &SmallRational) -> Self

Converts to this type from the input type.

impl<Num, Den> From<(Num, Den)> for Rational

where Integer: From<Num> + From<Den>,

fn from((num, den): (Num, Den)) -> Self

Converts to this type from the input type.

impl From<MiniRational> for Rational

fn from(src: MiniRational) -> Self

Converts to this type from the input type.

impl<Num> From<Num> for Rational

where Integer: From<Num>,

fn from(src: Num) -> Self

Converts to this type from the input type.

impl From<SmallRational> for Rational

fn from(src: SmallRational) -> Self

Converts to this type from the input type.

impl FromPrimitive for Rational

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for Rational

type Err = ParseRationalError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Rational, ParseRationalError>

Parses a string s to return a value of this type.

impl Hash for Rational

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Inv for Rational

type Output = Rational

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl LowerHex for Rational

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

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

type Output = MulRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Complex) -> MulRationalIncomplete<'_>

Performs the * operation.

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

type Output = MulOwnedRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &Complex) -> MulOwnedRationalIncomplete<'_>

Performs the * operation.

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

type Output = MulRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRationalIncomplete<'_>

Performs the * operation.

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

type Output = MulOwnedRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &Float) -> MulOwnedRationalIncomplete<'_>

Performs the * operation.

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

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl Mul<&Integer> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> Rational

Performs the * operation.

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

type Output = MulRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete<'_>

Performs the * operation.

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

type Output = MulRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete<'_>

Performs the * operation.

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

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &i128

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &i16

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &i32

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &i64

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &i8

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &isize

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulIsizeIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &u128

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &u16

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &u32

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &u64

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &u8

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for &usize

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulUsizeIncomplete<'_>

Performs the * operation.

impl Mul<&Rational> for Complex

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> Complex

Performs the * operation.

impl Mul<&Rational> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> Float

Performs the * operation.

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

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl Mul<&Rational> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&'b Rational> for i128

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for i16

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for i32

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for i64

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for i8

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulI8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for isize

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulIsizeIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for u128

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for u16

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for u32

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for u64

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for u8

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulU8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Rational> for usize

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> MulUsizeIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&i128> for &'b Rational

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> MulI128Incomplete<'b>

Performs the * operation.

impl Mul<&i128> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> Rational

Performs the * operation.

impl<'b> Mul<&i16> for &'b Rational

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> MulI16Incomplete<'b>

Performs the * operation.

impl Mul<&i16> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Rational

Performs the * operation.

impl<'b> Mul<&i32> for &'b Rational

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> MulI32Incomplete<'b>

Performs the * operation.

impl Mul<&i32> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Rational

Performs the * operation.

impl<'b> Mul<&i64> for &'b Rational

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> MulI64Incomplete<'b>

Performs the * operation.

impl Mul<&i64> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Rational

Performs the * operation.

impl<'b> Mul<&i8> for &'b Rational

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> MulI8Incomplete<'b>

Performs the * operation.

impl Mul<&i8> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Rational

Performs the * operation.

impl<'b> Mul<&isize> for &'b Rational

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> MulIsizeIncomplete<'b>

Performs the * operation.

impl Mul<&isize> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Rational

Performs the * operation.

impl<'b> Mul<&u128> for &'b Rational

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> MulU128Incomplete<'b>

Performs the * operation.

impl Mul<&u128> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> Rational

Performs the * operation.

impl<'b> Mul<&u16> for &'b Rational

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> MulU16Incomplete<'b>

Performs the * operation.

impl Mul<&u16> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Rational

Performs the * operation.

impl<'b> Mul<&u32> for &'b Rational

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> MulU32Incomplete<'b>

Performs the * operation.

impl Mul<&u32> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Rational

Performs the * operation.

impl<'b> Mul<&u64> for &'b Rational

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> MulU64Incomplete<'b>

Performs the * operation.

impl Mul<&u64> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Rational

Performs the * operation.

impl<'b> Mul<&u8> for &'b Rational

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> MulU8Incomplete<'b>

Performs the * operation.

impl Mul<&u8> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> Rational

Performs the * operation.

impl<'b> Mul<&usize> for &'b Rational

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> MulUsizeIncomplete<'b>

Performs the * operation.

impl Mul<&usize> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Rational

Performs the * operation.

impl Mul<Complex> for &Rational

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Complex

Performs the * operation.

impl Mul<Complex> for Rational

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Complex

Performs the * operation.

impl Mul<Float> for &Rational

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Float> for Rational

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl Mul<Integer> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulOwnedRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>

Performs the * operation.

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

type Output = MulOwnedRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>

Performs the * operation.

impl Mul<Rational> for &Integer

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &i128

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &i16

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &i32

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &i64

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &i8

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &isize

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &u128

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &u16

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &u32

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &u64

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &u8

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &usize

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for Integer

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for i128

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for i16

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for i32

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for i64

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for i8

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for isize

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for u128

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for u16

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for u32

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for u64

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for u8

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for usize

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i128> for &'b Rational

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> MulI128Incomplete<'b>

Performs the * operation.

impl Mul<i128> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i16> for &'b Rational

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> MulI16Incomplete<'b>

Performs the * operation.

impl Mul<i16> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i32> for &'b Rational

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> MulI32Incomplete<'b>

Performs the * operation.

impl Mul<i32> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i64> for &'b Rational

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> MulI64Incomplete<'b>

Performs the * operation.

impl Mul<i64> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i8> for &'b Rational

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> MulI8Incomplete<'b>

Performs the * operation.

impl Mul<i8> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<isize> for &'b Rational

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> MulIsizeIncomplete<'b>

Performs the * operation.

impl Mul<isize> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u128> for &'b Rational

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> MulU128Incomplete<'b>

Performs the * operation.

impl Mul<u128> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u16> for &'b Rational

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> MulU16Incomplete<'b>

Performs the * operation.

impl Mul<u16> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u32> for &'b Rational

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> MulU32Incomplete<'b>

Performs the * operation.

impl Mul<u32> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u64> for &'b Rational

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> MulU64Incomplete<'b>

Performs the * operation.

impl Mul<u64> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u8> for &'b Rational

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> MulU8Incomplete<'b>

Performs the * operation.

impl Mul<u8> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<usize> for &'b Rational

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> MulUsizeIncomplete<'b>

Performs the * operation.

impl Mul<usize> for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul for &'a Rational

type Output = MulIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulIncomplete<'_>

Performs the * operation.

impl Mul for Rational

type Output = Rational

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAdd<&Rational, &Rational> for Rational

type Output = Rational

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: &Rational, b: &Rational) -> Rational

Performs the fused multiply-add operation (self * a) + b

impl MulAdd for Rational

type Output = Rational

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: Rational, b: Rational) -> Rational

Performs the fused multiply-add operation (self * a) + b

impl MulAddAssign<&Rational, &Rational> for Rational

fn mul_add_assign(&mut self, a: &Rational, b: &Rational)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl MulAddAssign for Rational

fn mul_add_assign(&mut self, a: Rational, b: Rational)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl MulAssign<&Integer> for Rational

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&Rational> for Complex

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

Performs the *= operation.

impl MulAssign<&Rational> for Float

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

Performs the *= operation.

impl MulAssign<&Rational> for Rational

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

Performs the *= operation.

impl MulAssign<&i128> for Rational

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl MulAssign<&i16> for Rational

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl MulAssign<&i32> for Rational

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl MulAssign<&i64> for Rational

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl MulAssign<&i8> for Rational

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl MulAssign<&isize> for Rational

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl MulAssign<&u128> for Rational

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl MulAssign<&u16> for Rational

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl MulAssign<&u32> for Rational

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl MulAssign<&u64> for Rational

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl MulAssign<&u8> for Rational

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl MulAssign<&usize> for Rational

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl MulAssign<Integer> for Rational

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssign<Rational> for Complex

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

impl MulAssign<Rational> for Float

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

impl MulAssign<i128> for Rational

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl MulAssign<i16> for Rational

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for Rational

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for Rational

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for Rational

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<isize> for Rational

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl MulAssign<u128> for Rational

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for Rational

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for Rational

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for Rational

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for Rational

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign<usize> for Rational

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl MulAssign for Rational

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

impl MulAssignRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round( &mut self, rhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulAssignRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round( &mut self, rhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering

Performs the multiplication.

impl MulFrom<&Integer> for Rational

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

impl MulFrom<&Rational> for Complex

fn mul_from(&mut self, lhs: &Rational)

Peforms the multiplication.

impl MulFrom<&Rational> for Float

fn mul_from(&mut self, lhs: &Rational)

Peforms the multiplication.

impl MulFrom<&Rational> for Rational

fn mul_from(&mut self, lhs: &Rational)

Peforms the multiplication.

impl MulFrom<&i128> for Rational

fn mul_from(&mut self, lhs: &i128)

Peforms the multiplication.

impl MulFrom<&i16> for Rational

fn mul_from(&mut self, lhs: &i16)

Peforms the multiplication.

impl MulFrom<&i32> for Rational

fn mul_from(&mut self, lhs: &i32)

Peforms the multiplication.

impl MulFrom<&i64> for Rational

fn mul_from(&mut self, lhs: &i64)

Peforms the multiplication.

impl MulFrom<&i8> for Rational

fn mul_from(&mut self, lhs: &i8)

Peforms the multiplication.

impl MulFrom<&isize> for Rational

fn mul_from(&mut self, lhs: &isize)

Peforms the multiplication.

impl MulFrom<&u128> for Rational

fn mul_from(&mut self, lhs: &u128)

Peforms the multiplication.

impl MulFrom<&u16> for Rational

fn mul_from(&mut self, lhs: &u16)

Peforms the multiplication.

impl MulFrom<&u32> for Rational

fn mul_from(&mut self, lhs: &u32)

Peforms the multiplication.

impl MulFrom<&u64> for Rational

fn mul_from(&mut self, lhs: &u64)

Peforms the multiplication.

impl MulFrom<&u8> for Rational

fn mul_from(&mut self, lhs: &u8)

Peforms the multiplication.

impl MulFrom<&usize> for Rational

fn mul_from(&mut self, lhs: &usize)

Peforms the multiplication.

impl MulFrom<Integer> for Rational

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl MulFrom<Rational> for Complex

fn mul_from(&mut self, lhs: Rational)

Peforms the multiplication.

impl MulFrom<Rational> for Float

fn mul_from(&mut self, lhs: Rational)

Peforms the multiplication.

impl MulFrom<i128> for Rational

fn mul_from(&mut self, lhs: i128)

Peforms the multiplication.

impl MulFrom<i16> for Rational

fn mul_from(&mut self, lhs: i16)

Peforms the multiplication.

impl MulFrom<i32> for Rational

fn mul_from(&mut self, lhs: i32)

Peforms the multiplication.

impl MulFrom<i64> for Rational

fn mul_from(&mut self, lhs: i64)

Peforms the multiplication.

impl MulFrom<i8> for Rational

fn mul_from(&mut self, lhs: i8)

Peforms the multiplication.

impl MulFrom<isize> for Rational

fn mul_from(&mut self, lhs: isize)

Peforms the multiplication.

impl MulFrom<u128> for Rational

fn mul_from(&mut self, lhs: u128)

Peforms the multiplication.

impl MulFrom<u16> for Rational

fn mul_from(&mut self, lhs: u16)

Peforms the multiplication.

impl MulFrom<u32> for Rational

fn mul_from(&mut self, lhs: u32)

Peforms the multiplication.

impl MulFrom<u64> for Rational

fn mul_from(&mut self, lhs: u64)

Peforms the multiplication.

impl MulFrom<u8> for Rational

fn mul_from(&mut self, lhs: u8)

Peforms the multiplication.

impl MulFrom<usize> for Rational

fn mul_from(&mut self, lhs: usize)

Peforms the multiplication.

impl MulFrom for Rational

fn mul_from(&mut self, lhs: Rational)

Peforms the multiplication.

impl MulFromRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round( &mut self, lhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulFromRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round( &mut self, lhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: Rational, round: Round) -> Ordering

Performs the multiplication.

impl<'a> Neg for &'a Rational

type Output = NegIncomplete<'a>

The resulting type after applying the - operator.

fn neg(self) -> NegIncomplete<'a>

Performs the unary - operation.

impl Neg for Rational

type Output = Rational

The resulting type after applying the - operator.

fn neg(self) -> Rational

Performs the unary - operation.

impl NegAssign for Rational

fn neg_assign(&mut self)

Peforms the negation.

impl Octal for Rational

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl One for Rational

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

impl Ord for Rational

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq<Complex> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<MiniRational> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for Complex

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for Float

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for Integer

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for MiniRational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for SmallRational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for f32

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for f64

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for i128

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for i16

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for i32

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for i64

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for i8

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for isize

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for u128

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for u16

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for u32

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for u64

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for u8

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for usize

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SmallRational> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i128> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i16> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i32> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i8> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<isize> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u128> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u16> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u32> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u64> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<usize> for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Rational

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Float> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Integer> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<MiniRational> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for Float

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for Integer

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for MiniRational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for SmallRational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for f32

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for f64

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for i128

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for i16

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for i32

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for i64

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for i8

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for isize

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for u128

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for u16

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for u32

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for u64

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for u8

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Rational> for usize

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<SmallRational> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<f32> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<f64> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<i128> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<i16> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<i32> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<i64> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<i8> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<isize> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<u128> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<u16> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<u32> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<u64> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<u8> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<usize> for Rational

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

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

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

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

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

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

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

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

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

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

impl PartialOrd for Rational

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

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

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

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

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

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

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

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

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

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

impl<'b> Pow<&i32> for &'b Rational

type Output = PowI32Incomplete<'b>

The result after applying the operator.

fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>

Returns self to the power rhs.

impl Pow<&i32> for Rational

type Output = Rational

The result after applying the operator.

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

Returns self to the power rhs.

impl<'b> Pow<&u32> for &'b Rational

type Output = PowU32Incomplete<'b>

The result after applying the operator.

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

Returns self to the power rhs.

impl Pow<&u32> for Rational

type Output = Rational

The result after applying the operator.

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

Returns self to the power rhs.

impl<'b> Pow<i32> for &'b Rational

type Output = PowI32Incomplete<'b>

The result after applying the operator.

fn pow(self, rhs: i32) -> PowI32Incomplete<'b>

Returns self to the power rhs.

impl Pow<i32> for Rational

type Output = Rational

The result after applying the operator.

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

Returns self to the power rhs.

impl<'b> Pow<u32> for &'b Rational

type Output = PowU32Incomplete<'b>

The result after applying the operator.

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

Returns self to the power rhs.

impl Pow<u32> for Rational

type Output = Rational

The result after applying the operator.

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

Returns self to the power rhs.

impl PowAssign<&i32> for Rational

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

Peforms the power operation.

impl PowAssign<&u32> for Rational

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

Peforms the power operation.

impl PowAssign<i32> for Rational

fn pow_assign(&mut self, rhs: i32)

Peforms the power operation.

impl PowAssign<u32> for Rational

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl<T> Product<T> for Rational

where Rational: MulAssign<T>,

fn product<I>(iter: I) -> Rational

where I: Iterator<Item = T>,

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

impl Serialize for Rational

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'b> Shl<&i32> for &'b Rational

type Output = ShlI32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b>

Performs the << operation.

impl Shl<&i32> for Rational

type Output = Rational

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'b> Shl<&isize> for &'b Rational

type Output = ShlIsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> ShlIsizeIncomplete<'b>

Performs the << operation.

impl Shl<&isize> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Rational

Performs the << operation.

impl<'b> Shl<&u32> for &'b Rational

type Output = ShlU32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b>

Performs the << operation.

impl Shl<&u32> for Rational

type Output = Rational

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'b> Shl<&usize> for &'b Rational

type Output = ShlUsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> ShlUsizeIncomplete<'b>

Performs the << operation.

impl Shl<&usize> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Rational

Performs the << operation.

impl<'b> Shl<i32> for &'b Rational

type Output = ShlI32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>

Performs the << operation.

impl Shl<i32> for Rational

type Output = Rational

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'b> Shl<isize> for &'b Rational

type Output = ShlIsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> ShlIsizeIncomplete<'b>

Performs the << operation.

impl Shl<isize> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Rational

Performs the << operation.

impl<'b> Shl<u32> for &'b Rational

type Output = ShlU32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>

Performs the << operation.

impl Shl<u32> for Rational

type Output = Rational

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'b> Shl<usize> for &'b Rational

type Output = ShlUsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> ShlUsizeIncomplete<'b>

Performs the << operation.

impl Shl<usize> for Rational

type Output = Rational

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Rational

Performs the << operation.

impl ShlAssign<&i32> for Rational

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

Performs the <<= operation.

impl ShlAssign<&isize> for Rational

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl ShlAssign<&u32> for Rational

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

Performs the <<= operation.

impl ShlAssign<&usize> for Rational

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl ShlAssign<i32> for Rational

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<isize> for Rational

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl ShlAssign<u32> for Rational

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl ShlAssign<usize> for Rational

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'b> Shr<&i32> for &'b Rational

type Output = ShrI32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b>

Performs the >> operation.

impl Shr<&i32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'b> Shr<&isize> for &'b Rational

type Output = ShrIsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> ShrIsizeIncomplete<'b>

Performs the >> operation.

impl Shr<&isize> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Rational

Performs the >> operation.

impl<'b> Shr<&u32> for &'b Rational

type Output = ShrU32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b>

Performs the >> operation.

impl Shr<&u32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'b> Shr<&usize> for &'b Rational

type Output = ShrUsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> ShrUsizeIncomplete<'b>

Performs the >> operation.

impl Shr<&usize> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Rational

Performs the >> operation.

impl<'b> Shr<i32> for &'b Rational

type Output = ShrI32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>

Performs the >> operation.

impl Shr<i32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'b> Shr<isize> for &'b Rational

type Output = ShrIsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> ShrIsizeIncomplete<'b>

Performs the >> operation.

impl Shr<isize> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Rational

Performs the >> operation.

impl<'b> Shr<u32> for &'b Rational

type Output = ShrU32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>

Performs the >> operation.

impl Shr<u32> for Rational

type Output = Rational

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'b> Shr<usize> for &'b Rational

type Output = ShrUsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> ShrUsizeIncomplete<'b>

Performs the >> operation.

impl Shr<usize> for Rational

type Output = Rational

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Rational

Performs the >> operation.

impl ShrAssign<&i32> for Rational

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

Performs the >>= operation.

impl ShrAssign<&isize> for Rational

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl ShrAssign<&u32> for Rational

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

Performs the >>= operation.

impl ShrAssign<&usize> for Rational

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl ShrAssign<i32> for Rational

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<isize> for Rational

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl ShrAssign<u32> for Rational

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl ShrAssign<usize> for Rational

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

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

type Output = SubFromRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubFromRationalIncomplete<'_>

Performs the - operation.

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

type Output = SubFromOwnedRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Complex) -> SubFromOwnedRationalIncomplete<'_>

Performs the - operation.

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

type Output = SubFromRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubFromRationalIncomplete<'_>

Performs the - operation.

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

type Output = SubFromOwnedRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Float) -> SubFromOwnedRationalIncomplete<'_>

Performs the - operation.

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

type Output = SubIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete<'_>

Performs the - operation.

impl Sub<&Integer> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> Rational

Performs the - operation.

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

type Output = SubRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete<'_>

Performs the - operation.

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

type Output = SubRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete<'_>

Performs the - operation.

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

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubFromIntegerIncomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &i128

type Output = SubFromI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromI128Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &i16

type Output = SubFromI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromI16Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &i32

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromI32Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &i64

type Output = SubFromI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromI64Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &i8

type Output = SubFromI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromI8Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &isize

type Output = SubFromIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromIsizeIncomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &u128

type Output = SubFromU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromU128Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &u16

type Output = SubFromU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromU16Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &u32

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromU32Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &u64

type Output = SubFromU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromU64Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &u8

type Output = SubFromU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromU8Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Rational> for &usize

type Output = SubFromUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Rational) -> SubFromUsizeIncomplete<'b>

Performs the - operation.

impl Sub<&Rational> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> Complex

Performs the - operation.

impl Sub<&Rational> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> Float

Performs the - operation.

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

type Output = SubFromOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromOwnedIntegerIncomplete<'_>

Performs the - operation.

impl Sub<&Rational> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<&'b Rational> for i128

type Output = SubFromI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromI128Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for i16

type Output = SubFromI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromI16Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for i32

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromI32Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for i64

type Output = SubFromI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromI64Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for i8

type Output = SubFromI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromI8Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for isize

type Output = SubFromIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromIsizeIncomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for u128

type Output = SubFromU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromU128Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for u16

type Output = SubFromU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromU16Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for u32

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromU32Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for u64

type Output = SubFromU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromU64Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for u8

type Output = SubFromU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromU8Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Rational> for usize

type Output = SubFromUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromUsizeIncomplete<'_>

Performs the - operation.

impl<'b> Sub<&i128> for &'b Rational

type Output = SubI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> SubI128Incomplete<'b>

Performs the - operation.

impl Sub<&i128> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Rational

Performs the - operation.

impl<'b> Sub<&i16> for &'b Rational

type Output = SubI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> SubI16Incomplete<'b>

Performs the - operation.

impl Sub<&i16> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Rational

Performs the - operation.

impl<'b> Sub<&i32> for &'b Rational

type Output = SubI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> SubI32Incomplete<'b>

Performs the - operation.

impl Sub<&i32> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Rational

Performs the - operation.

impl<'b> Sub<&i64> for &'b Rational

type Output = SubI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> SubI64Incomplete<'b>

Performs the - operation.

impl Sub<&i64> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Rational

Performs the - operation.

impl<'b> Sub<&i8> for &'b Rational

type Output = SubI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> SubI8Incomplete<'b>

Performs the - operation.

impl Sub<&i8> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Rational

Performs the - operation.

impl<'b> Sub<&isize> for &'b Rational

type Output = SubIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> SubIsizeIncomplete<'b>

Performs the - operation.

impl Sub<&isize> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Rational

Performs the - operation.

impl<'b> Sub<&u128> for &'b Rational

type Output = SubU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> SubU128Incomplete<'b>

Performs the - operation.

impl Sub<&u128> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Rational

Performs the - operation.

impl<'b> Sub<&u16> for &'b Rational

type Output = SubU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> SubU16Incomplete<'b>

Performs the - operation.

impl Sub<&u16> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Rational

Performs the - operation.

impl<'b> Sub<&u32> for &'b Rational

type Output = SubU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> SubU32Incomplete<'b>

Performs the - operation.

impl Sub<&u32> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Rational

Performs the - operation.

impl<'b> Sub<&u64> for &'b Rational

type Output = SubU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> SubU64Incomplete<'b>

Performs the - operation.

impl Sub<&u64> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Rational

Performs the - operation.

impl<'b> Sub<&u8> for &'b Rational

type Output = SubU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> SubU8Incomplete<'b>

Performs the - operation.

impl Sub<&u8> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Rational

Performs the - operation.

impl<'b> Sub<&usize> for &'b Rational

type Output = SubUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> SubUsizeIncomplete<'b>

Performs the - operation.

impl Sub<&usize> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Rational

Performs the - operation.

impl Sub<Complex> for &Rational

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

impl Sub<Complex> for Rational

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

impl Sub<Float> for &Rational

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Float> for Rational

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubOwnedIntegerIncomplete<'a>

Performs the - operation.

impl Sub<Integer> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubOwnedRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> SubOwnedRationalIncomplete<'a>

Performs the - operation.

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

type Output = SubOwnedRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> SubOwnedRationalIncomplete<'a>

Performs the - operation.

impl Sub<Rational> for &Integer

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &i128

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &i16

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &i32

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &i64

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &i8

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &isize

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &u128

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &u16

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &u32

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &u64

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &u8

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for &usize

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for Integer

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for i128

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for i16

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for i32

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for i64

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for i8

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for isize

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for u128

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for u16

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for u32

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for u64

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for u8

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Rational> for usize

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<i128> for &'b Rational

type Output = SubI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> SubI128Incomplete<'b>

Performs the - operation.

impl Sub<i128> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<i16> for &'b Rational

type Output = SubI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> SubI16Incomplete<'b>

Performs the - operation.

impl Sub<i16> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<i32> for &'b Rational

type Output = SubI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> SubI32Incomplete<'b>

Performs the - operation.

impl Sub<i32> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<i64> for &'b Rational

type Output = SubI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> SubI64Incomplete<'b>

Performs the - operation.

impl Sub<i64> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<i8> for &'b Rational

type Output = SubI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> SubI8Incomplete<'b>

Performs the - operation.

impl Sub<i8> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<isize> for &'b Rational

type Output = SubIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> SubIsizeIncomplete<'b>

Performs the - operation.

impl Sub<isize> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<u128> for &'b Rational

type Output = SubU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> SubU128Incomplete<'b>

Performs the - operation.

impl Sub<u128> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<u16> for &'b Rational

type Output = SubU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> SubU16Incomplete<'b>

Performs the - operation.

impl Sub<u16> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<u32> for &'b Rational

type Output = SubU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> SubU32Incomplete<'b>

Performs the - operation.

impl Sub<u32> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<u64> for &'b Rational

type Output = SubU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> SubU64Incomplete<'b>

Performs the - operation.

impl Sub<u64> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<u8> for &'b Rational

type Output = SubU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> SubU8Incomplete<'b>

Performs the - operation.

impl Sub<u8> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b> Sub<usize> for &'b Rational

type Output = SubUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> SubUsizeIncomplete<'b>

Performs the - operation.

impl Sub<usize> for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub for &'a Rational

type Output = SubIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubIncomplete<'_>

Performs the - operation.

impl Sub for Rational

type Output = Rational

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&Integer> for Rational

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&Rational> for Complex

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

Performs the -= operation.

impl SubAssign<&Rational> for Float

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

Performs the -= operation.

impl SubAssign<&Rational> for Rational

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

Performs the -= operation.

impl SubAssign<&i128> for Rational

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl SubAssign<&i16> for Rational

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl SubAssign<&i32> for Rational

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl SubAssign<&i64> for Rational

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl SubAssign<&i8> for Rational

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl SubAssign<&isize> for Rational

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl SubAssign<&u128> for Rational

fn sub_assign(&mut self, rhs: &u128)

Performs the -= operation.

impl SubAssign<&u16> for Rational

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl SubAssign<&u32> for Rational

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl SubAssign<&u64> for Rational

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl SubAssign<&u8> for Rational

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl SubAssign<&usize> for Rational

fn sub_assign(&mut self, rhs: &usize)

Performs the -= operation.

impl SubAssign<Integer> for Rational

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssign<Rational> for Complex

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

impl SubAssign<Rational> for Float

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

impl SubAssign<i128> for Rational

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl SubAssign<i16> for Rational

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for Rational

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for Rational

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for Rational

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<isize> for Rational

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl SubAssign<u128> for Rational

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for Rational

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for Rational

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for Rational

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for Rational

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign<usize> for Rational

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl SubAssign for Rational

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

impl SubAssignRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round( &mut self, rhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubAssignRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &Rational, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round( &mut self, rhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubAssignRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: Rational, round: Round) -> Ordering

Performs the subtraction.

impl SubFrom<&Integer> for Rational

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

impl SubFrom<&Rational> for Complex

fn sub_from(&mut self, lhs: &Rational)

Peforms the subtraction.

impl SubFrom<&Rational> for Float

fn sub_from(&mut self, lhs: &Rational)

Peforms the subtraction.

impl SubFrom<&Rational> for Rational

fn sub_from(&mut self, lhs: &Rational)

Peforms the subtraction.

impl SubFrom<&i128> for Rational

fn sub_from(&mut self, lhs: &i128)

Peforms the subtraction.

impl SubFrom<&i16> for Rational

fn sub_from(&mut self, lhs: &i16)

Peforms the subtraction.

impl SubFrom<&i32> for Rational

fn sub_from(&mut self, lhs: &i32)

Peforms the subtraction.

impl SubFrom<&i64> for Rational

fn sub_from(&mut self, lhs: &i64)

Peforms the subtraction.

impl SubFrom<&i8> for Rational

fn sub_from(&mut self, lhs: &i8)

Peforms the subtraction.

impl SubFrom<&isize> for Rational

fn sub_from(&mut self, lhs: &isize)

Peforms the subtraction.

impl SubFrom<&u128> for Rational

fn sub_from(&mut self, lhs: &u128)

Peforms the subtraction.

impl SubFrom<&u16> for Rational

fn sub_from(&mut self, lhs: &u16)

Peforms the subtraction.

impl SubFrom<&u32> for Rational

fn sub_from(&mut self, lhs: &u32)

Peforms the subtraction.

impl SubFrom<&u64> for Rational

fn sub_from(&mut self, lhs: &u64)

Peforms the subtraction.

impl SubFrom<&u8> for Rational

fn sub_from(&mut self, lhs: &u8)

Peforms the subtraction.

impl SubFrom<&usize> for Rational

fn sub_from(&mut self, lhs: &usize)

Peforms the subtraction.

impl SubFrom<Integer> for Rational

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl SubFrom<Rational> for Complex

fn sub_from(&mut self, lhs: Rational)

Peforms the subtraction.

impl SubFrom<Rational> for Float

fn sub_from(&mut self, lhs: Rational)

Peforms the subtraction.

impl SubFrom<i128> for Rational

fn sub_from(&mut self, lhs: i128)

Peforms the subtraction.

impl SubFrom<i16> for Rational

fn sub_from(&mut self, lhs: i16)

Peforms the subtraction.

impl SubFrom<i32> for Rational

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

impl SubFrom<i64> for Rational

fn sub_from(&mut self, lhs: i64)

Peforms the subtraction.

impl SubFrom<i8> for Rational

fn sub_from(&mut self, lhs: i8)

Peforms the subtraction.

impl SubFrom<isize> for Rational

fn sub_from(&mut self, lhs: isize)

Peforms the subtraction.

impl SubFrom<u128> for Rational

fn sub_from(&mut self, lhs: u128)

Peforms the subtraction.

impl SubFrom<u16> for Rational

fn sub_from(&mut self, lhs: u16)

Peforms the subtraction.

impl SubFrom<u32> for Rational

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

impl SubFrom<u64> for Rational

fn sub_from(&mut self, lhs: u64)

Peforms the subtraction.

impl SubFrom<u8> for Rational

fn sub_from(&mut self, lhs: u8)

Peforms the subtraction.

impl SubFrom<usize> for Rational

fn sub_from(&mut self, lhs: usize)

Peforms the subtraction.

impl SubFrom for Rational

fn sub_from(&mut self, lhs: Rational)

Peforms the subtraction.

impl SubFromRound<&Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round( &mut self, lhs: &Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubFromRound<&Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &Rational, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round( &mut self, lhs: Rational, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubFromRound<Rational> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: Rational, round: Round) -> Ordering

Performs the subtraction.

impl<T> Sum<T> for Rational

where Rational: AddAssign<T>,

fn sum<I>(iter: I) -> Rational

where I: Iterator<Item = T>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl ToPrimitive for Rational

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl TryFrom<&Float> for Rational

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(value: &Float) -> Result<Self, TryFromFloatError>

Performs the conversion.

impl TryFrom<Float> for Rational

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(value: Float) -> Result<Self, TryFromFloatError>

Performs the conversion.

impl TryFrom<f32> for Rational

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Self, TryFromFloatError>

Performs the conversion.

impl TryFrom<f64> for Rational

type Error = TryFromFloatError

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, TryFromFloatError>

Performs the conversion.

impl UnwrappedCast<Rational> for &Float

fn unwrapped_cast(self) -> Rational

Casts the value.

impl UnwrappedCast<Rational> for Float

fn unwrapped_cast(self) -> Rational

Casts the value.

impl UnwrappedCast<Rational> for f32

fn unwrapped_cast(self) -> Rational

Casts the value.

impl UnwrappedCast<Rational> for f64

fn unwrapped_cast(self) -> Rational

Casts the value.

impl UpperHex for Rational

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Zero for Rational

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Eq for Rational

impl Send for Rational

impl Sync for Rational