[−][src]Struct algebraics::interval_arithmetic::DyadicFractionInterval

pub struct DyadicFractionInterval { /* fields omitted */ }

inclusive interval of the form [a / 2^n, b / 2^n] where a and b are integers and n is an unsigned integer.

Methods

`impl DyadicFractionInterval`[src]

`pub fn new( lower_bound_numer: BigInt, upper_bound_numer: BigInt, log2_denom: usize ) -> Self`[src]

`pub fn from_ratio_range( lower_bound: Ratio<BigInt>, upper_bound: Ratio<BigInt>, log2_denom: usize ) -> Self`[src]

`pub fn from_ratio(ratio: Ratio<BigInt>, log2_denom: usize) -> Self`[src]

`pub fn from_int(value: BigInt, log2_denom: usize) -> Self`[src]

`pub fn from_int_range( lower_bound: BigInt, upper_bound: BigInt, log2_denom: usize ) -> Self`[src]

`pub fn from_dyadic_fraction(numer: BigInt, log2_denom: usize) -> Self`[src]

`pub fn zero(log2_denom: usize) -> Self`[src]

`pub fn one(log2_denom: usize) -> Self`[src]

`pub fn negative_one(log2_denom: usize) -> Self`[src]

`pub fn set_zero(&mut self)`[src]

`pub fn set_one(&mut self)`[src]

`pub fn set_negative_one(&mut self)`[src]

`pub fn into_ratio_range(self) -> (Ratio<BigInt>, Ratio<BigInt>)`[src]

`pub fn to_ratio_range(&self) -> (Ratio<BigInt>, Ratio<BigInt>)`[src]

`pub fn into_lower_bound(self) -> Ratio<BigInt>`[src]

`pub fn into_upper_bound(self) -> Ratio<BigInt>`[src]

`pub fn lower_bound(&self) -> Ratio<BigInt>`[src]

`pub fn upper_bound(&self) -> Ratio<BigInt>`[src]

`pub fn log2_denom(&self) -> usize`[src]

`pub fn lower_bound_numer(&self) -> &BigInt`[src]

`pub fn upper_bound_numer(&self) -> &BigInt`[src]

`pub fn destructure(self) -> (BigInt, BigInt, usize)`[src]

convert to a tuple (self.lower_bound_numer, self.upper_bound_numer, self.log2_denom)

`pub fn set_to_lower_bound(&mut self)`[src]

`pub fn set_to_upper_bound(&mut self)`[src]

`pub fn set_lower_bound_numer(&mut self, lower_bound_numer: BigInt)`[src]

`pub fn set_upper_bound_numer(&mut self, upper_bound_numer: BigInt)`[src]

`pub fn set_lower_bound_to_zero(&mut self)`[src]

`pub fn set_upper_bound_to_zero(&mut self)`[src]

`pub fn convert_log2_denom(&mut self, log2_denom: usize)`[src]

`pub fn into_converted_log2_denom(self, log2_denom: usize) -> Self`[src]

`pub fn to_converted_log2_denom(&self, log2_denom: usize) -> Self`[src]

`pub fn checked_recip(&self) -> Option<Self>`[src]

`pub fn recip(&self) -> Self`[src]

`pub fn into_square(self) -> Self`[src]

`pub fn square_assign(&mut self)`[src]

`pub fn square(&self) -> Self`[src]

`pub fn sqrt_assign(&mut self)`[src]

`pub fn into_sqrt(self) -> Self`[src]

`pub fn sqrt(&self) -> Self`[src]

`pub fn contains_zero(&self) -> bool`[src]

`pub fn into_arithmetic_geometric_mean(self, rhs: Self) -> Self`[src]

`pub fn arithmetic_geometric_mean(&self, rhs: &Self) -> Self`[src]

`pub fn sqrt_2(log2_denom: usize) -> Self`[src]

`pub fn natural_log_of_2(log2_denom: usize) -> Self`[src]

`pub fn log(&self) -> Self`[src]

`pub fn into_exp(self) -> Self`[src]

`pub fn exp(&self) -> Self`[src]

`pub fn is_same(&self, rhs: &Self) -> bool`[src]

use instead of .eq() since .eq() wouldn't have well defined results in all cases

`pub fn abs_assign(&mut self)`[src]

`pub fn into_abs(self) -> Self`[src]

`pub fn abs(&self) -> Self`[src]

`pub fn floor_assign(&mut self, new_log2_denom: usize)`[src]

`pub fn into_floor(self, new_log2_denom: usize) -> Self`[src]

`pub fn floor(&self, new_log2_denom: usize) -> Self`[src]

`pub fn ceil_assign(&mut self, new_log2_denom: usize)`[src]

`pub fn into_ceil(self, new_log2_denom: usize) -> Self`[src]

`pub fn ceil(&self, new_log2_denom: usize) -> Self`[src]

Trait Implementations

`impl ExactDiv<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl<'a> ExactDiv<DyadicFractionInterval> for &'a DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl<'_> ExactDiv<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: &DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl<'a, '_> ExactDiv<&'_ DyadicFractionInterval> for &'a DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: &DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl ExactDivAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn exact_div_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`fn checked_exact_div_assign( &mut self, rhs: DyadicFractionInterval ) -> Result<(), ()>`[src]

`impl<'_> ExactDivAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn exact_div_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`fn checked_exact_div_assign( &mut self, rhs: &DyadicFractionInterval ) -> Result<(), ()>`[src]

`impl AlwaysExactDiv<DyadicFractionInterval> for DyadicFractionInterval`[src]

`impl<'a> AlwaysExactDiv<DyadicFractionInterval> for &'a DyadicFractionInterval`[src]

`impl<'_> AlwaysExactDiv<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`impl<'a, '_> AlwaysExactDiv<&'_ DyadicFractionInterval> for &'a DyadicFractionInterval`[src]

`impl AlwaysExactDivAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`impl<'_> AlwaysExactDivAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`impl IntervalUnion<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn interval_union(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> IntervalUnion<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn interval_union(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> IntervalUnion<DyadicFractionInterval> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn interval_union(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'a, 'b> IntervalUnion<&'a DyadicFractionInterval> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn interval_union(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl IntervalUnionAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn interval_union_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`impl<'_> IntervalUnionAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn interval_union_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`impl Clone for DyadicFractionInterval`[src]

`fn clone(&self) -> DyadicFractionInterval`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Default for DyadicFractionInterval`[src]

`fn default() -> DyadicFractionInterval`[src]

`impl Display for DyadicFractionInterval`[src]

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

`impl Debug for DyadicFractionInterval`[src]

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

`impl Div<u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl<'_> Div<u8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a u8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl Div<Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<u8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<u8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl Div<u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl<'_> Div<u16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a u16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl Div<Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<u16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<u16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl Div<u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl<'_> Div<u32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a u32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl Div<Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<u32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<u32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl Div<u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl<'_> Div<u64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a u64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl Div<Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<u64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<u64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl Div<u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl<'_> Div<u128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a u128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl Div<Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<u128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<u128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl Div<usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl<'_> Div<usize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a usize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl Div<Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<usize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<usize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl Div<BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Div<BigUint> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a BigUint> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl Div<Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<BigUint>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<BigUint>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl Div<i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl<'_> Div<i8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a i8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl Div<Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<i8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<i8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl Div<i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl<'_> Div<i16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a i16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl Div<Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<i16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<i16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl Div<i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl<'_> Div<i32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a i32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl Div<Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<i32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<i32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl Div<i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl<'_> Div<i64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a i64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl Div<Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<i64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<i64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl Div<i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl<'_> Div<i128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a i128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl Div<Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<i128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<i128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl Div<isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl<'_> Div<isize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a isize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl Div<Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<isize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<isize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl Div<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Div<DyadicFractionInterval> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a DyadicFractionInterval> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl Div<Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Div<Ratio<BigInt>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a Ratio<BigInt>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl Div<BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Div<&'_ BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Div<BigInt> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Div<&'a BigInt> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the / operator.

`fn div(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl Sub<u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl<'_> Sub<u8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a u8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<u8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<u8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl Sub<u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl<'_> Sub<u16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a u16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<u16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<u16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl Sub<u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl<'_> Sub<u32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a u32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<u32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<u32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl Sub<u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl<'_> Sub<u64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a u64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<u64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<u64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl Sub<u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl<'_> Sub<u128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a u128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<u128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<u128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl Sub<usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl<'_> Sub<usize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a usize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<usize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<usize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl Sub<BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Sub<BigUint> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a BigUint> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<BigUint>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<BigUint>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl Sub<i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl<'_> Sub<i8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a i8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<i8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<i8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl Sub<i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl<'_> Sub<i16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a i16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<i16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<i16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl Sub<i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl<'_> Sub<i32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a i32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<i32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<i32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl Sub<i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl<'_> Sub<i64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a i64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<i64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<i64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl Sub<i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl<'_> Sub<i128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a i128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<i128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<i128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl Sub<isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl<'_> Sub<isize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a isize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<isize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<isize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl Sub<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Sub<DyadicFractionInterval> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a DyadicFractionInterval> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl Sub<Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Sub<Ratio<BigInt>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a Ratio<BigInt>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl Sub<BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Sub<&'_ BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Sub<BigInt> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Sub<&'a BigInt> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn sub(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl Add<u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl<'_> Add<u8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a u8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl Add<Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<u8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<u8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl Add<u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl<'_> Add<u16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a u16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl Add<Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<u16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<u16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl Add<u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl<'_> Add<u32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a u32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl Add<Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<u32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<u32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl Add<u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl<'_> Add<u64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a u64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl Add<Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<u64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<u64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl Add<u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl<'_> Add<u128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a u128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl Add<Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<u128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<u128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl Add<usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl<'_> Add<usize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a usize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl Add<Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<usize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<usize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl Add<BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Add<BigUint> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a BigUint> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl Add<Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<BigUint>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<BigUint>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl Add<i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl<'_> Add<i8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a i8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl Add<Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<i8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<i8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl Add<i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl<'_> Add<i16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a i16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl Add<Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<i16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<i16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl Add<i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl<'_> Add<i32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a i32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl Add<Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<i32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<i32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl Add<i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl<'_> Add<i64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a i64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl Add<Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<i64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<i64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl Add<i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl<'_> Add<i128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a i128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl Add<Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<i128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<i128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl Add<isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl<'_> Add<isize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a isize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl Add<Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<isize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<isize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl Add<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Add<DyadicFractionInterval> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a DyadicFractionInterval> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl Add<Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Add<Ratio<BigInt>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a Ratio<BigInt>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl Add<BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Add<&'_ BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Add<BigInt> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Add<&'a BigInt> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the + operator.

`fn add(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl Mul<u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ u8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl<'_> Mul<u8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a u8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u8) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<u8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<u8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u8>) -> DyadicFractionInterval`[src]

`impl Mul<u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ u16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl<'_> Mul<u16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a u16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u16) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<u16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<u16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u16>) -> DyadicFractionInterval`[src]

`impl Mul<u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ u32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl<'_> Mul<u32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a u32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u32) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<u32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<u32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u32>) -> DyadicFractionInterval`[src]

`impl Mul<u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ u64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl<'_> Mul<u64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a u64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u64) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<u64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<u64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u64>) -> DyadicFractionInterval`[src]

`impl Mul<u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ u128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl<'_> Mul<u128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: u128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a u128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &u128) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<u128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<u128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<u128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<u128>) -> DyadicFractionInterval`[src]

`impl Mul<usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ usize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl<'_> Mul<usize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: usize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a usize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &usize) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<usize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<usize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<usize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<usize>) -> DyadicFractionInterval`[src]

`impl Mul<BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ BigUint> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl<'_> Mul<BigUint> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: BigUint) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a BigUint> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &BigUint) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<BigUint>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<BigUint>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<BigUint>) -> DyadicFractionInterval`[src]

`impl Mul<i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ i8> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl<'_> Mul<i8> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i8) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a i8> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i8) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<i8>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i8>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<i8>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i8>) -> DyadicFractionInterval`[src]

`impl Mul<i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ i16> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl<'_> Mul<i16> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i16) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a i16> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i16) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<i16>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i16>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<i16>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i16>) -> DyadicFractionInterval`[src]

`impl Mul<i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ i32> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl<'_> Mul<i32> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i32) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a i32> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i32) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<i32>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i32>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<i32>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i32>) -> DyadicFractionInterval`[src]

`impl Mul<i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ i64> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl<'_> Mul<i64> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i64) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a i64> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i64) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<i64>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i64>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<i64>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i64>) -> DyadicFractionInterval`[src]

`impl Mul<i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ i128> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl<'_> Mul<i128> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: i128) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a i128> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &i128) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<i128>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<i128>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<i128>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<i128>) -> DyadicFractionInterval`[src]

`impl Mul<isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ isize> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl<'_> Mul<isize> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: isize) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a isize> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &isize) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<isize>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<isize>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<isize>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<isize>) -> DyadicFractionInterval`[src]

`impl Mul<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'_> Mul<DyadicFractionInterval> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a DyadicFractionInterval> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`impl Mul<Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'_> Mul<Ratio<BigInt>> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a Ratio<BigInt>> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &Ratio<BigInt>) -> DyadicFractionInterval`[src]

`impl Mul<BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Mul<&'_ BigInt> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl<'_> Mul<BigInt> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: BigInt) -> DyadicFractionInterval`[src]

`impl<'a, 'b> Mul<&'a BigInt> for &'b DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the * operator.

`fn mul(self, rhs: &BigInt) -> DyadicFractionInterval`[src]

`impl Neg for DyadicFractionInterval`[src]

`type Output = Self`

The resulting type after applying the - operator.

`fn neg(self) -> Self`[src]

`impl<'_> Neg for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The resulting type after applying the - operator.

`fn neg(self) -> DyadicFractionInterval`[src]

`impl AddAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`impl<'_> AddAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`impl AddAssign<BigInt> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: BigInt)`[src]

`impl<'_> AddAssign<&'_ BigInt> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &BigInt)`[src]

`impl AddAssign<Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<BigInt>)`[src]

`impl<'_> AddAssign<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<BigInt>)`[src]

`impl AddAssign<u8> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: u8)`[src]

`impl<'_> AddAssign<&'_ u8> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &u8)`[src]

`impl AddAssign<Ratio<u8>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<u8>)`[src]

`impl<'_> AddAssign<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<u8>)`[src]

`impl AddAssign<u16> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: u16)`[src]

`impl<'_> AddAssign<&'_ u16> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &u16)`[src]

`impl AddAssign<Ratio<u16>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<u16>)`[src]

`impl<'_> AddAssign<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<u16>)`[src]

`impl AddAssign<u32> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: u32)`[src]

`impl<'_> AddAssign<&'_ u32> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &u32)`[src]

`impl AddAssign<Ratio<u32>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<u32>)`[src]

`impl<'_> AddAssign<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<u32>)`[src]

`impl AddAssign<u64> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: u64)`[src]

`impl<'_> AddAssign<&'_ u64> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &u64)`[src]

`impl AddAssign<Ratio<u64>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<u64>)`[src]

`impl<'_> AddAssign<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<u64>)`[src]

`impl AddAssign<u128> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: u128)`[src]

`impl<'_> AddAssign<&'_ u128> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &u128)`[src]

`impl AddAssign<Ratio<u128>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<u128>)`[src]

`impl<'_> AddAssign<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<u128>)`[src]

`impl AddAssign<usize> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: usize)`[src]

`impl<'_> AddAssign<&'_ usize> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &usize)`[src]

`impl AddAssign<Ratio<usize>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<usize>)`[src]

`impl<'_> AddAssign<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<usize>)`[src]

`impl AddAssign<BigUint> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: BigUint)`[src]

`impl<'_> AddAssign<&'_ BigUint> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &BigUint)`[src]

`impl AddAssign<Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<BigUint>)`[src]

`impl<'_> AddAssign<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<BigUint>)`[src]

`impl AddAssign<i8> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: i8)`[src]

`impl<'_> AddAssign<&'_ i8> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &i8)`[src]

`impl AddAssign<Ratio<i8>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<i8>)`[src]

`impl<'_> AddAssign<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<i8>)`[src]

`impl AddAssign<i16> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: i16)`[src]

`impl<'_> AddAssign<&'_ i16> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &i16)`[src]

`impl AddAssign<Ratio<i16>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<i16>)`[src]

`impl<'_> AddAssign<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<i16>)`[src]

`impl AddAssign<i32> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: i32)`[src]

`impl<'_> AddAssign<&'_ i32> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &i32)`[src]

`impl AddAssign<Ratio<i32>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<i32>)`[src]

`impl<'_> AddAssign<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<i32>)`[src]

`impl AddAssign<i64> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: i64)`[src]

`impl<'_> AddAssign<&'_ i64> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &i64)`[src]

`impl AddAssign<Ratio<i64>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<i64>)`[src]

`impl<'_> AddAssign<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<i64>)`[src]

`impl AddAssign<i128> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: i128)`[src]

`impl<'_> AddAssign<&'_ i128> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &i128)`[src]

`impl AddAssign<Ratio<i128>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<i128>)`[src]

`impl<'_> AddAssign<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<i128>)`[src]

`impl AddAssign<isize> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: isize)`[src]

`impl<'_> AddAssign<&'_ isize> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &isize)`[src]

`impl AddAssign<Ratio<isize>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: Ratio<isize>)`[src]

`impl<'_> AddAssign<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`fn add_assign(&mut self, rhs: &Ratio<isize>)`[src]

`impl SubAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`impl<'_> SubAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`impl SubAssign<BigInt> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: BigInt)`[src]

`impl<'_> SubAssign<&'_ BigInt> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &BigInt)`[src]

`impl SubAssign<Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<BigInt>)`[src]

`impl<'_> SubAssign<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<BigInt>)`[src]

`impl SubAssign<u8> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: u8)`[src]

`impl<'_> SubAssign<&'_ u8> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &u8)`[src]

`impl SubAssign<Ratio<u8>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<u8>)`[src]

`impl<'_> SubAssign<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<u8>)`[src]

`impl SubAssign<u16> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: u16)`[src]

`impl<'_> SubAssign<&'_ u16> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &u16)`[src]

`impl SubAssign<Ratio<u16>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<u16>)`[src]

`impl<'_> SubAssign<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<u16>)`[src]

`impl SubAssign<u32> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: u32)`[src]

`impl<'_> SubAssign<&'_ u32> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &u32)`[src]

`impl SubAssign<Ratio<u32>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<u32>)`[src]

`impl<'_> SubAssign<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<u32>)`[src]

`impl SubAssign<u64> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: u64)`[src]

`impl<'_> SubAssign<&'_ u64> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &u64)`[src]

`impl SubAssign<Ratio<u64>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<u64>)`[src]

`impl<'_> SubAssign<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<u64>)`[src]

`impl SubAssign<u128> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: u128)`[src]

`impl<'_> SubAssign<&'_ u128> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &u128)`[src]

`impl SubAssign<Ratio<u128>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<u128>)`[src]

`impl<'_> SubAssign<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<u128>)`[src]

`impl SubAssign<usize> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: usize)`[src]

`impl<'_> SubAssign<&'_ usize> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &usize)`[src]

`impl SubAssign<Ratio<usize>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<usize>)`[src]

`impl<'_> SubAssign<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<usize>)`[src]

`impl SubAssign<BigUint> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: BigUint)`[src]

`impl<'_> SubAssign<&'_ BigUint> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &BigUint)`[src]

`impl SubAssign<Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<BigUint>)`[src]

`impl<'_> SubAssign<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<BigUint>)`[src]

`impl SubAssign<i8> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: i8)`[src]

`impl<'_> SubAssign<&'_ i8> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &i8)`[src]

`impl SubAssign<Ratio<i8>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<i8>)`[src]

`impl<'_> SubAssign<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<i8>)`[src]

`impl SubAssign<i16> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: i16)`[src]

`impl<'_> SubAssign<&'_ i16> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &i16)`[src]

`impl SubAssign<Ratio<i16>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<i16>)`[src]

`impl<'_> SubAssign<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<i16>)`[src]

`impl SubAssign<i32> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: i32)`[src]

`impl<'_> SubAssign<&'_ i32> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &i32)`[src]

`impl SubAssign<Ratio<i32>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<i32>)`[src]

`impl<'_> SubAssign<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<i32>)`[src]

`impl SubAssign<i64> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: i64)`[src]

`impl<'_> SubAssign<&'_ i64> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &i64)`[src]

`impl SubAssign<Ratio<i64>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<i64>)`[src]

`impl<'_> SubAssign<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<i64>)`[src]

`impl SubAssign<i128> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: i128)`[src]

`impl<'_> SubAssign<&'_ i128> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &i128)`[src]

`impl SubAssign<Ratio<i128>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<i128>)`[src]

`impl<'_> SubAssign<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<i128>)`[src]

`impl SubAssign<isize> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: isize)`[src]

`impl<'_> SubAssign<&'_ isize> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &isize)`[src]

`impl SubAssign<Ratio<isize>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: Ratio<isize>)`[src]

`impl<'_> SubAssign<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`fn sub_assign(&mut self, rhs: &Ratio<isize>)`[src]

`impl MulAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`impl<'_> MulAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`impl MulAssign<BigInt> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: BigInt)`[src]

`impl<'_> MulAssign<&'_ BigInt> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &BigInt)`[src]

`impl MulAssign<Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<BigInt>)`[src]

`impl<'_> MulAssign<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<BigInt>)`[src]

`impl MulAssign<u8> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: u8)`[src]

`impl<'_> MulAssign<&'_ u8> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &u8)`[src]

`impl MulAssign<Ratio<u8>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<u8>)`[src]

`impl<'_> MulAssign<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<u8>)`[src]

`impl MulAssign<u16> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: u16)`[src]

`impl<'_> MulAssign<&'_ u16> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &u16)`[src]

`impl MulAssign<Ratio<u16>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<u16>)`[src]

`impl<'_> MulAssign<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<u16>)`[src]

`impl MulAssign<u32> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: u32)`[src]

`impl<'_> MulAssign<&'_ u32> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &u32)`[src]

`impl MulAssign<Ratio<u32>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<u32>)`[src]

`impl<'_> MulAssign<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<u32>)`[src]

`impl MulAssign<u64> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: u64)`[src]

`impl<'_> MulAssign<&'_ u64> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &u64)`[src]

`impl MulAssign<Ratio<u64>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<u64>)`[src]

`impl<'_> MulAssign<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<u64>)`[src]

`impl MulAssign<u128> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: u128)`[src]

`impl<'_> MulAssign<&'_ u128> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &u128)`[src]

`impl MulAssign<Ratio<u128>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<u128>)`[src]

`impl<'_> MulAssign<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<u128>)`[src]

`impl MulAssign<usize> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: usize)`[src]

`impl<'_> MulAssign<&'_ usize> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &usize)`[src]

`impl MulAssign<Ratio<usize>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<usize>)`[src]

`impl<'_> MulAssign<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<usize>)`[src]

`impl MulAssign<BigUint> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: BigUint)`[src]

`impl<'_> MulAssign<&'_ BigUint> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &BigUint)`[src]

`impl MulAssign<Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<BigUint>)`[src]

`impl<'_> MulAssign<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<BigUint>)`[src]

`impl MulAssign<i8> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: i8)`[src]

`impl<'_> MulAssign<&'_ i8> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &i8)`[src]

`impl MulAssign<Ratio<i8>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<i8>)`[src]

`impl<'_> MulAssign<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<i8>)`[src]

`impl MulAssign<i16> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: i16)`[src]

`impl<'_> MulAssign<&'_ i16> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &i16)`[src]

`impl MulAssign<Ratio<i16>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<i16>)`[src]

`impl<'_> MulAssign<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<i16>)`[src]

`impl MulAssign<i32> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: i32)`[src]

`impl<'_> MulAssign<&'_ i32> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &i32)`[src]

`impl MulAssign<Ratio<i32>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<i32>)`[src]

`impl<'_> MulAssign<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<i32>)`[src]

`impl MulAssign<i64> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: i64)`[src]

`impl<'_> MulAssign<&'_ i64> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &i64)`[src]

`impl MulAssign<Ratio<i64>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<i64>)`[src]

`impl<'_> MulAssign<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<i64>)`[src]

`impl MulAssign<i128> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: i128)`[src]

`impl<'_> MulAssign<&'_ i128> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &i128)`[src]

`impl MulAssign<Ratio<i128>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<i128>)`[src]

`impl<'_> MulAssign<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<i128>)`[src]

`impl MulAssign<isize> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: isize)`[src]

`impl<'_> MulAssign<&'_ isize> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &isize)`[src]

`impl MulAssign<Ratio<isize>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: Ratio<isize>)`[src]

`impl<'_> MulAssign<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`fn mul_assign(&mut self, rhs: &Ratio<isize>)`[src]

`impl DivAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`impl<'_> DivAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`impl DivAssign<BigInt> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: BigInt)`[src]

`impl<'_> DivAssign<&'_ BigInt> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &BigInt)`[src]

`impl DivAssign<Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<BigInt>)`[src]

`impl<'_> DivAssign<&'_ Ratio<BigInt>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<BigInt>)`[src]

`impl DivAssign<u8> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: u8)`[src]

`impl<'_> DivAssign<&'_ u8> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &u8)`[src]

`impl DivAssign<Ratio<u8>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<u8>)`[src]

`impl<'_> DivAssign<&'_ Ratio<u8>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<u8>)`[src]

`impl DivAssign<u16> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: u16)`[src]

`impl<'_> DivAssign<&'_ u16> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &u16)`[src]

`impl DivAssign<Ratio<u16>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<u16>)`[src]

`impl<'_> DivAssign<&'_ Ratio<u16>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<u16>)`[src]

`impl DivAssign<u32> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: u32)`[src]

`impl<'_> DivAssign<&'_ u32> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &u32)`[src]

`impl DivAssign<Ratio<u32>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<u32>)`[src]

`impl<'_> DivAssign<&'_ Ratio<u32>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<u32>)`[src]

`impl DivAssign<u64> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: u64)`[src]

`impl<'_> DivAssign<&'_ u64> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &u64)`[src]

`impl DivAssign<Ratio<u64>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<u64>)`[src]

`impl<'_> DivAssign<&'_ Ratio<u64>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<u64>)`[src]

`impl DivAssign<u128> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: u128)`[src]

`impl<'_> DivAssign<&'_ u128> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &u128)`[src]

`impl DivAssign<Ratio<u128>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<u128>)`[src]

`impl<'_> DivAssign<&'_ Ratio<u128>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<u128>)`[src]

`impl DivAssign<usize> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: usize)`[src]

`impl<'_> DivAssign<&'_ usize> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &usize)`[src]

`impl DivAssign<Ratio<usize>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<usize>)`[src]

`impl<'_> DivAssign<&'_ Ratio<usize>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<usize>)`[src]

`impl DivAssign<BigUint> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: BigUint)`[src]

`impl<'_> DivAssign<&'_ BigUint> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &BigUint)`[src]

`impl DivAssign<Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<BigUint>)`[src]

`impl<'_> DivAssign<&'_ Ratio<BigUint>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<BigUint>)`[src]

`impl DivAssign<i8> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: i8)`[src]

`impl<'_> DivAssign<&'_ i8> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &i8)`[src]

`impl DivAssign<Ratio<i8>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<i8>)`[src]

`impl<'_> DivAssign<&'_ Ratio<i8>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<i8>)`[src]

`impl DivAssign<i16> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: i16)`[src]

`impl<'_> DivAssign<&'_ i16> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &i16)`[src]

`impl DivAssign<Ratio<i16>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<i16>)`[src]

`impl<'_> DivAssign<&'_ Ratio<i16>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<i16>)`[src]

`impl DivAssign<i32> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: i32)`[src]

`impl<'_> DivAssign<&'_ i32> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &i32)`[src]

`impl DivAssign<Ratio<i32>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<i32>)`[src]

`impl<'_> DivAssign<&'_ Ratio<i32>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<i32>)`[src]

`impl DivAssign<i64> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: i64)`[src]

`impl<'_> DivAssign<&'_ i64> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &i64)`[src]

`impl DivAssign<Ratio<i64>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<i64>)`[src]

`impl<'_> DivAssign<&'_ Ratio<i64>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<i64>)`[src]

`impl DivAssign<i128> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: i128)`[src]

`impl<'_> DivAssign<&'_ i128> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &i128)`[src]

`impl DivAssign<Ratio<i128>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<i128>)`[src]

`impl<'_> DivAssign<&'_ Ratio<i128>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<i128>)`[src]

`impl DivAssign<isize> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: isize)`[src]

`impl<'_> DivAssign<&'_ isize> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &isize)`[src]

`impl DivAssign<Ratio<isize>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: Ratio<isize>)`[src]

`impl<'_> DivAssign<&'_ Ratio<isize>> for DyadicFractionInterval`[src]

`fn div_assign(&mut self, rhs: &Ratio<isize>)`[src]

`impl Hash for DyadicFractionInterval`[src]

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

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

`impl<E: Integer> Pow<E> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The result after applying the operator.

`fn pow(self, exponent: E) -> DyadicFractionInterval`[src]

`impl<'_, E: Integer> Pow<E> for &'_ DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

The result after applying the operator.

`fn pow(self, exponent: E) -> DyadicFractionInterval`[src]

Auto Trait Implementations

`impl Send for DyadicFractionInterval`

`impl Sync for DyadicFractionInterval`

`impl Unpin for DyadicFractionInterval`

`impl UnwindSafe for DyadicFractionInterval`

`impl RefUnwindSafe for DyadicFractionInterval`

Blanket Implementations

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToString for T where T: Display + ?Sized,` [src]

`default fn to_string(&self) -> String`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

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

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

[−][src]Struct algebraics::interval_arithmetic::DyadicFractionInterval

Methods

impl DyadicFractionInterval[src]

pub fn new( lower_bound_numer: BigInt, upper_bound_numer: BigInt, log2_denom: usize) -> Self[src]

pub fn from_ratio_range( lower_bound: Ratio<BigInt>, upper_bound: Ratio<BigInt>, log2_denom: usize) -> Self[src]

pub fn from_ratio(ratio: Ratio<BigInt>, log2_denom: usize) -> Self[src]

pub fn from_int(value: BigInt, log2_denom: usize) -> Self[src]

pub fn from_int_range( lower_bound: BigInt, upper_bound: BigInt, log2_denom: usize) -> Self[src]

pub fn from_dyadic_fraction(numer: BigInt, log2_denom: usize) -> Self[src]

pub fn zero(log2_denom: usize) -> Self[src]

pub fn one(log2_denom: usize) -> Self[src]

pub fn negative_one(log2_denom: usize) -> Self[src]

pub fn set_zero(&mut self)[src]

pub fn set_one(&mut self)[src]

pub fn set_negative_one(&mut self)[src]

pub fn into_ratio_range(self) -> (Ratio<BigInt>, Ratio<BigInt>)[src]

pub fn to_ratio_range(&self) -> (Ratio<BigInt>, Ratio<BigInt>)[src]

pub fn into_lower_bound(self) -> Ratio<BigInt>[src]

pub fn into_upper_bound(self) -> Ratio<BigInt>[src]

pub fn lower_bound(&self) -> Ratio<BigInt>[src]

pub fn upper_bound(&self) -> Ratio<BigInt>[src]

pub fn log2_denom(&self) -> usize[src]

pub fn lower_bound_numer(&self) -> &BigInt[src]

pub fn upper_bound_numer(&self) -> &BigInt[src]

pub fn destructure(self) -> (BigInt, BigInt, usize)[src]

pub fn set_to_lower_bound(&mut self)[src]

pub fn set_to_upper_bound(&mut self)[src]

pub fn set_lower_bound_numer(&mut self, lower_bound_numer: BigInt)[src]

pub fn set_upper_bound_numer(&mut self, upper_bound_numer: BigInt)[src]

pub fn set_lower_bound_to_zero(&mut self)[src]

pub fn set_upper_bound_to_zero(&mut self)[src]

pub fn convert_log2_denom(&mut self, log2_denom: usize)[src]

pub fn into_converted_log2_denom(self, log2_denom: usize) -> Self[src]

pub fn to_converted_log2_denom(&self, log2_denom: usize) -> Self[src]

pub fn checked_recip(&self) -> Option<Self>[src]

pub fn recip(&self) -> Self[src]

pub fn into_square(self) -> Self[src]

pub fn square_assign(&mut self)[src]

pub fn square(&self) -> Self[src]

pub fn sqrt_assign(&mut self)[src]

pub fn into_sqrt(self) -> Self[src]

pub fn sqrt(&self) -> Self[src]

pub fn contains_zero(&self) -> bool[src]

pub fn into_arithmetic_geometric_mean(self, rhs: Self) -> Self[src]

pub fn arithmetic_geometric_mean(&self, rhs: &Self) -> Self[src]

pub fn sqrt_2(log2_denom: usize) -> Self[src]

pub fn natural_log_of_2(log2_denom: usize) -> Self[src]

pub fn log(&self) -> Self[src]

pub fn into_exp(self) -> Self[src]

pub fn exp(&self) -> Self[src]

pub fn is_same(&self, rhs: &Self) -> bool[src]

pub fn abs_assign(&mut self)[src]

pub fn into_abs(self) -> Self[src]

pub fn abs(&self) -> Self[src]

pub fn floor_assign(&mut self, new_log2_denom: usize)[src]

pub fn into_floor(self, new_log2_denom: usize) -> Self[src]

pub fn floor(&self, new_log2_denom: usize) -> Self[src]

pub fn ceil_assign(&mut self, new_log2_denom: usize)[src]

pub fn into_ceil(self, new_log2_denom: usize) -> Self[src]

pub fn ceil(&self, new_log2_denom: usize) -> Self[src]

Trait Implementations

impl ExactDiv<DyadicFractionInterval> for DyadicFractionInterval[src]

type Output = DyadicFractionInterval

fn exact_div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval[src]

fn checked_exact_div( self, rhs: DyadicFractionInterval) -> Option<DyadicFractionInterval>[src]

impl<'a> ExactDiv<DyadicFractionInterval> for &'a DyadicFractionInterval[src]

type Output = DyadicFractionInterval

fn exact_div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval[src]

fn checked_exact_div( self, rhs: DyadicFractionInterval) -> Option<DyadicFractionInterval>[src]

impl<'_> ExactDiv<&'_ DyadicFractionInterval> for DyadicFractionInterval[src]

type Output = DyadicFractionInterval

fn exact_div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval[src]

fn checked_exact_div( self, rhs: &DyadicFractionInterval) -> Option<DyadicFractionInterval>[src]

impl<'a, '_> ExactDiv<&'_ DyadicFractionInterval> for &'a DyadicFractionInterval[src]

type Output = DyadicFractionInterval

fn exact_div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval[src]

fn checked_exact_div( self, rhs: &DyadicFractionInterval) -> Option<DyadicFractionInterval>[src]

impl ExactDivAssign<DyadicFractionInterval> for DyadicFractionInterval[src]

fn exact_div_assign(&mut self, rhs: DyadicFractionInterval)[src]

fn checked_exact_div_assign( &mut self, rhs: DyadicFractionInterval) -> Result<(), ()>[src]

`impl DyadicFractionInterval`[src]

`pub fn new( lower_bound_numer: BigInt, upper_bound_numer: BigInt, log2_denom: usize ) -> Self`[src]

`pub fn from_ratio_range( lower_bound: Ratio<BigInt>, upper_bound: Ratio<BigInt>, log2_denom: usize ) -> Self`[src]

`pub fn from_ratio(ratio: Ratio<BigInt>, log2_denom: usize) -> Self`[src]

`pub fn from_int(value: BigInt, log2_denom: usize) -> Self`[src]

`pub fn from_int_range( lower_bound: BigInt, upper_bound: BigInt, log2_denom: usize ) -> Self`[src]

`pub fn from_dyadic_fraction(numer: BigInt, log2_denom: usize) -> Self`[src]

`pub fn zero(log2_denom: usize) -> Self`[src]

`pub fn one(log2_denom: usize) -> Self`[src]

`pub fn negative_one(log2_denom: usize) -> Self`[src]

`pub fn set_zero(&mut self)`[src]

`pub fn set_one(&mut self)`[src]

`pub fn set_negative_one(&mut self)`[src]

`pub fn into_ratio_range(self) -> (Ratio<BigInt>, Ratio<BigInt>)`[src]

`pub fn to_ratio_range(&self) -> (Ratio<BigInt>, Ratio<BigInt>)`[src]

`pub fn into_lower_bound(self) -> Ratio<BigInt>`[src]

`pub fn into_upper_bound(self) -> Ratio<BigInt>`[src]

`pub fn lower_bound(&self) -> Ratio<BigInt>`[src]

`pub fn upper_bound(&self) -> Ratio<BigInt>`[src]

`pub fn log2_denom(&self) -> usize`[src]

`pub fn lower_bound_numer(&self) -> &BigInt`[src]

`pub fn upper_bound_numer(&self) -> &BigInt`[src]

`pub fn destructure(self) -> (BigInt, BigInt, usize)`[src]

`pub fn set_to_lower_bound(&mut self)`[src]

`pub fn set_to_upper_bound(&mut self)`[src]

`pub fn set_lower_bound_numer(&mut self, lower_bound_numer: BigInt)`[src]

`pub fn set_upper_bound_numer(&mut self, upper_bound_numer: BigInt)`[src]

`pub fn set_lower_bound_to_zero(&mut self)`[src]

`pub fn set_upper_bound_to_zero(&mut self)`[src]

`pub fn convert_log2_denom(&mut self, log2_denom: usize)`[src]

`pub fn into_converted_log2_denom(self, log2_denom: usize) -> Self`[src]

`pub fn to_converted_log2_denom(&self, log2_denom: usize) -> Self`[src]

`pub fn checked_recip(&self) -> Option<Self>`[src]

`pub fn recip(&self) -> Self`[src]

`pub fn into_square(self) -> Self`[src]

`pub fn square_assign(&mut self)`[src]

`pub fn square(&self) -> Self`[src]

`pub fn sqrt_assign(&mut self)`[src]

`pub fn into_sqrt(self) -> Self`[src]

`pub fn sqrt(&self) -> Self`[src]

`pub fn contains_zero(&self) -> bool`[src]

`pub fn into_arithmetic_geometric_mean(self, rhs: Self) -> Self`[src]

`pub fn arithmetic_geometric_mean(&self, rhs: &Self) -> Self`[src]

`pub fn sqrt_2(log2_denom: usize) -> Self`[src]

`pub fn natural_log_of_2(log2_denom: usize) -> Self`[src]

`pub fn log(&self) -> Self`[src]

`pub fn into_exp(self) -> Self`[src]

`pub fn exp(&self) -> Self`[src]

`pub fn is_same(&self, rhs: &Self) -> bool`[src]

`pub fn abs_assign(&mut self)`[src]

`pub fn into_abs(self) -> Self`[src]

`pub fn abs(&self) -> Self`[src]

`pub fn floor_assign(&mut self, new_log2_denom: usize)`[src]

`pub fn into_floor(self, new_log2_denom: usize) -> Self`[src]

`pub fn floor(&self, new_log2_denom: usize) -> Self`[src]

`pub fn ceil_assign(&mut self, new_log2_denom: usize)`[src]

`pub fn into_ceil(self, new_log2_denom: usize) -> Self`[src]

`pub fn ceil(&self, new_log2_denom: usize) -> Self`[src]

`impl ExactDiv<DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl<'a> ExactDiv<DyadicFractionInterval> for &'a DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl<'_> ExactDiv<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: &DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl<'a, '_> ExactDiv<&'_ DyadicFractionInterval> for &'a DyadicFractionInterval`[src]

`type Output = DyadicFractionInterval`

`fn exact_div(self, rhs: &DyadicFractionInterval) -> DyadicFractionInterval`[src]

`fn checked_exact_div( self, rhs: &DyadicFractionInterval ) -> Option<DyadicFractionInterval>`[src]

`impl ExactDivAssign<DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn exact_div_assign(&mut self, rhs: DyadicFractionInterval)`[src]

`fn checked_exact_div_assign( &mut self, rhs: DyadicFractionInterval ) -> Result<(), ()>`[src]

`impl<'_> ExactDivAssign<&'_ DyadicFractionInterval> for DyadicFractionInterval`[src]

`fn exact_div_assign(&mut self, rhs: &DyadicFractionInterval)`[src]

`fn checked_exact_div_assign( &mut self, rhs: &DyadicFractionInterval ) -> Result<(), ()>`[src]