Struct typerat::Q

pub struct Q<N, D = P1>(/* private fields */)
where
    N: Numerator<D>,
    D: Denominator;

Q<N, D> represents a type-level rational number with numerator N and denominator D.

Implementations

impl<N, D> Q<N, D>

where N: Numerator<D>, D: Denominator,

pub const fn new() -> Self

Constructs a new instance of this type-level rational number.

Trait Implementations

impl<Nl, Dl, Nr, Dr, No, Do> Add<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: PrivateAddHelper<Q<Nr, Dr>, Output = Q<No, Do>>, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator, No: Numerator<Do>, Do: Denominator,

type Output = Q<No, Do>

The resulting type after applying the + operator.

fn add(self, rhs: Q<Nr, Dr>) -> Self::Output

Performs the + operation.

impl<N, D> Binary for Q<N, D>

where Self: PrivateFmtHelper, N: Numerator<D>, D: Denominator,

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

Formats the value using the given formatter.

impl<N, D> Clone for Q<N, D>

where N: Numerator<D>, D: Denominator,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Nl, Dl, Nr, Dr> Cmp<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: PrivateCmpHelper<Q<Nr, Dr>>, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator,

type Output = <Q<Nl, Dl> as PrivateCmpHelper<Q<Nr, Dr>>>::Output

The resulting type after type-level comparison.

fn cmp(&self, other: &Rhs) -> Self::Output

Performs comparison.

impl<N, D> Debug for Q<N, D>

where N: Numerator<D> + Debug, D: Denominator + Debug,

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

Formats the value using the given formatter.

impl<N, D> Default for Q<N, D>

where N: Numerator<D>, D: Denominator,

fn default() -> Self

Returns the “default value” for a type.

impl<N, D> Display for Q<N, D>

where Self: PrivateFmtHelper, N: Numerator<D>, D: Denominator,

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

Formats the value using the given formatter.

impl<Nl, Dl, Nr, Dr, No, Do> Div<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: Mul<<Q<Nr, Dr> as Recip>::Output, Output = Q<No, Do>>, Q<Nr, Dr>: Recip, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator, No: Numerator<Do>, Do: Denominator,

type Output = Q<No, Do>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Nr, Dr>) -> Self::Output

Performs the / operation.

impl<N, D> LowerHex for Q<N, D>

where Self: PrivateFmtHelper, N: Numerator<D>, D: Denominator,

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

Formats the value using the given formatter.

impl<Nl, Dl, Nr, Dr, No, Do> Mul<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: PrivateMulHelper<Q<Nr, Dr>, Output = Q<No, Do>>, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator, No: Numerator<Do>, Do: Denominator,

type Output = Q<No, Do>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Nr, Dr>) -> Self::Output

Performs the * operation.

impl<N, D, No> Neg for Q<N, D>

where N: Numerator<D> + Neg<Output = No>, D: Denominator, No: Numerator<D>,

type Output = Q<No, D>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N, D> Octal for Q<N, D>

where Self: PrivateFmtHelper, N: Numerator<D>, D: Denominator,

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

Formats the value using the given formatter.

impl<Nl, Dl, Nr, Dr> PartialEq<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: Cmp<Q<Nr, Dr>>, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator,

fn eq(&self, other: &Q<Nr, Dr>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Nl, Dl, Nr, Dr> PartialOrd<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: Cmp<Q<Nr, Dr>>, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator,

fn partial_cmp(&self, other: &Q<Nr, Dr>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<N, D> Rational for Q<N, D>

where Self: Sealed, N: Numerator<D>, D: Denominator,

const F64: f64 = <Self as PrivateF64Helper>::F64

Approximate 64-bit floating point number of this rational number.

impl<Un, Ud> Recip for Q<NInt<Un>, PInt<Ud>>

where Un: NonZeroUnsigned, Ud: NonZeroUnsigned, NInt<Un>: Numerator<PInt<Ud>>, PInt<Ud>: Denominator, NInt<Ud>: Numerator<PInt<Un>>, PInt<Un>: Denominator,

type Output = Q<NInt<Ud>, PInt<Un>>

The resulting type after applying the reciprocal operation.

impl<Un, Ud> Recip for Q<PInt<Un>, PInt<Ud>>

where Un: NonZeroUnsigned, Ud: NonZeroUnsigned, PInt<Un>: Numerator<PInt<Ud>> + Denominator, PInt<Ud>: Denominator + Numerator<PInt<Un>>,

type Output = Q<PInt<Ud>, PInt<Un>>

The resulting type after applying the reciprocal operation.

impl<Nl, Dl, Nr, Dr, No, Do> Rem<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: PrivateRemHelper<Q<Nr, Dr>, Output = Q<No, Do>>, Q<Nr, Dr>: NonZero, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator, No: Numerator<Do>, Do: Denominator,

type Output = Q<No, Do>

The resulting type after applying the % operator.

fn rem(self, rhs: Q<Nr, Dr>) -> Self::Output

Performs the % operation.

impl<Nl, Dl, Nr, Dr, No, Do> Sub<Q<Nr, Dr>> for Q<Nl, Dl>

where Self: Add<<Q<Nr, Dr> as Neg>::Output, Output = Q<No, Do>>, Q<Nr, Dr>: Neg, Nl: Numerator<Dl>, Dl: Denominator, Nr: Numerator<Dr>, Dr: Denominator, No: Numerator<Do>, Do: Denominator,

type Output = Q<No, Do>

The resulting type after applying the - operator.

fn sub(self, rhs: Q<Nr, Dr>) -> Self::Output

Performs the - operation.

impl<N, D> UpperHex for Q<N, D>

where Self: PrivateFmtHelper, N: Numerator<D>, D: Denominator,

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

Formats the value using the given formatter.

impl<N, D> Copy for Q<N, D>

where N: Numerator<D>, D: Denominator,

impl<N, D> NonNegative for Q<N, D>

where N: Numerator<D> + NonNegative, D: Denominator,

impl<N, D> NonZero for Q<N, D>

where N: Numerator<D> + NonZero, D: Denominator,

impl<N> NotOne for Q<N>

where N: Numerator + NotOne,

impl<N, D> NotOne for Q<N, D>

where N: Numerator<D>, D: Denominator + NotOne,