Struct rug::rational::BorrowRational

source · [−]

#[repr(transparent)]
pub struct BorrowRational<'a> { /* private fields */ }

Expand description

Used to get a reference to a Rational number.

The struct implements Deref<Target = Rational>.

No memory is unallocated when this struct is dropped.

Examples

use rug::{rational::BorrowRational, Rational};
let r = Rational::from((42, 3));
let neg: BorrowRational = r.as_neg();
// r is still valid
assert_eq!(r, (42, 3));
assert_eq!(*neg, (-42, 3));

Implementations

source

impl BorrowRational<'_>

source

pub const unsafe fn from_raw<'a>(raw: mpq_t) -> BorrowRational<'a>

Create a borrow from a raw GMP rational number.

Safety

The value must be initialized.
The mpq_t type can be considered as a kind of pointer, so there can be multiple copies of it. BorrowRational cannot mutate the value, so there can be other copies, but none of them are allowed to mutate the value.
The lifetime is obtained from the return type. The user must ensure the value remains valid for the duration of the lifetime.
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][gmp mpq] for details.

Examples

use rug::{rational::BorrowRational, Rational};
let r = Rational::from((42, 3));
// Safety: r.as_raw() is a valid pointer.
let raw = unsafe { *r.as_raw() };
// Safety: r is still valid when borrow is used.
let borrow = unsafe { BorrowRational::from_raw(raw) };
assert_eq!(r, *borrow);

Methods from Deref<Target = Rational>

source

pub fn as_raw(&self) -> *const mpq_t

Returns a pointer to the inner GMP rational number.

The returned pointer will be valid for as long as self is valid.

Examples

use gmp_mpfr_sys::gmp;
use rug::Rational;
let r = Rational::from((-145, 10));
let q_ptr = r.as_raw();
unsafe {
    let d = gmp::mpq_get_d(q_ptr);
    assert_eq!(d, -14.5);
}
// r is still valid
assert_eq!(r, (-145, 10));

source

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

Examples

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

source

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

Examples

use core::f64;
use rug::{rational::SmallRational, Rational};

// An `f64` has 53 bits of precision.
let exact = 0x1f_1234_5678_9aff_u64;
let den = 0x1000_u64;
let r = Rational::from((exact, den));
assert_eq!(r.to_f64(), exact as f64 / den as f64);

// large has 56 ones
let large = 0xff_1234_5678_9aff_u64;
// trunc has 53 ones followed by 3 zeros
let trunc = 0xff_1234_5678_9af8_u64;
let j = Rational::from((large, den));
assert_eq!(j.to_f64(), trunc as f64 / den as f64);

let max = Rational::from_f64(f64::MAX).unwrap();
let plus_small = max + &*SmallRational::from((7, 2));
// plus_small is truncated to f64::MAX
assert_eq!(plus_small.to_f64(), f64::MAX);
let times_three_two = plus_small * &*SmallRational::from((3, 2));
// times_three_two is too large
assert_eq!(times_three_two.to_f64(), f64::INFINITY);

source

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

source

pub fn numer(&self) -> &Integer

Borrows the numerator as an Integer.

Examples

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

source

pub fn denom(&self) -> &Integer

Borrows the denominator as an Integer.

Examples

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

source

pub fn as_neg(&self) -> BorrowRational<'_>

Borrows a negated copy of the Rational number.

The returned object implements Deref<Target = Rational>.

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

Examples

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

source

pub fn as_abs(&self) -> BorrowRational<'_>

Borrows an absolute copy of the Rational number.

The returned object implements Deref<Target = Rational>.

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

Examples

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

source

pub fn as_recip(&self) -> BorrowRational<'_>

Borrows a reciprocal copy of the Rational number.

The returned object implements Deref<Target = Rational>.

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

Panics

Panics if the value is zero.

Examples

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

source

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

source

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

source

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

source

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::{Complete, Rational};
let r = Rational::from((-100, 17));
let abs = r.abs_ref().complete();
assert_eq!(abs, (100, 17));

source

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

source

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::{Assign, Complete, Rational};
let min = (-3, 2);
let max = (3, 2);
let too_small = Rational::from((-5, 2));
let mut clamped = too_small.clamp_ref(&min, &max).complete();
assert_eq!(clamped, (-3, 2));
let in_range = Rational::from((1, 2));
clamped.assign(in_range.clamp_ref(&min, &max));
assert_eq!(clamped, (1, 2));

source

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::{Complete, Rational};
let r = Rational::from((-100, 17));
assert_eq!(r.recip_ref().complete(), (-17, 100));

source

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

source

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::{Complete, Rational};
// -100/17 = -5 - 15/17
let r = Rational::from((-100, 17));
assert_eq!(r.rem_trunc_ref().complete(), (-15, 17));

source

pub fn fract_trunc_ref(&self) -> FractTruncIncomplete<'_>

Computes the fractional and truncated parts of the number.

The following are implemented with the returned incomplete-computation value as Src:

Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for Src

Examples

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

source

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

source

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::{Complete, Rational};
// 100/17 = 6 - 2/17
let r = Rational::from((100, 17));
assert_eq!(r.rem_ceil_ref().complete(), (-2, 17));

source

pub fn fract_ceil_ref(&self) -> FractCeilIncomplete<'_>

Computes the fractional and ceil parts of the number.

The fractional part cannot be greater than zero.

The following are implemented with the returned incomplete-computation value as Src:

Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for Src

Examples

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

source

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

source

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::{Complete, Rational};
// -100/17 = -6 + 2/17
let r = Rational::from((-100, 17));
assert_eq!(r.rem_floor_ref().complete(), (2, 17));

source

pub fn fract_floor_ref(&self) -> FractFloorIncomplete<'_>

Computes the fractional and floor parts of the number.

The fractional part cannot be negative.

The following are implemented with the returned incomplete-computation value as Src:

Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for Src

Examples

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

source

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

source

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::{Assign, Complete, Rational};
// -3.5 = -4 + 0.5 = -4 + 1/2
let r1 = Rational::from((-35, 10));
let mut rem = r1.rem_round_ref().complete();
assert_eq!(rem, (1, 2));
// 3.7 = 4 - 0.3 = 4 - 3/10
let r2 = Rational::from((37, 10));
rem.assign(r2.rem_round_ref());
assert_eq!(rem, (-3, 10));

source

pub fn fract_round_ref(&self) -> FractRoundIncomplete<'_>

Computes the fractional and round parts of the number.

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

The following are implemented with the returned incomplete-computation value as Src:

Assign<Src> for (Rational, Integer)
Assign<Src> for (&mut Rational, &mut Integer)
From<Src> for (Rational, Integer)
Complete<Completed = (Rational, Integer)> for Src

Examples

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

source

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::{Complete, Rational};
let r = Rational::from((-13, 2));
assert_eq!(r.square_ref().complete(), (169, 4));

Trait Implementations

source

impl<'a> Debug for BorrowRational<'a>

source

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

Formats the value using the given formatter. Read more

source

impl Deref for BorrowRational<'_>

type Target = Rational

The resulting type after dereferencing.

source

fn deref(&self) -> &Rational

Dereferences the value.

Auto Trait Implementations

impl<'a> RefUnwindSafe for BorrowRational<'a>

impl<'a> Send for BorrowRational<'a>

impl<'a> Sync for BorrowRational<'a>

impl<'a> Unpin for BorrowRational<'a>

impl<'a> UnwindSafe for BorrowRational<'a>

Blanket Implementations

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Az for T

source

fn az<Dst>(self) -> Dst where
T: Cast<Dst>,

Casts the value.

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<Src, Dst> CastFrom<Src> for Dst where
Src: Cast<Dst>,

source

fn cast_from(src: Src) -> Dst

Casts the value.

source

impl<T> CheckedAs for T

source

fn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,

Casts the value.

source

impl<Src, Dst> CheckedCastFrom<Src> for Dst where
Src: CheckedCast<Dst>,

source

fn checked_cast_from(src: Src) -> Option<Dst>

Casts the value.

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> OverflowingAs for T

source

fn overflowing_as<Dst>(self) -> (Dst, bool ) where
T: OverflowingCast<Dst>,

Casts the value.

source

impl<Src, Dst> OverflowingCastFrom<Src> for Dst where
Src: OverflowingCast<Dst>,

source

fn overflowing_cast_from(src: Src) -> (Dst, bool )

OverflowingCasts the value.

source

impl<T> SaturatingAs for T

source

fn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,

Casts the value.

source

impl<Src, Dst> SaturatingCastFrom<Src> for Dst where
Src: SaturatingCast<Dst>,

source

fn saturating_cast_from(src: Src) -> Dst

Casts the value.

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

source

impl<T> UnwrappedAs for T

source

fn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,

Casts the value.

source

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst where
Src: UnwrappedCast<Dst>,

source

fn unwrapped_cast_from(src: Src) -> Dst

UnwrappedCasts the value.

source

impl<T> WrappingAs for T

source

fn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,

Casts the value.

source

impl<Src, Dst> WrappingCastFrom<Src> for Dst where
Src: WrappingCast<Dst>,

source

fn wrapping_cast_from(src: Src) -> Dst

WrappingCasts the value.

Struct rug::rational::BorrowRational

Implementations

impl BorrowRational<'_>

pub const unsafe fn from_raw<'a>(raw: mpq_t) -> BorrowRational<'a>

Methods from Deref<Target = Rational>

pub fn as_raw(&self) -> *const mpq_t

pub fn to_f32(&self) -> f32

pub fn to_f64(&self) -> f64

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

pub fn numer(&self) -> &Integer

pub fn denom(&self) -> &Integer

pub fn as_neg(&self) -> BorrowRational<'_>

pub fn as_abs(&self) -> BorrowRational<'_>

pub fn as_recip(&self) -> BorrowRational<'_>

pub fn cmp0(&self) -> Ordering

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

pub fn is_integer(&self) -> bool

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

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

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>,

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

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

pub fn rem_trunc_ref(&self) -> RemTruncIncomplete<'_>

pub fn fract_trunc_ref(&self) -> FractTruncIncomplete<'_>

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

pub fn rem_ceil_ref(&self) -> RemCeilIncomplete<'_>

pub fn fract_ceil_ref(&self) -> FractCeilIncomplete<'_>

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

pub fn rem_floor_ref(&self) -> RemFloorIncomplete<'_>

pub fn fract_floor_ref(&self) -> FractFloorIncomplete<'_>

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

pub fn rem_round_ref(&self) -> RemRoundIncomplete<'_>

pub fn fract_round_ref(&self) -> FractRoundIncomplete<'_>

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

Trait Implementations

impl<'a> Debug for BorrowRational<'a>

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

impl Deref for BorrowRational<'_>

type Target = Rational

fn deref(&self) -> &Rational

Auto Trait Implementations

impl<'a> RefUnwindSafe for BorrowRational<'a>

impl<'a> Send for BorrowRational<'a>

impl<'a> Sync for BorrowRational<'a>

impl<'a> Unpin for BorrowRational<'a>

impl<'a> UnwindSafe for BorrowRational<'a>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Az for T

fn az<Dst>(self) -> Dst where T: Cast<Dst>,

impl<T> Borrow<T> for T where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<Src, Dst> CastFrom<Src> for Dst where Src: Cast<Dst>,

fn cast_from(src: Src) -> Dst

impl<T> CheckedAs for T

fn checked_as<Dst>(self) -> Option<Dst> where T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dst where Src: CheckedCast<Dst>,

fn checked_cast_from(src: Src) -> Option<Dst>

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

fn into(self) -> U

impl<T> OverflowingAs for T

fn overflowing_as<Dst>(self) -> (Dst, bool) where T: OverflowingCast<Dst>,

impl<Src, Dst> OverflowingCastFrom<Src> for Dst where Src: OverflowingCast<Dst>,

fn overflowing_cast_from(src: Src) -> (Dst, bool)

impl<T> SaturatingAs for T

fn saturating_as<Dst>(self) -> Dst where T: SaturatingCast<Dst>,

impl<Src, Dst> SaturatingCastFrom<Src> for Dst where Src: SaturatingCast<Dst>,

fn saturating_cast_from(src: Src) -> Dst

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> UnwrappedAs for T

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>,

impl<T> Any for T where
T: 'static + ?Sized,

fn az<Dst>(self) -> Dst where
T: Cast<Dst>,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<Src, Dst> CastFrom<Src> for Dst where
Src: Cast<Dst>,

fn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dst where
Src: CheckedCast<Dst>,

impl<T, U> Into<U> for T where
U: From<T>,

fn overflowing_as<Dst>(self) -> (Dst, bool ) where
T: OverflowingCast<Dst>,

impl<Src, Dst> OverflowingCastFrom<Src> for Dst where
Src: OverflowingCast<Dst>,

fn overflowing_cast_from(src: Src) -> (Dst, bool )

fn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,

impl<Src, Dst> SaturatingCastFrom<Src> for Dst where
Src: SaturatingCast<Dst>,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

fn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst where
Src: UnwrappedCast<Dst>,

fn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,

impl<Src, Dst> WrappingCastFrom<Src> for Dst where
Src: WrappingCast<Dst>,