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]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`

Formats the value using the given formatter.

`impl From<u8> for U12`
[src]

`fn from(small: u8) -> Self`

Performs the conversion.

`impl Default for U12`
[src]

`fn default() -> Self`

Returns the "default value" for a type. Read more

`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