# Struct rug::Rational
[−]
[src]

pub struct Rational { /* fields omitted */ }

An arbitrary-precision rational number.

A rational number is made up of a numerator
`Integer`

and denominator
`Integer`

. After rational number functions,
the number is always in canonical form, that is, the denominator
is always greater than zero, and there are no common factors. Zero
is stored as 0/1.

# Examples

use rug::Rational; let r = Rational::from((-12, 15)); let recip = Rational::from(r.recip_ref()); assert_eq!(recip, (-5, 4)); assert_eq!(recip.to_f32(), -1.25); // The numerator and denominator are stored in canonical form. let (num, den) = r.into_numer_denom(); assert_eq!(num, -4); assert_eq!(den, 5);

The `Rational`

type supports various functions. Most methods have
three versions: one that consumes the operand, one that mutates
the operand, and one that borrows the operand.

use rug::Rational; // 1. consume the operand let a = Rational::from((-15, 2)); let abs_a = a.abs(); assert_eq!(abs_a, (15, 2)); // 2. mutate the operand let mut b = Rational::from((-17, 2)); b.abs_mut(); assert_eq!(b, (17, 2)); // 3. borrow the operand let c = Rational::from((-19, 2)); let r = c.abs_ref(); let abs_c = Rational::from(r); assert_eq!(abs_c, (19, 2)); // c was not consumed assert_eq!(c, (-19, 2));

## Methods

`impl Rational`

[src]

`fn new() -> Rational`

[src]

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

# Examples

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

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

[src]

Creates a `Rational`

from an `f32`

if it is finite, losing no
precision.

# Examples

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

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

[src]

Creates a `Rational`

from an `f64`

if it is finite, losing no
precision.

# Examples

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

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

[src]

Parses a `Rational`

number.

# Examples

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

# Panics

Panics if `radix`

is less than 2 or greater than 36.

`fn valid_str_radix(`

src: &str,

radix: i32

) -> Result<ValidRational, ParseRationalError>

[src]

src: &str,

radix: i32

) -> Result<ValidRational, ParseRationalError>

Checks if a `Rational`

number can be parsed.

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

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

The string must contain a numerator, and may contain a
denominator; the numerator and denominator are separated with
a `'/'`

. The numerator can start with an optional minus or
plus sign.

Whitespace is not allowed anywhere in the string, including in
the beginning and end and around the `'/'`

.

# Examples

use rug::Rational; let valid1 = Rational::valid_str_radix("12/23", 4); let r1 = Rational::from(valid1.unwrap()); assert_eq!(r1, (2 + 4 * 1, 3 + 4 * 2)); let valid2 = Rational::valid_str_radix("12/yz", 36); let r2 = Rational::from(valid2.unwrap()); assert_eq!(r2, (2 + 36 * 1, 35 + 36 * 34)); let invalid = Rational::valid_str_radix("12 / 23", 4); let invalid_f = Rational::from_str_radix("12 / 23", 4); assert_eq!(invalid.unwrap_err(), invalid_f.unwrap_err());

# Panics

Panics if `radix`

is less than 2 or greater than 36.

`fn to_integer(&self) -> Integer`

[src]

Converts to an `Integer`

, rounding
towards zero.

# Examples

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

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

[src]

Converts to an `Integer`

inside `i`

,
rounding towards zero.

# Examples

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

`fn to_f32(&self) -> f32`

[src]

Converts to an `f32`

, rounding towards zero.

# Examples

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

`fn to_f64(&self) -> f64`

[src]

Converts to an `f64`

, rounding towards zero.

# Examples

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

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

[src]

Returns a string representation for the specified `radix`

.

# Examples

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

# Panics

Panics if `radix`

is less than 2 or greater than 36.

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

[src]

Assigns from an `f32`

if it is finite, losing no precision.

# Examples

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

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

[src]

Assigns from an `f64`

if it is finite, losing no precision.

# Examples

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

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

[src]

Parses a `Rational`

number from a string.

# Examples

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

`fn assign_str_radix(`

&mut self,

src: &str,

radix: i32

) -> Result<(), ParseRationalError>

[src]

&mut self,

src: &str,

radix: i32

) -> Result<(), ParseRationalError>

Parses a `Rational`

number from a string with the specified
radix.

# Examples

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

# Panics

Panics if `radix`

is less than 2 or greater than 36.

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

[src]

Borrows the numerator as an `Integer`

.

# Examples

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

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

[src]

Borrows the denominator as an
`Integer`

.

# Examples

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

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

[src]

Borrows the numerator and denominator as
`Integer`

values.

# Examples

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

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

[src]

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

# Examples

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

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

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

# Panics

Panics if the denominator is zero when the borrow ends.

`unsafe fn as_mut_numer_denom_no_canonicalization(`

&mut self

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

[src]

&mut self

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

Borrows the numerator and denominator mutably without canonicalizing aftwerwards.

# Safety

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

structures keep their numerators and
denominators canonicalized.

# Examples

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

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

[src]

Converts into numerator and denominator integers.

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

# Examples

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

`fn as_neg(&self) -> BorrowRational`

[src]

Borrows a negated copy of the `Rational`

number.

The returned object implements `Deref`

with a `Rational`

target. This method performs a shallow copy and negates it,
and negation does not change the allocated data.

# Examples

use rug::Rational; let r = Rational::from((7, 11)); let neg_r = r.as_neg(); assert_eq!(*neg_r, (-7, 11)); // methods taking &self can be used on the returned object let reneg_r = neg_r.as_neg(); assert_eq!(*reneg_r, (7, 11)); assert_eq!(*reneg_r, r);

`fn as_abs(&self) -> BorrowRational`

[src]

Borrows an absolute copy of the `Rational`

number.

The returned object implements `Deref`

with a `Rational`

target. This method performs a shallow copy and possibly
negates it, and negation does not change the allocated data.

# Examples

use rug::Rational; let r = Rational::from((-7, 11)); let abs_r = r.as_abs(); assert_eq!(*abs_r, (7, 11)); // methods taking &self can be used on the returned object let reabs_r = abs_r.as_abs(); assert_eq!(*reabs_r, (7, 11)); assert_eq!(*reabs_r, *abs_r);

`fn as_recip(&self) -> BorrowRational`

[src]

Borrows a reciprocal copy of the `Rational`

number.

The returned object implements `Deref`

with a `Rational`

target. This method performs some shallow copying, swapping
numerator and denominator and making sure the sign is in the
numerator.

# Examples

use rug::Rational; let r = Rational::from((-7, 11)); let recip_r = r.as_recip(); assert_eq!(*recip_r, (-11, 7)); // methods taking &self can be used on the returned object let rerecip_r = recip_r.as_recip(); assert_eq!(*rerecip_r, (-7, 11)); assert_eq!(*rerecip_r, r);

# Panics

Panics if the value is zero.

`fn cmp0(&self) -> Ordering`

[src]

Returns the same result as `self.cmp(&0)`

, but is faster.

# Examples

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

`fn abs(self) -> Self`

[src]

Computes the absolute value.

# Examples

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

`fn abs_mut(&mut self)`

[src]

Computes the absolute value.

# Examples

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

`fn abs_ref(&self) -> AbsRef`

[src]

Computes the absolute value.

# Examples

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

`fn clamp<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Rational where`

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,

[src]

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,

Clamps the value within the specified bounds.

# Examples

use rug::Rational; let min = (-3, 2); let max = (3, 2); let too_small = Rational::from((-5, 2)); let clamped1 = too_small.clamp(&min, &max); assert_eq!(clamped1, (-3, 2)); let in_range = Rational::from((1, 2)); let clamped2 = in_range.clamp(&min, &max); assert_eq!(clamped2, (1, 2));

# Panics

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

`fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where`

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,

[src]

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b Max>,

Clamps the value within the specified bounds.

# Examples

use rug::Rational; let min = (-3, 2); let max = (3, 2); let mut too_small = Rational::from((-5, 2)); too_small.clamp_mut(&min, &max); assert_eq!(too_small, (-3, 2)); let mut in_range = Rational::from((1, 2)); in_range.clamp_mut(&min, &max); assert_eq!(in_range, (1, 2));

# Panics

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

`fn clamp_ref<'a, Min, Max>(`

&'a self,

min: &'a Min,

max: &'a Max

) -> ClampRef<'a, Min, Max> where

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,

[src]

&'a self,

min: &'a Min,

max: &'a Max

) -> ClampRef<'a, Min, Max> where

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,

Clamps the value within the specified bounds.

# Examples

use rug::Rational; let min = (-3, 2); let max = (3, 2); let too_small = Rational::from((-5, 2)); let r1 = too_small.clamp_ref(&min, &max); let clamped1 = Rational::from(r1); assert_eq!(clamped1, (-3, 2)); let in_range = Rational::from((1, 2)); let r2 = in_range.clamp_ref(&min, &max); let clamped2 = Rational::from(r2); assert_eq!(clamped2, (1, 2));

# Panics

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

`fn recip(self) -> Self`

[src]

Computes the reciprocal.

# Examples

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

# Panics

Panics if the value is zero.

`fn recip_mut(&mut self)`

[src]

Computes the reciprocal.

# Examples

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

# Panics

Panics if the value is zero.

`fn recip_ref(&self) -> RecipRef`

[src]

Computes the reciprocal.

# Examples

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

`fn trunc(self) -> Integer`

[src]

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

.

# Examples

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

`fn trunc_mut(&mut self)`

[src]

Rounds the number towards zero.

# Examples

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

`fn trunc_ref(&self) -> TruncRef`

[src]

Rounds the number towards zero.

# Examples

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

`fn fract(self) -> Rational`

[src]

: renamed to `rem_trunc`

Computes the fractional part of the number.

`fn fract_mut(&mut self)`

[src]

: renamed to `rem_trunc_mut`

Computes the fractional part of the number.

`fn fract_ref(&self) -> RemTruncRef`

[src]

: renamed to `rem_trunc_ref`

Computes the fractional part of the number.

`fn rem_trunc(self) -> Self`

[src]

Computes the fractional part of the number.

# Examples

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

`fn rem_trunc_mut(&mut self)`

[src]

Computes the fractional part of the number.

# Examples

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

`fn rem_trunc_ref(&self) -> RemTruncRef`

[src]

Computes the fractional part of the number.

# Examples

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

`fn fract_trunc(self, trunc: Integer) -> (Rational, Integer)`

[src]

Computes the fractional and truncated parts of the number.

The initial value of `trunc`

is ignored.

# Examples

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

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

[src]

Computes the fractional and truncated parts of the number.

The initial value of `trunc`

is ignored.

# Examples

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

`fn fract_trunc_ref(&self) -> FractTruncRef`

[src]

Computes the fractional and truncated parts of the number.

# Examples

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

`fn ceil(self) -> Integer`

[src]

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

.

# Examples

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

`fn ceil_mut(&mut self)`

[src]

Rounds the number upwards (towards plus infinity).

# Examples

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

`fn ceil_ref(&self) -> CeilRef`

[src]

Rounds the number upwards (towards plus infinity).

# Examples

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

`fn rem_ceil(self) -> Self`

[src]

Computes the non-positive remainder after rounding up.

# Examples

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

`fn rem_ceil_mut(&mut self)`

[src]

Computes the non-positive remainder after rounding up.

# Examples

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

`fn rem_ceil_ref(&self) -> RemCeilRef`

[src]

Computes the non-positive remainder after rounding up.

# Examples

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

`fn fract_ceil(self, ceil: Integer) -> (Rational, Integer)`

[src]

Computes the fractional and ceil parts of the number.

The fractional part cannot greater than zero. The initial
value of `ceil`

is ignored.

# Examples

use rug::{Integer, Rational}; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let (fract, ceil) = r.fract_ceil(Integer::new()); assert_eq!(fract, (-2, 17)); assert_eq!(ceil, 6);

`fn fract_ceil_mut(&mut self, ceil: &mut Integer)`

[src]

Computes the fractional and ceil parts of the number.

The fractional part cannot be greater than zero. The initial
value of `ceil`

is ignored.

# Examples

use rug::{Integer, Rational}; // 100/17 = 6 - 2/17 let mut r = Rational::from((100, 17)); let mut ceil = Integer::new(); r.fract_ceil_mut(&mut ceil); assert_eq!(r, (-2, 17)); assert_eq!(ceil, 6);

`fn fract_ceil_ref(&self) -> FractCeilRef`

[src]

Computes the fractional and ceil parts of the number.

The fractional part cannot be greater than zero.

# Examples

use rug::{Assign, Integer, Rational}; // 100/17 = 6 - 2/17 let r = Rational::from((100, 17)); let r_ref = r.fract_ceil_ref(); let (mut fract, mut ceil) = (Rational::new(), Integer::new()); (&mut fract, &mut ceil).assign(r_ref); assert_eq!(fract, (-2, 17)); assert_eq!(ceil, 6);

`fn floor(self) -> Integer`

[src]

Rounds the number downwards (towards minus infinity) and
returns it as an `Integer`

.

# Examples

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

`fn floor_mut(&mut self)`

[src]

Rounds the number downwards (towards minus infinity).

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

`fn floor_ref(&self) -> FloorRef`

[src]

Rounds the number downwards (towards minus infinity).

# Examples

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

`fn rem_floor(self) -> Self`

[src]

Computes the non-negative remainder after rounding down.

# Examples

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

`fn rem_floor_mut(&mut self)`

[src]

Computes the non-negative remainder after rounding down.

# Examples

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

`fn rem_floor_ref(&self) -> RemFloorRef`

[src]

Computes the non-negative remainder after rounding down.

# Examples

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

`fn fract_floor(self, floor: Integer) -> (Rational, Integer)`

[src]

Computes the fractional and floor parts of the number.

The fractional part cannot be negative. The initial value of
`floor`

is ignored.

# Examples

use rug::{Integer, Rational}; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let (fract, floor) = r.fract_floor(Integer::new()); assert_eq!(fract, (2, 17)); assert_eq!(floor, -6);

`fn fract_floor_mut(&mut self, floor: &mut Integer)`

[src]

Computes the fractional and floor parts of the number.

The fractional part cannot be negative. The initial value of
`floor`

is ignored.

# Examples

use rug::{Integer, Rational}; // -100/17 = -6 + 2/17 let mut r = Rational::from((-100, 17)); let mut floor = Integer::new(); r.fract_floor_mut(&mut floor); assert_eq!(r, (2, 17)); assert_eq!(floor, -6);

`fn fract_floor_ref(&self) -> FractFloorRef`

[src]

Computes the fractional and floor parts of the number.

The fractional part cannot be negative.

# Examples

use rug::{Assign, Integer, Rational}; // -100/17 = -6 + 2/17 let r = Rational::from((-100, 17)); let r_ref = r.fract_floor_ref(); let (mut fract, mut floor) = (Rational::new(), Integer::new()); (&mut fract, &mut floor).assign(r_ref); assert_eq!(fract, (2, 17)); assert_eq!(floor, -6);

`fn round(self) -> Integer`

[src]

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

.

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

# Examples

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

`fn round_mut(&mut self)`

[src]

Rounds the number to the nearest integer.

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

# Examples

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

`fn round_ref(&self) -> RoundRef`

[src]

Rounds the number to the nearest integer.

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

# Examples

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

`fn rem_round(self) -> Self`

[src]

Computes the remainder after rounding to the nearest integer.

# Examples

use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let rem1 = r1.rem_round(); assert_eq!(rem1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let rem2 = r2.rem_round(); assert_eq!(rem2, (-3, 10));

`fn rem_round_mut(&mut self)`

[src]

Computes the remainder after rounding to the nearest integer.

# Examples

use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let mut r1 = Rational::from((-35, 10)); r1.rem_round_mut(); assert_eq!(r1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let mut r2 = Rational::from((37, 10)); r2.rem_round_mut(); assert_eq!(r2, (-3, 10));

`fn rem_round_ref(&self) -> RemRoundRef`

[src]

Computes the remainder after rounding to the nearest integer.

# Examples

use rug::Rational; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let r_ref1 = r1.rem_round_ref(); let rem1 = Rational::from(r_ref1); assert_eq!(rem1, (1, 2)); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let r_ref2 = r2.rem_round_ref(); let rem2 = Rational::from(r_ref2); assert_eq!(rem2, (-3, 10));

`fn fract_round(self, round: Integer) -> (Rational, Integer)`

[src]

Computes the fractional and rounded parts of the number.

The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.

# Examples

use rug::{Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let (fract1, round1) = r1.fract_round(Integer::new()); assert_eq!(fract1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let (fract2, round2) = r2.fract_round(Integer::new()); assert_eq!(fract2, (-3, 10)); assert_eq!(round2, 4);

`fn fract_round_mut(&mut self, round: &mut Integer)`

[src]

Computes the fractional and round parts of the number.

The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.

# Examples

use rug::{Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let mut r1 = Rational::from((-35, 10)); let mut round1 = Integer::new(); r1.fract_round_mut(&mut round1); assert_eq!(r1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let mut r2 = Rational::from((37, 10)); let mut round2 = Integer::new(); r2.fract_round_mut(&mut round2); assert_eq!(r2, (-3, 10)); assert_eq!(round2, 4);

`fn fract_round_ref(&self) -> FractRoundRef`

[src]

Computes the fractional and round parts of the number.

The fractional part is positive when the number is rounded down and negative when the number is rounded up. When the number lies exactly between two integers, it is rounded away from zero.

# Examples

use rug::{Assign, Integer, Rational}; // -3.5 = -4 + 0.5 = -4 + 1/2 let r1 = Rational::from((-35, 10)); let r_ref1 = r1.fract_round_ref(); let (mut fract1, mut round1) = (Rational::new(), Integer::new()); (&mut fract1, &mut round1).assign(r_ref1); assert_eq!(fract1, (1, 2)); assert_eq!(round1, -4); // 3.7 = 4 - 0.3 = 4 - 3/10 let r2 = Rational::from((37, 10)); let r_ref2 = r2.fract_round_ref(); let (mut fract2, mut round2) = (Rational::new(), Integer::new()); (&mut fract2, &mut round2).assign(r_ref2); assert_eq!(fract2, (-3, 10)); assert_eq!(round2, 4);

## Trait Implementations

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

[src]

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

[src]

`impl<'a, Min, Max> From<ClampRef<'a, Min, Max>> for Rational where`

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,

Min: 'a,

Max: 'a,

[src]

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,

Min: 'a,

Max: 'a,

`impl<'a, Min, Max> Assign<ClampRef<'a, Min, Max>> for Rational where`

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,

Min: 'a,

Max: 'a,

[src]

Rational: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,

Min: 'a,

Max: 'a,

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

Peforms the assignement. Read more

`impl Neg for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator.

`fn neg(self) -> Rational`

[src]

Performs the unary `-`

operation.

`impl NegAssign for Rational`

[src]

`fn neg_assign(&mut self)`

[src]

Peforms the negation. Read more

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

[src]

`type Output = NegRef<'a>`

The resulting type after applying the `-`

operator.

`fn neg(self) -> NegRef<'a>`

[src]

Performs the unary `-`

operation.

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

[src]

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

[src]

`impl Add<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `+`

operator.

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

[src]

Performs the `+`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `+`

operator.

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

[src]

Performs the `+`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `+`

operator.

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

[src]

Performs the `+`

operation.

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

[src]

`type Output = AddRef<'a>`

The resulting type after applying the `+`

operator.

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

[src]

Performs the `+`

operation.

`impl AddAssign<Rational> for Rational`

[src]

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

[src]

Performs the `+=`

operation.

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

[src]

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

[src]

Performs the `+=`

operation.

`impl AddFrom<Rational> for Rational`

[src]

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

[src]

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

[src]

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

[src]

`impl Sub<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator.

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

[src]

Performs the `-`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator.

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

[src]

Performs the `-`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `-`

operator.

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

[src]

Performs the `-`

operation.

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

[src]

`type Output = SubRef<'a>`

The resulting type after applying the `-`

operator.

`fn sub(self, rhs: &'a Rational) -> SubRef<'a>`

[src]

Performs the `-`

operation.

`impl SubAssign<Rational> for Rational`

[src]

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

[src]

Performs the `-=`

operation.

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

[src]

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

[src]

Performs the `-=`

operation.

`impl SubFrom<Rational> for Rational`

[src]

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

[src]

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

[src]

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

[src]

`impl Mul<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `*`

operator.

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

[src]

Performs the `*`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `*`

operator.

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

[src]

Performs the `*`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `*`

operator.

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

[src]

Performs the `*`

operation.

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

[src]

`type Output = MulRef<'a>`

The resulting type after applying the `*`

operator.

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

[src]

Performs the `*`

operation.

`impl MulAssign<Rational> for Rational`

[src]

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

[src]

Performs the `*=`

operation.

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

[src]

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

[src]

Performs the `*=`

operation.

`impl MulFrom<Rational> for Rational`

[src]

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

[src]

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

[src]

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

[src]

`impl Div<Rational> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `/`

operator.

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

[src]

Performs the `/`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `/`

operator.

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

[src]

Performs the `/`

operation.

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

[src]

`type Output = Rational`

The resulting type after applying the `/`

operator.

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

[src]

Performs the `/`

operation.

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

[src]

`type Output = DivRef<'a>`

The resulting type after applying the `/`

operator.

`fn div(self, rhs: &'a Rational) -> DivRef<'a>`

[src]

Performs the `/`

operation.

`impl DivAssign<Rational> for Rational`

[src]

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

[src]

Performs the `/=`

operation.

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

[src]

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

[src]

Performs the `/=`

operation.

`impl DivFrom<Rational> for Rational`

[src]

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

[src]

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

[src]

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

[src]

`impl Shl<i32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `<<`

operator.

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

[src]

Performs the `<<`

operation.

`impl<'t> Shl<&'t i32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `<<`

operator.

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

[src]

Performs the `<<`

operation.

`impl<'b> Shl<i32> for &'b Rational`

[src]

`type Output = ShlRefI32<'b>`

The resulting type after applying the `<<`

operator.

`fn shl(self, rhs: i32) -> ShlRefI32<'b>`

[src]

Performs the `<<`

operation.

`impl<'t, 'b> Shl<&'t i32> for &'b Rational`

[src]

`type Output = ShlRefI32<'b>`

The resulting type after applying the `<<`

operator.

`fn shl(self, rhs: &'t i32) -> ShlRefI32<'b>`

[src]

Performs the `<<`

operation.

`impl ShlAssign<i32> for Rational`

[src]

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

[src]

Performs the `<<=`

operation.

`impl<'t> ShlAssign<&'t i32> for Rational`

[src]

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

[src]

Performs the `<<=`

operation.

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

[src]

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

[src]

`impl Shr<i32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `>>`

operator.

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

[src]

Performs the `>>`

operation.

`impl<'t> Shr<&'t i32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `>>`

operator.

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

[src]

Performs the `>>`

operation.

`impl<'b> Shr<i32> for &'b Rational`

[src]

`type Output = ShrRefI32<'b>`

The resulting type after applying the `>>`

operator.

`fn shr(self, rhs: i32) -> ShrRefI32<'b>`

[src]

Performs the `>>`

operation.

`impl<'t, 'b> Shr<&'t i32> for &'b Rational`

[src]

`type Output = ShrRefI32<'b>`

The resulting type after applying the `>>`

operator.

`fn shr(self, rhs: &'t i32) -> ShrRefI32<'b>`

[src]

Performs the `>>`

operation.

`impl ShrAssign<i32> for Rational`

[src]

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

[src]

Performs the `>>=`

operation.

`impl<'t> ShrAssign<&'t i32> for Rational`

[src]

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

[src]

Performs the `>>=`

operation.

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

[src]

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

[src]

`impl Pow<i32> for Rational`

[src]

`type Output = Rational`

The resulting type after the power operation.

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

[src]

Performs the power operation. Read more

`impl<'t> Pow<&'t i32> for Rational`

[src]

`type Output = Rational`

The resulting type after the power operation.

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

[src]

Performs the power operation. Read more

`impl<'b> Pow<i32> for &'b Rational`

[src]

`type Output = PowRefI32<'b>`

The resulting type after the power operation.

`fn pow(self, rhs: i32) -> PowRefI32<'b>`

[src]

Performs the power operation. Read more

`impl<'t, 'b> Pow<&'t i32> for &'b Rational`

[src]

`type Output = PowRefI32<'b>`

The resulting type after the power operation.

`fn pow(self, rhs: &'t i32) -> PowRefI32<'b>`

[src]

Performs the power operation. Read more

`impl PowAssign<i32> for Rational`

[src]

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

[src]

Peforms the power operation. Read more

`impl<'t> PowAssign<&'t i32> for Rational`

[src]

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

[src]

Peforms the power operation. Read more

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

[src]

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

[src]

`impl Shl<u32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `<<`

operator.

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

[src]

Performs the `<<`

operation.

`impl<'t> Shl<&'t u32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `<<`

operator.

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

[src]

Performs the `<<`

operation.

`impl<'b> Shl<u32> for &'b Rational`

[src]

`type Output = ShlRefU32<'b>`

The resulting type after applying the `<<`

operator.

`fn shl(self, rhs: u32) -> ShlRefU32<'b>`

[src]

Performs the `<<`

operation.

`impl<'t, 'b> Shl<&'t u32> for &'b Rational`

[src]

`type Output = ShlRefU32<'b>`

The resulting type after applying the `<<`

operator.

`fn shl(self, rhs: &'t u32) -> ShlRefU32<'b>`

[src]

Performs the `<<`

operation.

`impl ShlAssign<u32> for Rational`

[src]

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

[src]

Performs the `<<=`

operation.

`impl<'t> ShlAssign<&'t u32> for Rational`

[src]

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

[src]

Performs the `<<=`

operation.

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

[src]

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

[src]

`impl Shr<u32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `>>`

operator.

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

[src]

Performs the `>>`

operation.

`impl<'t> Shr<&'t u32> for Rational`

[src]

`type Output = Rational`

The resulting type after applying the `>>`

operator.

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

[src]

Performs the `>>`

operation.

`impl<'b> Shr<u32> for &'b Rational`

[src]

`type Output = ShrRefU32<'b>`

The resulting type after applying the `>>`

operator.

`fn shr(self, rhs: u32) -> ShrRefU32<'b>`

[src]

Performs the `>>`

operation.

`impl<'t, 'b> Shr<&'t u32> for &'b Rational`

[src]

`type Output = ShrRefU32<'b>`

The resulting type after applying the `>>`

operator.

`fn shr(self, rhs: &'t u32) -> ShrRefU32<'b>`

[src]

Performs the `>>`

operation.

`impl ShrAssign<u32> for Rational`

[src]

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

[src]

Performs the `>>=`

operation.

`impl<'t> ShrAssign<&'t u32> for Rational`

[src]

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

[src]

Performs the `>>=`

operation.

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

[src]

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

[src]

`impl Pow<u32> for Rational`

[src]

`type Output = Rational`

The resulting type after the power operation.

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

[src]

Performs the power operation. Read more

`impl<'t> Pow<&'t u32> for Rational`

[src]

`type Output = Rational`

The resulting type after the power operation.

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

[src]

Performs the power operation. Read more

`impl<'b> Pow<u32> for &'b Rational`

[src]

`type Output = PowRefU32<'b>`

The resulting type after the power operation.

`fn pow(self, rhs: u32) -> PowRefU32<'b>`

[src]

Performs the power operation. Read more

`impl<'t, 'b> Pow<&'t u32> for &'b Rational`

[src]

`type Output = PowRefU32<'b>`

The resulting type after the power operation.

`fn pow(self, rhs: &'t u32) -> PowRefU32<'b>`

[src]

Performs the power operation. Read more

`impl PowAssign<u32> for Rational`

[src]

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

[src]

Peforms the power operation. Read more

`impl<'t> PowAssign<&'t u32> for Rational`

[src]

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

[src]

Peforms the power operation. Read more

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

[src]

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

[src]

`impl Sum for Rational`

[src]

`fn sum<I>(iter: I) -> Rational where`

I: Iterator<Item = Rational>,

[src]

I: Iterator<Item = Rational>,

Method which takes an iterator and generates `Self`

from the elements by "summing up" the items. Read more

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

[src]

`fn sum<I>(iter: I) -> Rational where`

I: Iterator<Item = &'a Rational>,

[src]

I: Iterator<Item = &'a Rational>,

Method which takes an iterator and generates `Self`

from the elements by "summing up" the items. Read more

`impl Product for Rational`

[src]

`fn product<I>(iter: I) -> Rational where`

I: Iterator<Item = Rational>,

[src]

I: Iterator<Item = Rational>,

Method which takes an iterator and generates `Self`

from the elements by multiplying the items. Read more

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

[src]

`fn product<I>(iter: I) -> Rational where`

I: Iterator<Item = &'a Rational>,

[src]

I: Iterator<Item = &'a Rational>,

Method which takes an iterator and generates `Self`

from the elements by multiplying the items. Read more

`impl Eq for Rational`

[src]

`impl Ord for Rational`

[src]

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

[src]

This method returns an `Ordering`

between `self`

and `other`

. Read more

`fn max(self, other: Self) -> Self`

1.22.0[src]

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`

1.22.0[src]

Compares and returns the minimum of two values. Read more

`impl PartialEq for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

This method tests less than or equal to (for `self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

This method tests greater than or equal to (for `self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<Integer> for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd<Integer> for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

This method tests less than or equal to (for `self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

This method tests greater than or equal to (for `self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<i32> for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd<i32> for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

This method tests less than or equal to (for `self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

This method tests greater than or equal to (for `self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<u32> for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd<u32> for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<i64> for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd<i64> for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

`impl PartialEq<u64> for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd<u64> for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

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

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more

`impl Serialize for Rational`

[src]

`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where`

S: Serializer,

[src]

S: Serializer,

Serialize this value into the given Serde serializer. Read more

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

[src]

`fn deserialize<D>(deserializer: D) -> Result<Rational, D::Error> where`

D: Deserializer<'de>,

[src]

D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

`impl Default for Rational`

[src]

`impl Clone for Rational`

[src]

`fn clone(&self) -> Rational`

[src]

Returns a copy of the value. Read more

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

[src]

Performs copy-assignment from `source`

. Read more

`impl Drop for Rational`

[src]

`impl Hash for Rational`

[src]

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

[src]

Feeds this value into the given [`Hasher`

]. Read more

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

H: Hasher,

1.3.0[src]

H: Hasher,

Feeds a slice of this type into the given [`Hasher`

]. Read more

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

[src]

`impl<Num> From<Num> for Rational where`

Integer: From<Num>,

[src]

Integer: From<Num>,

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

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

[src]

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

`impl FromStr for Rational`

[src]

`type Err = ParseRationalError`

The associated error which can be returned from parsing.

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

[src]

Parses a string `s`

to return a value of this type. Read more

`impl Display for Rational`

[src]

`fn fmt(&self, f: &mut Formatter) -> Result`

[src]

Formats the value using the given formatter. Read more

`impl Debug for Rational`

[src]

`impl Binary for Rational`

[src]

`impl Octal for Rational`

[src]

`impl LowerHex for Rational`

[src]

`impl UpperHex for Rational`

[src]

`impl Assign for Rational`

[src]

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

[src]

`impl<Num> Assign<Num> for Rational where`

Integer: Assign<Num>,

[src]

Integer: Assign<Num>,

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

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

[src]

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

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

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

[src]

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

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

[src]

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

[src]

Performs the conversion.

`impl Send for Rational`

[src]

`impl Sync for Rational`

[src]

`impl Add<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `+`

operator.

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

[src]

Performs the `+`

operation.

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

[src]

`type Output = AddRefRationalOwn<'a>`

The resulting type after applying the `+`

operator.

`fn add(self, rhs: &'a Float) -> AddRefRationalOwn<'a>`

[src]

Performs the `+`

operation.

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

[src]

`type Output = Float`

The resulting type after applying the `+`

operator.

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

[src]

Performs the `+`

operation.

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

[src]

`type Output = AddRefRational<'a>`

The resulting type after applying the `+`

operator.

`fn add(self, rhs: &'a Float) -> AddRefRational<'a>`

[src]

Performs the `+`

operation.

`impl Sub<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `-`

operator.

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

[src]

Performs the `-`

operation.

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

[src]

`type Output = SubFromRefRationalOwn<'a>`

The resulting type after applying the `-`

operator.

`fn sub(self, rhs: &'a Float) -> SubFromRefRationalOwn<'a>`

[src]

Performs the `-`

operation.

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

[src]

`type Output = Float`

The resulting type after applying the `-`

operator.

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

[src]

Performs the `-`

operation.

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

[src]

`type Output = SubRefRationalOwn<'a>`

The resulting type after applying the `-`

operator.

`fn sub(self, rhs: &'a Float) -> SubRefRationalOwn<'a>`

[src]

Performs the `-`

operation.

`impl Mul<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `*`

operator.

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

[src]

Performs the `*`

operation.

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

[src]

`type Output = MulRefRationalOwn<'a>`

The resulting type after applying the `*`

operator.

`fn mul(self, rhs: &'a Float) -> MulRefRationalOwn<'a>`

[src]

Performs the `*`

operation.

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

[src]

`type Output = Float`

The resulting type after applying the `*`

operator.

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

[src]

Performs the `*`

operation.

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

[src]

`type Output = MulRefRational<'a>`

The resulting type after applying the `*`

operator.

`fn mul(self, rhs: &'a Float) -> MulRefRational<'a>`

[src]

Performs the `*`

operation.

`impl Div<Float> for Rational`

[src]

`type Output = Float`

The resulting type after applying the `/`

operator.

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

[src]

Performs the `/`

operation.

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

[src]

`type Output = DivFromRefRationalOwn<'a>`

The resulting type after applying the `/`

operator.

`fn div(self, rhs: &'a Float) -> DivFromRefRationalOwn<'a>`

[src]

Performs the `/`

operation.

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

[src]

`type Output = Float`

The resulting type after applying the `/`

operator.

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

[src]

Performs the `/`

operation.

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

[src]

`type Output = DivRefRationalOwn<'a>`

The resulting type after applying the `/`

operator.

`fn div(self, rhs: &'a Float) -> DivRefRationalOwn<'a>`

[src]

Performs the `/`

operation.

`impl PartialEq<Float> for Rational`

[src]

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

[src]

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

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

1.0.0[src]

This method tests for `!=`

.

`impl PartialOrd<Float> for Rational`

[src]

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

[src]

This method returns an ordering between `self`

and `other`

values if one exists. Read more

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

1.0.0[src]

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `<=`

operator. Read more

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

1.0.0[src]

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

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

1.0.0[src]

`self`

and `other`

) and is used by the `>=`

operator. Read more