# 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 Debug 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 Copy 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 Eq for U12`

[src]

`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 Ord for U12`

[src]

`fn cmp(&self, __arg_0: &U12) -> Ordering`

This method returns an `Ordering`

between `self`

and `other`

. Read more

`impl From<u8> for U12`

[src]

`impl FailableInto<u8> for U12`

[src]

Implements a failable conversion into u8 from U12.

`fn failable_into(self) -> Option<u8>`

Returns the receiver as `Some(T)`

if non-truncating, or `None`

.

`fn unchecked_into(self) -> T`

Returns the receiver as `T`

by using `failable_into()`

and unwrapping the result. Read more

`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