Struct twelve_bit::u12::U12
[−]
[src]
pub struct U12(_);
Methods
impl U12
[src]
fn min_value() -> Self
Returns the smallest value that can be represented by this integer type.
fn max_value() -> Self
Returns the largest value that can be represented by this integer type.
fn count_ones(self) -> u32
Returns the number of ones in the binary representation of self
.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b000000000000].count_ones(), 0); assert_eq!(u12![0b001011111100].count_ones(), 7); assert_eq!(u12![0b111111111111].count_ones(), 12)
fn count_zeros(self) -> u32
Returns the number of zeros in the binary representation of self
.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b000000000000].count_zeros(), 12); assert_eq!(u12![0b001011111000].count_zeros(), 6); assert_eq!(u12![0b111111111111].count_zeros(), 0)
fn leading_zeros(self) -> u32
Returns the number of leading zeros in the binary representation of self
.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b111111111111].leading_zeros(), 0); assert_eq!(u12![0b001011111000].leading_zeros(), 2); assert_eq!(u12![0b000011111000].leading_zeros(), 4); assert_eq!(u12![0b000000000000].leading_zeros(), 12);
fn trailing_zeros(self) -> u32
Returns the number of trailing zeros in the binary representation of self
.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b111111111111].trailing_zeros(), 0); assert_eq!(u12![0b001011111000].trailing_zeros(), 3); assert_eq!(u12![0b001011110000].trailing_zeros(), 4); assert_eq!(u12![0b000000000000].trailing_zeros(), 12);
fn checked_add(self, other: Self) -> Option<Self>
Checked integer addition.
Computes self + other
, returning None
if overflow occurred.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![1].checked_add(u12![1]), Some(u12![2])); assert_eq!(U12::max_value().checked_add(u12![1]), None);
fn saturating_add(self, other: Self) -> Self
Saturating integer addition.
Computes self + other
, saturating at the numeric bounds instead of overflowing.
Examples
Basic usage:
use twelve_bit::u12::U12; assert_eq!(U12::from(1u8).saturating_add(1u8.into()), U12::from(2u8)); assert_eq!(U12::max_value().saturating_add(1u8.into()), U12::max_value());
fn wrapping_add(self, other: Self) -> Self
Wrapping (modular) addition.
Computes self + other
, wrapping around at the boundary of the type.
Examples
Basic usage:
use twelve_bit::u12::U12; assert_eq!(U12::from(1u8).wrapping_add(1u8.into()), U12::from(2u8)); assert_eq!(U12::max_value().wrapping_add(3u8.into()), U12::from(2u8));
fn overflowing_add(self, other: Self) -> (Self, bool)
Overflowing addition.
Computes self + other
, returning a tuple of the addition along with a
boolean indicating whether an arithmetic overflow would occur.
If an overflow would have occurred then the wrapped value is returned.
Examples
Basic usage:
use twelve_bit::u12::U12; assert_eq!(U12::from(1u8).overflowing_add(1u8.into()), (U12::from(2u8), false)); assert_eq!(U12::max_value().overflowing_add(3u8.into()), (U12::from(2u8), true));
fn checked_sub(self, other: Self) -> Option<Self>
Checked integer subtraction.
Computes self - other
, returning None
if underflow occurred.
Examples
Basic usage:
use twelve_bit::u12::U12; assert_eq!(U12::from(1u8).checked_sub(1u8.into()), Some(U12::from(0u8))); assert_eq!(U12::min_value().checked_sub(1u8.into()), None);
fn saturating_sub(self, other: Self) -> Self
Saturating integer subtraction.
Computes self - other
, saturating at the numeric bounds instead of overflowing.
Examples
Basic usage:
use twelve_bit::u12::U12; assert_eq!(U12::from(1u8).saturating_sub(1u8.into()), U12::min_value()); assert_eq!(U12::min_value().saturating_sub(5u8.into()), U12::min_value());
fn wrapping_sub(self, other: Self) -> Self
Wrapping (modular) subtraction.
Computes self - other
, wrapping around at the boundary of the type.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(1u8).wrapping_sub(1u8.into()), U12::min_value()); assert_eq!(U12::min_value().wrapping_sub(5u8.into()), (0xFFB as u16).unchecked_into());
fn overflowing_sub(self, other: Self) -> (Self, bool)
Overflowing subtraction.
Computes self - other
, returning a tuple of the subtraction result along with a
boolean indicating whether an arithmetic underflow would occur.
If an underflow would have occurred then the wrapped value is returned.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(1u8).overflowing_sub(1u8.into()), (U12::from(0u8), false)); assert_eq!(U12::min_value().overflowing_sub(1u8.into()), (0xFFFu16.unchecked_into(), true));
fn checked_mul(self, other: Self) -> Option<Self>
Checked integer multiplication.
Computes self * other
, returning None
if overflow occurred.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(2u8).checked_mul(255u8.into()), Some((510 as u16).unchecked_into())); assert_eq!(U12::from(2u8).checked_mul((2048u16).unchecked_into()), None); assert_eq!(U12::from(2u8).checked_mul((4095u16).unchecked_into()), None);
fn saturating_mul(self, other: Self) -> Self
Saturating integer multiplication.
Computes self * other
, saturating at the numeric bounds instead of overflowing.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(2u8).saturating_mul(1u8.into()), 2u8.into()); assert_eq!(U12::from(2u8).saturating_mul((2048u16).unchecked_into()), U12::max_value()); assert_eq!(U12::from(2u8).saturating_mul((4095u16).unchecked_into()), U12::max_value());
fn wrapping_mul(self, other: Self) -> Self
Wrapping (modular) multiplication.
Computes self * other
, wrapping around at the boundary of the type.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(2u8).wrapping_mul(1u8.into()), 2u8.into()); assert_eq!(U12::from(2u8).wrapping_mul((2048u16).unchecked_into()), 0u8.into()); assert_eq!(U12::from(2u8).wrapping_mul((4095u16).unchecked_into()), (0xFFE as u16).unchecked_into());
fn overflowing_mul(self, other: Self) -> (Self, bool)
Overflowing multiplication. Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![2].overflowing_mul(u12![1]), (u12![2], false)); assert_eq!(u12![2].overflowing_mul(u12![2048]), (u12![0], true)); assert_eq!(u12![2].overflowing_mul(u12![4095]), (u12![0xFFE], true));
fn checked_div(self, other: Self) -> Option<Self>
Checked integer division.
Computes self / other
, returning None if other == 0 or the operation results in
underflow or overflow.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(2u8).checked_div(0u8.into()), None); assert_eq!(U12::from(2u8).checked_div((2048u16).unchecked_into()), Some(U12::min_value())); assert_eq!(U12::from(2u8).checked_div(2u8.into()), Some(U12::from(1u8)));
fn wrapping_div(self, other: Self) -> Self
Wrapping (modular) division. Computes self / other. Wrapped division on unsigned types is just normal division. There's no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(2u8).wrapping_div((2048u16).unchecked_into()), U12::min_value()); assert_eq!(U12::from(2u8).wrapping_div(2u8.into()), U12::from(1u8));
fn overflowing_div(self, other: Self) -> (Self, bool)
Calculates the divisor when the receiver is divided by rhs
.
Returns a tuple of the divisor along with a boolean indicating whether an arithmetic
overflow would occur. Note that for unsigned integers overflow never occurs,
so the second value is always false.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![2].overflowing_div(u12![1]), (u12![2], false)); assert_eq!(u12![2048].overflowing_div(u12![2]), (u12![1024], false)); assert_eq!(u12![4095].overflowing_div(u12![2]), (u12![2047], false));
fn checked_neg(self) -> Option<Self>
Checked integer negation.
Computes -self
, returning None
unless self == 0
.
Note that negating any positive integer will overflow.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(0u8).checked_neg(), Some(0u8.into())); assert_eq!(U12::from(2u8).checked_neg(), None);
fn wrapping_neg(self) -> Self
Wrapping (modular) negation.
Computes -self
, wrapping around at the boundary of the type.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(2u8).wrapping_neg(), 0xFFEu16.unchecked_into()); assert_eq!(U12::from(255u8).wrapping_neg(), 0xF01u16.unchecked_into());
fn overflowing_neg(self) -> (U12, bool)
Negates self in an overflowing fashion.
Returns !self + 1
using wrapping operations to return the value that
represents the negation of this unsigned value. Note that for positive
unsigned values overflow always occurs, but negating 0
does not overflow.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(U12::from(0u8).overflowing_neg(), (0u8.into(), false)); assert_eq!(U12::from(2u8).overflowing_neg(), (0xFFEu16.unchecked_into(), true));
fn checked_rem(self, other: Self) -> Option<Self>
Checked integer remainder.
Computes self % other
, returning None
if other == 0
or the
operation results in underflow or overflow.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![5].checked_rem(u12![2]), Some(u12![1])); assert_eq!(u12![5].checked_rem(u12![0]), None);
fn wrapping_rem(self, other: Self) -> Self
Wrapping (modular) integer remainder.
Computes self % other
. Wrapped remainder calculation on unsigned types
is just the regular remainder calculation. There's no way wrapping could ever
happen. This function exists, so that all operations are accounted for in the
wrapping operations.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![100].wrapping_rem(u12![10]), u12![0]);
fn overflowing_rem(self, other: Self) -> (Self, bool)
Calculates the remainder when self
is divided by other
.
Returns a tuple of the remainder after dividing along with a boolean indicating
whether an arithmetic overflow would occur. Note that for unsigned integers
overflow never occurs, so the second value is always false.
Panics
This function will panic if other
is 0
.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![5].overflowing_rem(u12![2]), (u12![1], false));
fn checked_shl(self, rhs: u32) -> Option<Self>
Checked shift left.
Computes self << rhs
, returning None
if rhs
is larger than or equal to
the number of bits in the receiver.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b000000000001].checked_shl(12), None); assert_eq!(u12![0b000000000001].checked_shl(1), Some(u12![0b000000000010])); assert_eq!(u12![0b000000000001].checked_shl(11), Some(u12![0b100000000000]));
fn wrapping_shl(self, rhs: u32) -> Self
Panic-free bitwise shift-left; yields self << mask(rhs)
, where mask removes any
high-order bits of rhs that would cause the shift to exceed the bitwidth of the type.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b000000000001].wrapping_shl(12), u12![0b000000000001]); assert_eq!(u12![0b000000000001].wrapping_shl( 1), u12![0b000000000010]); assert_eq!(u12![0b000000000001].wrapping_shl(11), u12![0b100000000000]);
fn overflowing_shl(self, rhs: u32) -> (Self, bool)
Shifts self left by rhs bits.
Returns a tuple of the shifted version of the receiver along with a boolean
indicating whether the shift value was larger than or equal to the number of
bits. If the shift value is too large, then value is masked (N-1)
where N
is the number of bits, and this value is then used to perform the shift.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b000000000001].overflowing_shl(12), (u12![0b000000000001], true)); assert_eq!(u12![0b000000000001].overflowing_shl( 1), (u12![0b000000000010], false)); assert_eq!(u12![0b000000000001].overflowing_shl(11), (u12![0b100000000000], false));
fn checked_shr(self, rhs: u32) -> Option<Self>
Checked shift right.
Computes self >> rhs
, returning None
if rhs
is larger than or
equal to the number of bits in the receiver.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b100000000000].checked_shr(12), None); assert_eq!(u12![0b100000000000].checked_shr( 1), Some(u12![0b010000000000])); assert_eq!(u12![0b100000000000].checked_shr(11), Some(u12![0b000000000001]));
fn wrapping_shr(self, rhs: u32) -> Self
Panic-free bitwise shift-right; yields self >> mask(rhs)
, where mask removes any
high-order bits of rhs that would cause the shift to exceed the bitwidth of the type.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b100000000000].wrapping_shr(12), u12![0b100000000000]); assert_eq!(u12![0b100000000000].wrapping_shr( 1), u12![0b010000000000]); assert_eq!(u12![0b100000000000].wrapping_shr(11), u12![0b000000000001]);
fn overflowing_shr(self, rhs: u32) -> (Self, bool)
Shifts the receiver right by rhs
bits.
Returns a tuple of the shifted version of self along with a boolean indicating
whether the shift value was larger than or equal to the number of bits.
If the shift value is too large, then value is masked (N-1)
where N
is the
number of bits, and this value is then used to perform the shift.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b100000000000].overflowing_shr(12), (u12![0b100000000000], true)); assert_eq!(u12![0b100000000000].overflowing_shr( 1), (u12![0b010000000000], false)); assert_eq!(u12![0b100000000000].overflowing_shr(11), (u12![0b000000000001], false));
fn checked_bitand(self, rhs: Self) -> Option<Self>
Checked bitwise-and of the receiver with rhs
.
Computes self & rhs
. This method cannot fail.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b111100001111].checked_bitand(u12![0b111100000000]), Some(u12![0b111100000000]));
fn checked_bitor(self, rhs: Self) -> Option<Self>
Checked bitwise-or of the receiver with rhs
.
Computes self | rhs
. This method cannot fail.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b111100001111].checked_bitor(u12![0b111100000000]), Some(u12![0b111100001111]));
fn checked_bitxor(self, rhs: Self) -> Option<Self>
Checked bitwise-xor of the receiver with rhs
.
Computes self ^ rhs
. This method cannot fail.
Examples
Basic usage:
use twelve_bit::u12::*; assert_eq!(u12![0b111100001111].checked_bitxor(u12![0b111100000000]), Some(u12![0b000000001111]));
Trait Implementations
impl Ord for U12
[src]
fn cmp(&self, __arg_0: &U12) -> Ordering
This method returns an Ordering
between self
and other
. Read more
impl PartialOrd for U12
[src]
fn partial_cmp(&self, __arg_0: &U12) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, __arg_0: &U12) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, __arg_0: &U12) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, __arg_0: &U12) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, __arg_0: &U12) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Eq for U12
[src]
impl PartialEq for U12
[src]
fn eq(&self, __arg_0: &U12) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &U12) -> bool
This method tests for !=
.
impl Copy for U12
[src]
impl Clone for U12
[src]
fn clone(&self) -> U12
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl Debug for U12
[src]
impl From<u8> for U12
[src]
impl Default for U12
[src]
impl Add<U12> for U12
[src]
type Output = U12
The resulting type after applying the +
operator
fn add(self, other: U12) -> Self::Output
The method for the +
operator
impl<'a> Add<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the +
operator
fn add(self, other: U12) -> Self::Output
The method for the +
operator
impl<'a> Add<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the +
operator
fn add(self, other: &'a U12) -> Self::Output
The method for the +
operator
impl<'a, 'b> Add<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the +
operator
fn add(self, other: &'a U12) -> Self::Output
The method for the +
operator
impl Sub<U12> for U12
[src]
type Output = U12
The resulting type after applying the -
operator
fn sub(self, other: U12) -> Self::Output
The method for the -
operator
impl<'a> Sub<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the -
operator
fn sub(self, other: U12) -> Self::Output
The method for the -
operator
impl<'a> Sub<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the -
operator
fn sub(self, other: &'a U12) -> Self::Output
The method for the -
operator
impl<'a, 'b> Sub<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the -
operator
fn sub(self, other: &'a U12) -> Self::Output
The method for the -
operator
impl Mul<U12> for U12
[src]
type Output = U12
The resulting type after applying the *
operator
fn mul(self, other: U12) -> Self::Output
The method for the *
operator
impl<'a> Mul<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the *
operator
fn mul(self, other: U12) -> Self::Output
The method for the *
operator
impl<'a> Mul<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the *
operator
fn mul(self, other: &'a U12) -> Self::Output
The method for the *
operator
impl<'a, 'b> Mul<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the *
operator
fn mul(self, other: &'a U12) -> Self::Output
The method for the *
operator
impl Div<U12> for U12
[src]
type Output = U12
The resulting type after applying the /
operator
fn div(self, other: U12) -> Self::Output
The method for the /
operator
impl<'a> Div<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the /
operator
fn div(self, other: U12) -> Self::Output
The method for the /
operator
impl<'a> Div<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the /
operator
fn div(self, other: &'a U12) -> Self::Output
The method for the /
operator
impl<'a, 'b> Div<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the /
operator
fn div(self, other: &'a U12) -> Self::Output
The method for the /
operator
impl Rem<U12> for U12
[src]
type Output = U12
The resulting type after applying the %
operator
fn rem(self, other: U12) -> Self::Output
The method for the %
operator
impl<'a> Rem<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the %
operator
fn rem(self, other: U12) -> Self::Output
The method for the %
operator
impl<'a> Rem<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the %
operator
fn rem(self, other: &'a U12) -> Self::Output
The method for the %
operator
impl<'a, 'b> Rem<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the %
operator
fn rem(self, other: &'a U12) -> Self::Output
The method for the %
operator
impl Not for U12
[src]
type Output = U12
The resulting type after applying the !
operator
fn not(self) -> Self::Output
The method for the unary !
operator
impl<'a> Not for &'a U12
[src]
type Output = U12
The resulting type after applying the !
operator
fn not(self) -> Self::Output
The method for the unary !
operator
impl BitAnd<U12> for U12
[src]
type Output = U12
The resulting type after applying the &
operator
fn bitand(self, other: U12) -> Self::Output
The method for the &
operator
impl<'a> BitAnd<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the &
operator
fn bitand(self, other: U12) -> Self::Output
The method for the &
operator
impl<'a> BitAnd<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the &
operator
fn bitand(self, other: &'a U12) -> Self::Output
The method for the &
operator
impl<'a, 'b> BitAnd<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the &
operator
fn bitand(self, other: &'a U12) -> Self::Output
The method for the &
operator
impl BitOr<U12> for U12
[src]
type Output = U12
The resulting type after applying the |
operator
fn bitor(self, other: U12) -> Self::Output
The method for the |
operator
impl<'a> BitOr<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the |
operator
fn bitor(self, other: U12) -> Self::Output
The method for the |
operator
impl<'a> BitOr<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the |
operator
fn bitor(self, other: &'a U12) -> Self::Output
The method for the |
operator
impl<'a, 'b> BitOr<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the |
operator
fn bitor(self, other: &'a U12) -> Self::Output
The method for the |
operator
impl BitXor<U12> for U12
[src]
type Output = U12
The resulting type after applying the ^
operator
fn bitxor(self, other: U12) -> Self::Output
The method for the ^
operator
impl<'a> BitXor<U12> for &'a U12
[src]
type Output = U12
The resulting type after applying the ^
operator
fn bitxor(self, other: U12) -> Self::Output
The method for the ^
operator
impl<'a> BitXor<&'a U12> for U12
[src]
type Output = U12
The resulting type after applying the ^
operator
fn bitxor(self, other: &'a U12) -> Self::Output
The method for the ^
operator
impl<'a, 'b> BitXor<&'a U12> for &'b U12
[src]
type Output = U12
The resulting type after applying the ^
operator
fn bitxor(self, other: &'a U12) -> Self::Output
The method for the ^
operator
impl Shl<u8> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u8) -> Self::Output
The method for the <<
operator
impl<'a> Shl<u8> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u8) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a u8> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u8) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a u8> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u8) -> Self::Output
The method for the <<
operator
impl Shl<i8> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i8) -> Self::Output
The method for the <<
operator
impl<'a> Shl<i8> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i8) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a i8> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i8) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a i8> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i8) -> Self::Output
The method for the <<
operator
impl Shl<u16> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u16) -> Self::Output
The method for the <<
operator
impl<'a> Shl<u16> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u16) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a u16> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u16) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a u16> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u16) -> Self::Output
The method for the <<
operator
impl Shl<i16> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i16) -> Self::Output
The method for the <<
operator
impl<'a> Shl<i16> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i16) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a i16> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i16) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a i16> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i16) -> Self::Output
The method for the <<
operator
impl Shl<u32> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u32) -> Self::Output
The method for the <<
operator
impl<'a> Shl<u32> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u32) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a u32> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u32) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a u32> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u32) -> Self::Output
The method for the <<
operator
impl Shl<i32> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i32) -> Self::Output
The method for the <<
operator
impl<'a> Shl<i32> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i32) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a i32> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i32) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a i32> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i32) -> Self::Output
The method for the <<
operator
impl Shl<u64> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u64) -> Self::Output
The method for the <<
operator
impl<'a> Shl<u64> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: u64) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a u64> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u64) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a u64> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a u64) -> Self::Output
The method for the <<
operator
impl Shl<i64> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i64) -> Self::Output
The method for the <<
operator
impl<'a> Shl<i64> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: i64) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a i64> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i64) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a i64> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a i64) -> Self::Output
The method for the <<
operator
impl Shl<usize> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: usize) -> Self::Output
The method for the <<
operator
impl<'a> Shl<usize> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: usize) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a usize> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a usize) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a usize> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a usize) -> Self::Output
The method for the <<
operator
impl Shl<isize> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: isize) -> Self::Output
The method for the <<
operator
impl<'a> Shl<isize> for &'a U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: isize) -> Self::Output
The method for the <<
operator
impl<'a> Shl<&'a isize> for U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a isize) -> Self::Output
The method for the <<
operator
impl<'a, 'b> Shl<&'a isize> for &'b U12
[src]
type Output = U12
The resulting type after applying the <<
operator
fn shl(self, other: &'a isize) -> Self::Output
The method for the <<
operator
impl Shr<u8> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u8) -> Self::Output
The method for the >>
operator
impl<'a> Shr<u8> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u8) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a u8> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u8) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a u8> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u8) -> Self::Output
The method for the >>
operator
impl Shr<i8> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i8) -> Self::Output
The method for the >>
operator
impl<'a> Shr<i8> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i8) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a i8> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i8) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a i8> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i8) -> Self::Output
The method for the >>
operator
impl Shr<u16> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u16) -> Self::Output
The method for the >>
operator
impl<'a> Shr<u16> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u16) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a u16> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u16) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a u16> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u16) -> Self::Output
The method for the >>
operator
impl Shr<i16> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i16) -> Self::Output
The method for the >>
operator
impl<'a> Shr<i16> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i16) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a i16> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i16) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a i16> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i16) -> Self::Output
The method for the >>
operator
impl Shr<u32> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u32) -> Self::Output
The method for the >>
operator
impl<'a> Shr<u32> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u32) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a u32> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u32) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a u32> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u32) -> Self::Output
The method for the >>
operator
impl Shr<i32> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i32) -> Self::Output
The method for the >>
operator
impl<'a> Shr<i32> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i32) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a i32> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i32) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a i32> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i32) -> Self::Output
The method for the >>
operator
impl Shr<u64> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u64) -> Self::Output
The method for the >>
operator
impl<'a> Shr<u64> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: u64) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a u64> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u64) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a u64> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a u64) -> Self::Output
The method for the >>
operator
impl Shr<i64> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i64) -> Self::Output
The method for the >>
operator
impl<'a> Shr<i64> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: i64) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a i64> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i64) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a i64> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a i64) -> Self::Output
The method for the >>
operator
impl Shr<usize> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: usize) -> Self::Output
The method for the >>
operator
impl<'a> Shr<usize> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: usize) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a usize> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a usize) -> Self::Output
The method for the >>
operator
impl<'a, 'b> Shr<&'a usize> for &'b U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a usize) -> Self::Output
The method for the >>
operator
impl Shr<isize> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: isize) -> Self::Output
The method for the >>
operator
impl<'a> Shr<isize> for &'a U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: isize) -> Self::Output
The method for the >>
operator
impl<'a> Shr<&'a isize> for U12
[src]
type Output = U12
The resulting type after applying the >>
operator
fn shr(self, other: &'a isize) -> Self::Output
The method for the >>
operator