Trait PrivateDivIf 

pub trait PrivateDivIf<N, D, Q, R, I, RcmpD> {
    type Quotient;
    type Remainder;

    // Required methods
    fn private_div_if_quotient(
        self,
        _: N,
        _: D,
        _: Q,
        _: R,
        _: I,
        _: RcmpD,
    ) -> Self::Quotient;
    fn private_div_if_remainder(
        self,
        _: N,
        _: D,
        _: Q,
        _: R,
        _: I,
        _: RcmpD,
    ) -> Self::Remainder;
}

Required Associated Types

type Quotient

type Remainder

Required Methods

fn private_div_if_quotient( self, _: N, _: D, _: Q, _: R, _: I, _: RcmpD, ) -> Self::Quotient

fn private_div_if_remainder( self, _: N, _: D, _: Q, _: R, _: I, _: RcmpD, ) -> Self::Remainder

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Equal> for ()

where UInt<Ui, Bi>: Copy + Sub<B1>, Q: SetBit<UInt<Ui, Bi>, B1>, (): PrivateDiv<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>,

type Quotient = <() as PrivateDiv<N, D, <Q as SetBit<UInt<Ui, Bi>, B1>>::Output, UTerm, <UInt<Ui, Bi> as Sub<B1>>::Output>>::Quotient

type Remainder = <() as PrivateDiv<N, D, <Q as SetBit<UInt<Ui, Bi>, B1>>::Output, UTerm, <UInt<Ui, Bi> as Sub<B1>>::Output>>::Remainder

fn private_div_if_quotient( self, n: N, d: D, q: Q, _: R, i: UInt<Ui, Bi>, _: Equal, ) -> Self::Quotient

fn private_div_if_remainder( self, n: N, d: D, q: Q, _: R, i: UInt<Ui, Bi>, _: Equal, ) -> Self::Remainder

impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Greater> for ()

where D: Copy, UInt<Ui, Bi>: Copy + Sub<B1>, R: Sub<D>, Q: SetBit<UInt<Ui, Bi>, B1>, (): PrivateDiv<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, Diff<R, D>, Sub1<UInt<Ui, Bi>>>,

type Quotient = <() as PrivateDiv<N, D, <Q as SetBit<UInt<Ui, Bi>, B1>>::Output, <R as Sub<D>>::Output, <UInt<Ui, Bi> as Sub<B1>>::Output>>::Quotient

type Remainder = <() as PrivateDiv<N, D, <Q as SetBit<UInt<Ui, Bi>, B1>>::Output, <R as Sub<D>>::Output, <UInt<Ui, Bi> as Sub<B1>>::Output>>::Remainder

fn private_div_if_quotient( self, n: N, d: D, q: Q, r: R, i: UInt<Ui, Bi>, _: Greater, ) -> Self::Quotient

fn private_div_if_remainder( self, n: N, d: D, q: Q, r: R, i: UInt<Ui, Bi>, _: Greater, ) -> Self::Remainder

impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Less> for ()

where UInt<Ui, Bi>: Sub<B1>, (): PrivateDiv<N, D, Q, R, Sub1<UInt<Ui, Bi>>>,

type Quotient = <() as PrivateDiv<N, D, Q, R, <UInt<Ui, Bi> as Sub<B1>>::Output>>::Quotient

type Remainder = <() as PrivateDiv<N, D, Q, R, <UInt<Ui, Bi> as Sub<B1>>::Output>>::Remainder

fn private_div_if_quotient( self, n: N, d: D, q: Q, r: R, i: UInt<Ui, Bi>, _: Less, ) -> Self::Quotient

fn private_div_if_remainder( self, n: N, d: D, q: Q, r: R, i: UInt<Ui, Bi>, _: Less, ) -> Self::Remainder

impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, UTerm, Equal> for ()

where Q: SetBit<U0, B1>,

type Quotient = <Q as SetBit<UTerm, B1>>::Output

type Remainder = UTerm

fn private_div_if_quotient( self, _: N, _: D, q: Q, _: R, i: U0, _: Equal, ) -> Self::Quotient

fn private_div_if_remainder( self, _: N, _: D, _: Q, _: R, i: U0, _: Equal, ) -> Self::Remainder

impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, UTerm, Greater> for ()

where R: Sub<D>, Q: SetBit<U0, B1>,

type Quotient = <Q as SetBit<UTerm, B1>>::Output

type Remainder = <R as Sub<D>>::Output

fn private_div_if_quotient( self, _: N, _: D, q: Q, _: R, i: U0, _: Greater, ) -> Self::Quotient

fn private_div_if_remainder( self, _: N, d: D, _: Q, r: R, _: U0, _: Greater, ) -> Self::Remainder

impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, UTerm, Less> for ()

type Quotient = Q

type Remainder = R

fn private_div_if_quotient( self, _: N, _: D, q: Q, _: R, _: U0, _: Less, ) -> Self::Quotient

fn private_div_if_remainder( self, _: N, _: D, _: Q, r: R, _: U0, _: Less, ) -> Self::Remainder

Implementors