devela::zall_::_num

Struct Bitwise

#[repr(transparent)]
pub struct Bitwise<T>(pub T);

Expand description

⅀ 🛠️ Provides constant bitwise operations on T.

^{📍 num/fin}

It’s implemented for: u8, u16, u32, u64, u128 and usize.

§Panic behavior

Unchecked bit operations panic in debug builds when a bit index or range is out of bounds. In release builds they do not panic; the invalid index produces a wrapped shift and a non-meaningful result.

Checked variants never panic and return an error instead.

See also BitOps for the related trait.

§Methods

The methods are the same for all unsigned primitives. The following list of methods links to the u8 implementation:

Constants and mask constructors
- mask_range (checked).
- is_set_mask.
- set_mask.
- is_unset_mask.
- unset_mask.
Get methods
- get_range (checked).
- get_value_range (checked).
Set ops
- is_set (checked).
- set (checked).
- is_set_range (checked).
- set_range (checked).
- set_all.
- set_value_range (checked, checked_strict).
Unset ops
- is_unset (checked).
- unset (checked).
- is_unset_range (checked).
- unset_range (checked).
- unset_all.
Flip ops
- flip (checked).
- flip_range (checked).
- flip_range_if (checked).
Reverse ops
- reverse_range (checked).
Count ops
- count_ones_range (checked).
- count_zeros_range (checked).
Find ops
- find_first_one_range (checked).
- find_first_zero_range (checked).
- find_last_one_range (checked).
- find_last_zero_range (checked).

pub const fn is_set_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 1.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b0011_1000);
assert![b.is_set_range(3, 5)];

Source

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 1.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b0011_1000);
assert![b.is_set_range_checked(3, 5).unwrap()];

Source

pub const fn set_range(self, start: u32, end: u32) -> Self

Sets the bits in self to 1, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b1000_0001);
assert_eq![0b1001_1111, b.set_range(1, 4).0];

Sets the given value into the bits from the [start..=end] range.

Leaves the rest of the bits unchanged.

The value is first masked to fit the size of the range, and then it is inserted into the specified bit range of self, replacing the existing bits in that range. The rest of the bits in self remain unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range(0b101, 1, 3).0];

Source

pub const fn set_value_range_checked( self, value: u8, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range_checked(0b101, 1, 3).unwrap().0];

Source

pub const fn set_value_range_checked_strict( self, value: u8, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given checked value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

A value fits when it can be represented by end - start + 1 bits.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS, MismatchedIndices if start > end, and MismatchedCapacity if value does not fit within the specified bit range.

§Examples

let b = Bitwise::<u8>(0);
assert![b.set_value_range_checked_strict(0b100, 0, 1).is_err()];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u8>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_checked(7).unwrap().0];

Source

pub const fn is_unset_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 0.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b1000_0001);
assert![b.is_unset_range(1, 6)];

Source

pub const fn is_unset_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 0.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1000_0001);
assert![b.is_unset_range_checked(1, 6).unwrap()];

Source

pub const fn unset_range(self, start: u32, end: u32) -> Self

Unsets the bits in self to 0, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range(1, 4).0];

Source

pub const fn unset_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Unsets the bits in self to 0, from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range_checked(1, 4).unwrap().0];

Source

pub const fn unset_all(self) -> Self

Unsets all the bits to 0.

§Examples

let b = Bitwise::<u8>(0b1111_1111);
assert_eq![0, b.unset_all().0];

Source §

impl Bitwise<u8>

§Flip ops for `u8`.

Source

pub const fn flip(self, nth: u32) -> Self

Flips the nth bit.

§Panics

Panics in debug mode if `nth >= BITS.

§Examples

let b = Bitwise::<u8>(0b0000_0001);
assert_eq![0, b.flip(0).0];

Source

pub const fn flip_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

Flips the nth bit.

§Errors

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u8>(0b0000_0001);
assert_eq![0, b.flip_checked(0).unwrap().0];

Source

pub const fn flip_range(self, start: u32, end: u32) -> Self

Flips the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range(4, 7).0];

Source

pub const fn flip_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Flips the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range_checked(4, 7).unwrap().0];

Source

pub const fn flip_range_if(self, start: u32, end: u32, cond: bool) -> Self

Conditionally flips bits in a range if cond is true.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if(4, 7, false).0];

Source

pub const fn flip_range_if_checked( self, start: u32, end: u32, cond: bool, ) -> Result<Self, MismatchedBounds> ⓘ

Conditionally flips bits in a range if cond is true.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if_checked(4, 7, false).unwrap().0];

Source §

impl Bitwise<u8>

§Reverse ops for `u8`.

Source

pub const fn reverse_range(self, start: u32, end: u32) -> Self

Reverses the order of the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u8>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range(1, 4).0];

Source

pub const fn reverse_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Reverses the order of the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1011_0110);
assert_eq![1, b.count_zeros_range_checked(1, 4).unwrap()];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u8>(0b1110_1111);
assert_eq![Some(4), b.find_last_zero_range_checked(0, 7).unwrap()];

Source §

impl Bitwise<u16>

§Implementations for `u16`.

§Constants and mask constructors for `u16`.

Source

pub const BITS: u32 = u16::BITS

The size in bits.

Source

pub const fn mask_range(start: u32, end: u32) -> Self

Returns a bitmask of ones from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u16>::mask_range(1, 4).0]

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    2.8 ns   163.0 ns
  64    2.0 ns    21.6 ns
  32    2.4 ns    12.1 ns
  16    2.6 ns     7.6 ns
   8    2.9 ns     8.4 ns

Source

pub const fn mask_range_checked( start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Returns a bitmask of ones from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u16>::mask_range_checked(1, 4).unwrap().0];

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    3.7 ns   145.0 ns
  64    3.2 ns    38.2 ns
  32    3.2 ns     9.0 ns
  16    3.2 ns     7.0 ns
   8    3.1 ns     6.7 ns

Source

pub const fn is_set_mask(self, mask: u16) -> bool

Returns true if any bit selected by mask is 1 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert![b.is_set_mask(0b1000_0000)];

Source

pub const fn set_mask(self, mask: u16) -> Self

Sets all bits selected by mask to 1.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b1010_1111, b.set_mask(0b0000_1111).0];

Source

pub const fn is_unset_mask(self, mask: u16) -> bool

Returns true if all bits selected by mask are 0 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert![b.is_unset_mask(0b0100_0000)];

Source

pub const fn unset_mask(self, mask: u16) -> Self

Sets all bits selected by mask to 0.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_mask(0b1000_0000).0];

Source §

impl Bitwise<u16>

§Get methods for `u16`.

Source

pub const fn get_range(self, start: u32, end: u32) -> Self

Gets the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range(1, 4).0];

Source

pub const fn get_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range_checked(1, 4).unwrap().0];

Source

pub const fn get_value_range(self, start: u32, end: u32) -> Self

Gets the value of the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1011_0110);
assert_eq![0b1011, b.get_value_range(1, 4).0];

Source

pub const fn get_value_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the value of the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1011_0110);
assert_eq![0b1011, b.get_value_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u16>(0);
assert_eq![0b0000_1000, b.set_checked(3).unwrap().0];

Source

pub const fn is_set_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 1.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b0011_1000);
assert![b.is_set_range(3, 5)];

Source

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 1.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b0011_1000);
assert![b.is_set_range_checked(3, 5).unwrap()];

Source

pub const fn set_range(self, start: u32, end: u32) -> Self

Sets the bits in self to 1, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1000_0001);
assert_eq![0b1001_1111, b.set_range(1, 4).0];

Sets the given value into the bits from the [start..=end] range.

Leaves the rest of the bits unchanged.

The value is first masked to fit the size of the range, and then it is inserted into the specified bit range of self, replacing the existing bits in that range. The rest of the bits in self remain unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range(0b101, 1, 3).0];

Source

pub const fn set_value_range_checked( self, value: u16, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range_checked(0b101, 1, 3).unwrap().0];

Source

pub const fn set_value_range_checked_strict( self, value: u16, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given checked value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

A value fits when it can be represented by end - start + 1 bits.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS, MismatchedIndices if start > end, and MismatchedCapacity if value does not fit within the specified bit range.

§Examples

let b = Bitwise::<u16>(0);
assert![b.set_value_range_checked_strict(0b100, 0, 1).is_err()];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_checked(7).unwrap().0];

Source

pub const fn is_unset_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 0.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1000_0001);
assert![b.is_unset_range(1, 6)];

Source

pub const fn is_unset_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 0.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1000_0001);
assert![b.is_unset_range_checked(1, 6).unwrap()];

Source

pub const fn unset_range(self, start: u32, end: u32) -> Self

Unsets the bits in self to 0, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range(1, 4).0];

Source

pub const fn unset_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Unsets the bits in self to 0, from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range_checked(1, 4).unwrap().0];

Source

pub const fn unset_all(self) -> Self

Unsets all the bits to 0.

§Examples

let b = Bitwise::<u16>(0b1111_1111);
assert_eq![0, b.unset_all().0];

Source §

impl Bitwise<u16>

§Flip ops for `u16`.

Source

pub const fn flip(self, nth: u32) -> Self

Flips the nth bit.

§Panics

Panics in debug mode if `nth >= BITS.

§Examples

let b = Bitwise::<u16>(0b0000_0001);
assert_eq![0, b.flip(0).0];

Source

pub const fn flip_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

Flips the nth bit.

§Errors

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u16>(0b0000_0001);
assert_eq![0, b.flip_checked(0).unwrap().0];

Source

pub const fn flip_range(self, start: u32, end: u32) -> Self

Flips the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range(4, 7).0];

Source

pub const fn flip_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Flips the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range_checked(4, 7).unwrap().0];

Source

pub const fn flip_range_if(self, start: u32, end: u32, cond: bool) -> Self

Conditionally flips bits in a range if cond is true.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if(4, 7, false).0];

Source

pub const fn flip_range_if_checked( self, start: u32, end: u32, cond: bool, ) -> Result<Self, MismatchedBounds> ⓘ

Conditionally flips bits in a range if cond is true.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if_checked(4, 7, false).unwrap().0];

Source §

impl Bitwise<u16>

§Reverse ops for `u16`.

Source

pub const fn reverse_range(self, start: u32, end: u32) -> Self

Reverses the order of the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u16>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range(1, 4).0];

Source

pub const fn reverse_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Reverses the order of the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1011_0110);
assert_eq![1, b.count_zeros_range_checked(1, 4).unwrap()];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u16>(0b1110_1111);
assert_eq![Some(4), b.find_last_zero_range_checked(0, 7).unwrap()];

Source §

impl Bitwise<u32>

§Implementations for `u32`.

§Constants and mask constructors for `u32`.

Source

pub const BITS: u32 = u32::BITS

The size in bits.

Source

pub const fn mask_range(start: u32, end: u32) -> Self

Returns a bitmask of ones from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u32>::mask_range(1, 4).0]

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    2.8 ns   163.0 ns
  64    2.0 ns    21.6 ns
  32    2.4 ns    12.1 ns
  16    2.6 ns     7.6 ns
   8    2.9 ns     8.4 ns

Source

pub const fn mask_range_checked( start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Returns a bitmask of ones from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u32>::mask_range_checked(1, 4).unwrap().0];

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    3.7 ns   145.0 ns
  64    3.2 ns    38.2 ns
  32    3.2 ns     9.0 ns
  16    3.2 ns     7.0 ns
   8    3.1 ns     6.7 ns

Source

pub const fn is_set_mask(self, mask: u32) -> bool

Returns true if any bit selected by mask is 1 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert![b.is_set_mask(0b1000_0000)];

Source

pub const fn set_mask(self, mask: u32) -> Self

Sets all bits selected by mask to 1.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b1010_1111, b.set_mask(0b0000_1111).0];

Source

pub const fn is_unset_mask(self, mask: u32) -> bool

Returns true if all bits selected by mask are 0 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert![b.is_unset_mask(0b0100_0000)];

Source

pub const fn unset_mask(self, mask: u32) -> Self

Sets all bits selected by mask to 0.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_mask(0b1000_0000).0];

Source §

impl Bitwise<u32>

§Get methods for `u32`.

Source

pub const fn get_range(self, start: u32, end: u32) -> Self

Gets the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range(1, 4).0];

Source

pub const fn get_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range_checked(1, 4).unwrap().0];

Source

pub const fn get_value_range(self, start: u32, end: u32) -> Self

Gets the value of the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1011_0110);
assert_eq![0b1011, b.get_value_range(1, 4).0];

Source

pub const fn get_value_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the value of the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1011_0110);
assert_eq![0b1011, b.get_value_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u32>(0);
assert_eq![0b0000_1000, b.set_checked(3).unwrap().0];

Source

pub const fn is_set_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 1.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b0011_1000);
assert![b.is_set_range(3, 5)];

Source

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 1.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b0011_1000);
assert![b.is_set_range_checked(3, 5).unwrap()];

Source

pub const fn set_range(self, start: u32, end: u32) -> Self

Sets the bits in self to 1, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1000_0001);
assert_eq![0b1001_1111, b.set_range(1, 4).0];

Sets the given value into the bits from the [start..=end] range.

Leaves the rest of the bits unchanged.

The value is first masked to fit the size of the range, and then it is inserted into the specified bit range of self, replacing the existing bits in that range. The rest of the bits in self remain unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range(0b101, 1, 3).0];

Source

pub const fn set_value_range_checked( self, value: u32, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range_checked(0b101, 1, 3).unwrap().0];

Source

pub const fn set_value_range_checked_strict( self, value: u32, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given checked value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

A value fits when it can be represented by end - start + 1 bits.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS, MismatchedIndices if start > end, and MismatchedCapacity if value does not fit within the specified bit range.

§Examples

let b = Bitwise::<u32>(0);
assert![b.set_value_range_checked_strict(0b100, 0, 1).is_err()];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_checked(7).unwrap().0];

Source

pub const fn is_unset_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 0.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1000_0001);
assert![b.is_unset_range(1, 6)];

Source

pub const fn is_unset_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 0.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1000_0001);
assert![b.is_unset_range_checked(1, 6).unwrap()];

Source

pub const fn unset_range(self, start: u32, end: u32) -> Self

Unsets the bits in self to 0, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range(1, 4).0];

Source

pub const fn unset_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Unsets the bits in self to 0, from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range_checked(1, 4).unwrap().0];

Source

pub const fn unset_all(self) -> Self

Unsets all the bits to 0.

§Examples

let b = Bitwise::<u32>(0b1111_1111);
assert_eq![0, b.unset_all().0];

Source §

impl Bitwise<u32>

§Flip ops for `u32`.

Source

pub const fn flip(self, nth: u32) -> Self

Flips the nth bit.

§Panics

Panics in debug mode if `nth >= BITS.

§Examples

let b = Bitwise::<u32>(0b0000_0001);
assert_eq![0, b.flip(0).0];

Source

pub const fn flip_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

Flips the nth bit.

§Errors

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u32>(0b0000_0001);
assert_eq![0, b.flip_checked(0).unwrap().0];

Source

pub const fn flip_range(self, start: u32, end: u32) -> Self

Flips the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range(4, 7).0];

Source

pub const fn flip_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Flips the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range_checked(4, 7).unwrap().0];

Source

pub const fn flip_range_if(self, start: u32, end: u32, cond: bool) -> Self

Conditionally flips bits in a range if cond is true.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if(4, 7, false).0];

Source

pub const fn flip_range_if_checked( self, start: u32, end: u32, cond: bool, ) -> Result<Self, MismatchedBounds> ⓘ

Conditionally flips bits in a range if cond is true.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if_checked(4, 7, false).unwrap().0];

Source §

impl Bitwise<u32>

§Reverse ops for `u32`.

Source

pub const fn reverse_range(self, start: u32, end: u32) -> Self

Reverses the order of the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u32>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range(1, 4).0];

Source

pub const fn reverse_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Reverses the order of the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1011_0110);
assert_eq![1, b.count_zeros_range_checked(1, 4).unwrap()];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u32>(0b1110_1111);
assert_eq![Some(4), b.find_last_zero_range_checked(0, 7).unwrap()];

Source §

impl Bitwise<u64>

§Implementations for `u64`.

§Constants and mask constructors for `u64`.

Source

pub const BITS: u32 = u64::BITS

The size in bits.

Source

pub const fn mask_range(start: u32, end: u32) -> Self

Returns a bitmask of ones from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u64>::mask_range(1, 4).0]

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    2.8 ns   163.0 ns
  64    2.0 ns    21.6 ns
  32    2.4 ns    12.1 ns
  16    2.6 ns     7.6 ns
   8    2.9 ns     8.4 ns

Source

pub const fn mask_range_checked( start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Returns a bitmask of ones from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u64>::mask_range_checked(1, 4).unwrap().0];

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    3.7 ns   145.0 ns
  64    3.2 ns    38.2 ns
  32    3.2 ns     9.0 ns
  16    3.2 ns     7.0 ns
   8    3.1 ns     6.7 ns

Source

pub const fn is_set_mask(self, mask: u64) -> bool

Returns true if any bit selected by mask is 1 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert![b.is_set_mask(0b1000_0000)];

Source

pub const fn set_mask(self, mask: u64) -> Self

Sets all bits selected by mask to 1.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b1010_1111, b.set_mask(0b0000_1111).0];

Source

pub const fn is_unset_mask(self, mask: u64) -> bool

Returns true if all bits selected by mask are 0 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert![b.is_unset_mask(0b0100_0000)];

Source

pub const fn unset_mask(self, mask: u64) -> Self

Sets all bits selected by mask to 0.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_mask(0b1000_0000).0];

Source §

impl Bitwise<u64>

§Get methods for `u64`.

Source

pub const fn get_range(self, start: u32, end: u32) -> Self

Gets the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range(1, 4).0];

Source

pub const fn get_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range_checked(1, 4).unwrap().0];

Source

pub const fn get_value_range(self, start: u32, end: u32) -> Self

Gets the value of the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1011_0110);
assert_eq![0b1011, b.get_value_range(1, 4).0];

Source

pub const fn get_value_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the value of the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1011_0110);
assert_eq![0b1011, b.get_value_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u64>(0);
assert_eq![0b0000_1000, b.set_checked(3).unwrap().0];

Source

pub const fn is_set_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 1.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b0011_1000);
assert![b.is_set_range(3, 5)];

Source

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 1.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b0011_1000);
assert![b.is_set_range_checked(3, 5).unwrap()];

Source

pub const fn set_range(self, start: u32, end: u32) -> Self

Sets the bits in self to 1, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1000_0001);
assert_eq![0b1001_1111, b.set_range(1, 4).0];

Sets the given value into the bits from the [start..=end] range.

Leaves the rest of the bits unchanged.

The value is first masked to fit the size of the range, and then it is inserted into the specified bit range of self, replacing the existing bits in that range. The rest of the bits in self remain unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range(0b101, 1, 3).0];

Source

pub const fn set_value_range_checked( self, value: u64, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range_checked(0b101, 1, 3).unwrap().0];

Source

pub const fn set_value_range_checked_strict( self, value: u64, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given checked value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

A value fits when it can be represented by end - start + 1 bits.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS, MismatchedIndices if start > end, and MismatchedCapacity if value does not fit within the specified bit range.

§Examples

let b = Bitwise::<u64>(0);
assert![b.set_value_range_checked_strict(0b100, 0, 1).is_err()];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_checked(7).unwrap().0];

Source

pub const fn is_unset_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 0.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1000_0001);
assert![b.is_unset_range(1, 6)];

Source

pub const fn is_unset_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 0.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1000_0001);
assert![b.is_unset_range_checked(1, 6).unwrap()];

Source

pub const fn unset_range(self, start: u32, end: u32) -> Self

Unsets the bits in self to 0, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range(1, 4).0];

Source

pub const fn unset_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Unsets the bits in self to 0, from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range_checked(1, 4).unwrap().0];

Source

pub const fn unset_all(self) -> Self

Unsets all the bits to 0.

§Examples

let b = Bitwise::<u64>(0b1111_1111);
assert_eq![0, b.unset_all().0];

Source §

impl Bitwise<u64>

§Flip ops for `u64`.

Source

pub const fn flip(self, nth: u32) -> Self

Flips the nth bit.

§Panics

Panics in debug mode if `nth >= BITS.

§Examples

let b = Bitwise::<u64>(0b0000_0001);
assert_eq![0, b.flip(0).0];

Source

pub const fn flip_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

Flips the nth bit.

§Errors

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u64>(0b0000_0001);
assert_eq![0, b.flip_checked(0).unwrap().0];

Source

pub const fn flip_range(self, start: u32, end: u32) -> Self

Flips the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range(4, 7).0];

Source

pub const fn flip_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Flips the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range_checked(4, 7).unwrap().0];

Source

pub const fn flip_range_if(self, start: u32, end: u32, cond: bool) -> Self

Conditionally flips bits in a range if cond is true.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if(4, 7, false).0];

Source

pub const fn flip_range_if_checked( self, start: u32, end: u32, cond: bool, ) -> Result<Self, MismatchedBounds> ⓘ

Conditionally flips bits in a range if cond is true.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if_checked(4, 7, false).unwrap().0];

Source §

impl Bitwise<u64>

§Reverse ops for `u64`.

Source

pub const fn reverse_range(self, start: u32, end: u32) -> Self

Reverses the order of the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u64>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range(1, 4).0];

Source

pub const fn reverse_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Reverses the order of the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1011_0110);
assert_eq![1, b.count_zeros_range_checked(1, 4).unwrap()];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u64>(0b1110_1111);
assert_eq![Some(4), b.find_last_zero_range_checked(0, 7).unwrap()];

Source §

impl Bitwise<u128>

§Implementations for `u128`.

§Constants and mask constructors for `u128`.

Source

pub const BITS: u32 = u128::BITS

The size in bits.

Source

pub const fn mask_range(start: u32, end: u32) -> Self

Returns a bitmask of ones from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u128>::mask_range(1, 4).0]

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    2.8 ns   163.0 ns
  64    2.0 ns    21.6 ns
  32    2.4 ns    12.1 ns
  16    2.6 ns     7.6 ns
   8    2.9 ns     8.4 ns

Source

pub const fn mask_range_checked( start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Returns a bitmask of ones from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<u128>::mask_range_checked(1, 4).unwrap().0];

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    3.7 ns   145.0 ns
  64    3.2 ns    38.2 ns
  32    3.2 ns     9.0 ns
  16    3.2 ns     7.0 ns
   8    3.1 ns     6.7 ns

Source

pub const fn is_set_mask(self, mask: u128) -> bool

Returns true if any bit selected by mask is 1 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert![b.is_set_mask(0b1000_0000)];

Source

pub const fn set_mask(self, mask: u128) -> Self

Sets all bits selected by mask to 1.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b1010_1111, b.set_mask(0b0000_1111).0];

Source

pub const fn is_unset_mask(self, mask: u128) -> bool

Returns true if all bits selected by mask are 0 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert![b.is_unset_mask(0b0100_0000)];

Source

pub const fn unset_mask(self, mask: u128) -> Self

Sets all bits selected by mask to 0.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_mask(0b1000_0000).0];

Source §

impl Bitwise<u128>

§Get methods for `u128`.

Source

pub const fn get_range(self, start: u32, end: u32) -> Self

Gets the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range(1, 4).0];

Source

pub const fn get_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range_checked(1, 4).unwrap().0];

Source

pub const fn get_value_range(self, start: u32, end: u32) -> Self

Gets the value of the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1011_0110);
assert_eq![0b1011, b.get_value_range(1, 4).0];

Source

pub const fn get_value_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the value of the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1011_0110);
assert_eq![0b1011, b.get_value_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u128>(0);
assert_eq![0b0000_1000, b.set_checked(3).unwrap().0];

Source

pub const fn is_set_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 1.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b0011_1000);
assert![b.is_set_range(3, 5)];

Source

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 1.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b0011_1000);
assert![b.is_set_range_checked(3, 5).unwrap()];

Source

pub const fn set_range(self, start: u32, end: u32) -> Self

Sets the bits in self to 1, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1000_0001);
assert_eq![0b1001_1111, b.set_range(1, 4).0];

Sets the given value into the bits from the [start..=end] range.

Leaves the rest of the bits unchanged.

The value is first masked to fit the size of the range, and then it is inserted into the specified bit range of self, replacing the existing bits in that range. The rest of the bits in self remain unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range(0b101, 1, 3).0];

Source

pub const fn set_value_range_checked( self, value: u128, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range_checked(0b101, 1, 3).unwrap().0];

Source

pub const fn set_value_range_checked_strict( self, value: u128, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given checked value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

A value fits when it can be represented by end - start + 1 bits.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS, MismatchedIndices if start > end, and MismatchedCapacity if value does not fit within the specified bit range.

§Examples

let b = Bitwise::<u128>(0);
assert![b.set_value_range_checked_strict(0b100, 0, 1).is_err()];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_checked(7).unwrap().0];

Source

pub const fn is_unset_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 0.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1000_0001);
assert![b.is_unset_range(1, 6)];

Source

pub const fn is_unset_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 0.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1000_0001);
assert![b.is_unset_range_checked(1, 6).unwrap()];

Source

pub const fn unset_range(self, start: u32, end: u32) -> Self

Unsets the bits in self to 0, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range(1, 4).0];

Source

pub const fn unset_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Unsets the bits in self to 0, from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range_checked(1, 4).unwrap().0];

Source

pub const fn unset_all(self) -> Self

Unsets all the bits to 0.

§Examples

let b = Bitwise::<u128>(0b1111_1111);
assert_eq![0, b.unset_all().0];

Source §

impl Bitwise<u128>

§Flip ops for `u128`.

Source

pub const fn flip(self, nth: u32) -> Self

Flips the nth bit.

§Panics

Panics in debug mode if `nth >= BITS.

§Examples

let b = Bitwise::<u128>(0b0000_0001);
assert_eq![0, b.flip(0).0];

Source

pub const fn flip_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

Flips the nth bit.

§Errors

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<u128>(0b0000_0001);
assert_eq![0, b.flip_checked(0).unwrap().0];

Source

pub const fn flip_range(self, start: u32, end: u32) -> Self

Flips the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range(4, 7).0];

Source

pub const fn flip_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Flips the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range_checked(4, 7).unwrap().0];

Source

pub const fn flip_range_if(self, start: u32, end: u32, cond: bool) -> Self

Conditionally flips bits in a range if cond is true.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if(4, 7, false).0];

Source

pub const fn flip_range_if_checked( self, start: u32, end: u32, cond: bool, ) -> Result<Self, MismatchedBounds> ⓘ

Conditionally flips bits in a range if cond is true.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if_checked(4, 7, false).unwrap().0];

Source §

impl Bitwise<u128>

§Reverse ops for `u128`.

Source

pub const fn reverse_range(self, start: u32, end: u32) -> Self

Reverses the order of the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<u128>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range(1, 4).0];

Source

pub const fn reverse_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Reverses the order of the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1011_0110);
assert_eq![1, b.count_zeros_range_checked(1, 4).unwrap()];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<u128>(0b1110_1111);
assert_eq![Some(4), b.find_last_zero_range_checked(0, 7).unwrap()];

Source §

impl Bitwise<usize>

§Implementations for `usize`.

§Constants and mask constructors for `usize`.

Source

pub const BITS: u32 = usize::BITS

The size in bits.

Source

pub const fn mask_range(start: u32, end: u32) -> Self

Returns a bitmask of ones from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<usize>::mask_range(1, 4).0]

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    2.8 ns   163.0 ns
  64    2.0 ns    21.6 ns
  32    2.4 ns    12.1 ns
  16    2.6 ns     7.6 ns
   8    2.9 ns     8.4 ns

Source

pub const fn mask_range_checked( start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Returns a bitmask of ones from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

assert_eq![0b0001_1110, Bitwise::<usize>::mask_range_checked(1, 4).unwrap().0];

§Benchmarks

The current algorithm used can be more than 1 order of magnitude more efficient than a naive loop that sets the individual bits, as well as much more consistant across the spectrum of bitsizes.

The following table shows the compared benchmark for start=0 and end=BITS-1 measured on an i5-8350U CPU @ 1.70 Ghz:

bits   current    naive
----   -------   --------
 128    3.7 ns   145.0 ns
  64    3.2 ns    38.2 ns
  32    3.2 ns     9.0 ns
  16    3.2 ns     7.0 ns
   8    3.1 ns     6.7 ns

Source

pub const fn is_set_mask(self, mask: usize) -> bool

Returns true if any bit selected by mask is 1 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert![b.is_set_mask(0b1000_0000)];

Source

pub const fn set_mask(self, mask: usize) -> Self

Sets all bits selected by mask to 1.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b1010_1111, b.set_mask(0b0000_1111).0];

Source

pub const fn is_unset_mask(self, mask: usize) -> bool

Returns true if all bits selected by mask are 0 in self.

Bits not included in mask are ignored.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert![b.is_unset_mask(0b0100_0000)];

Source

pub const fn unset_mask(self, mask: usize) -> Self

Sets all bits selected by mask to 0.

Bits not included in mask are left unchanged.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_mask(0b1000_0000).0];

Source §

impl Bitwise<usize>

§Get methods for `usize`.

Source

pub const fn get_range(self, start: u32, end: u32) -> Self

Gets the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range(1, 4).0];

Source

pub const fn get_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1011_0110);
assert_eq![0b0001_0110, b.get_range_checked(1, 4).unwrap().0];

Source

pub const fn get_value_range(self, start: u32, end: u32) -> Self

Gets the value of the bits in self from the [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1011_0110);
assert_eq![0b1011, b.get_value_range(1, 4).0];

Source

pub const fn get_value_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Gets the value of the bits in self from the checked [start..=end] range.

Sets the rest of the bits to 0.

The bits in the specified range are shifted rightwards so that the least significant bit (LSB) aligns with the units place, forming the integer value.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1011_0110);
assert_eq![0b1011, b.get_value_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<usize>(0);
assert_eq![0b0000_1000, b.set_checked(3).unwrap().0];

Source

pub const fn is_set_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 1.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b0011_1000);
assert![b.is_set_range(3, 5)];

Source

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 1.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b0011_1000);
assert![b.is_set_range_checked(3, 5).unwrap()];

Source

pub const fn set_range(self, start: u32, end: u32) -> Self

Sets the bits in self to 1, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1000_0001);
assert_eq![0b1001_1111, b.set_range(1, 4).0];

Sets the given value into the bits from the [start..=end] range.

Leaves the rest of the bits unchanged.

The value is first masked to fit the size of the range, and then it is inserted into the specified bit range of self, replacing the existing bits in that range. The rest of the bits in self remain unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range(0b101, 1, 3).0];

Source

pub const fn set_value_range_checked( self, value: usize, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1000_0001);
assert_eq![0b1000_1011, b.set_value_range_checked(0b101, 1, 3).unwrap().0];

Source

pub const fn set_value_range_checked_strict( self, value: usize, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Sets the given checked value into the bits from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

A value fits when it can be represented by end - start + 1 bits.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS, MismatchedIndices if start > end, and MismatchedCapacity if value does not fit within the specified bit range.

§Examples

let b = Bitwise::<usize>(0);
assert![b.set_value_range_checked_strict(0b100, 0, 1).is_err()];

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b0010_0000, b.unset_checked(7).unwrap().0];

Source

pub const fn is_unset_range(self, start: u32, end: u32) -> bool

Returns true if all bits in the [start..=end] range are 0.

Bits outside the range are ignored.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1000_0001);
assert![b.is_unset_range(1, 6)];

Source

pub const fn is_unset_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

Returns true if all bits in the checked [start..=end] range are 0.

Bits outside the range are ignored.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1000_0001);
assert![b.is_unset_range_checked(1, 6).unwrap()];

Source

pub const fn unset_range(self, start: u32, end: u32) -> Self

Unsets the bits in self to 0, from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range(1, 4).0];

Source

pub const fn unset_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Unsets the bits in self to 0, from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1111_1111);
assert_eq![0b1110_0001, b.unset_range_checked(1, 4).unwrap().0];

Source

pub const fn unset_all(self) -> Self

Unsets all the bits to 0.

§Examples

let b = Bitwise::<usize>(0b1111_1111);
assert_eq![0, b.unset_all().0];

Source §

impl Bitwise<usize>

§Flip ops for `usize`.

Source

pub const fn flip(self, nth: u32) -> Self

Flips the nth bit.

§Panics

Panics in debug mode if `nth >= BITS.

§Examples

let b = Bitwise::<usize>(0b0000_0001);
assert_eq![0, b.flip(0).0];

Source

pub const fn flip_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

Flips the nth bit.

§Errors

Returns IndexOutOfBounds if nth >= BITS.

§Examples

let b = Bitwise::<usize>(0b0000_0001);
assert_eq![0, b.flip_checked(0).unwrap().0];

Source

pub const fn flip_range(self, start: u32, end: u32) -> Self

Flips the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range(4, 7).0];

Source

pub const fn flip_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Flips the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b0101_0000, b.flip_range_checked(4, 7).unwrap().0];

Source

pub const fn flip_range_if(self, start: u32, end: u32, cond: bool) -> Self

Conditionally flips bits in a range if cond is true.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if(4, 7, false).0];

Source

pub const fn flip_range_if_checked( self, start: u32, end: u32, cond: bool, ) -> Result<Self, MismatchedBounds> ⓘ

Conditionally flips bits in a range if cond is true.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1010_0000);
assert_eq![0b1010_0000, b.flip_range_if_checked(4, 7, false).unwrap().0];

Source §

impl Bitwise<usize>

§Reverse ops for `usize`.

Source

pub const fn reverse_range(self, start: u32, end: u32) -> Self

Reverses the order of the bits in self from the [start..=end] range.

Leaves the rest of the bits unchanged.

§Panics

Panics in debug mode if start >= BITS || end >= BITS || start > end.

§Examples

let b = Bitwise::<usize>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range(1, 4).0];

Source

pub const fn reverse_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

Reverses the order of the bits in self from the checked [start..=end] range.

Leaves the rest of the bits unchanged.

§Errors

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b0001_0110);
assert_eq![0b0001_1010, b.reverse_range_checked(1, 4).unwrap().0];

Returns IndexOutOfBounds if start >= BITS || end >= BITS and MismatchedIndices if start > end.

§Examples

let b = Bitwise::<usize>(0b1011_0110);
assert_eq![1, b.count_zeros_range_checked(1, 4).unwrap()];

impl<T: Clone> Clone for Bitwise<T>

Source §

fn clone(&self) -> Self

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Source §

Source §

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

Source §

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 (const: unstable) · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 (const: unstable) · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

impl<T> UpperExp for Bitwise<T>
where T: UpperExp,

Source §

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult<()>

Formats the value using the given formatter. Read more

Source §

impl<T> UpperHex for Bitwise<T>
where T: UpperHex,

Source §

The size of this type in bytes.

Source §

fn byte_align(&self) -> usize

Returns the alignment of this type in bytes.

Source §

fn byte_size(&self) -> usize

Returns the size of this type in bytes. Read more

Source §

fn ptr_size_ratio(&self) -> [usize; 2]

Returns the size ratio between Ptr::BYTES and BYTE_SIZE. Read more

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T> Hook for T

Source §

fn hook<F>(self, f: F) -> Self
where F: FnOnce(&mut Self),

Hooks a mutation step into the value and returns it. Read more

Source §

fn tap<F>(self, f: F) -> Self
where F: FnOnce(&Self),

Taps into the value for observation and returns it unchanged. Read more

Source §

fn morph<F>(self, f: F) -> R
where F: FnOnce(Self) -> R, Self: Sized,

Morphs the value into a new one and returns it. Read more

Source §

fn morph_ref<F>(&self, f: F) -> R
where F: FnOnce(&Self) -> R,

Morphs the value by shared reference and returns the result. Read more

Source §

fn morph_mut<F>(&mut self, f: F) -> R
where F: FnOnce(&mut Self) -> R,

Morphs the value by exclusive reference and returns the result. Read more

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error> ⓘ

Performs the conversion.

Struct Bitwise Copy item path

§Panic behavior

§Related items

§Methods

Tuple Fields§

Implementations§

impl Bitwise<u8>

§Implementations for u8.

§Constants and mask constructors for u8.

pub const BITS: u32 = u8::BITS

pub const fn mask_range(start: u32, end: u32) -> Self

§Panics

§Examples

§Benchmarks

pub const fn mask_range_checked( start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

§Benchmarks

pub const fn is_set_mask(self, mask: u8) -> bool

§Examples

pub const fn set_mask(self, mask: u8) -> Self

§Examples

pub const fn is_unset_mask(self, mask: u8) -> bool

§Examples

pub const fn unset_mask(self, mask: u8) -> Self

§Examples

impl Bitwise<u8>

§Get methods for u8.

pub const fn get_range(self, start: u32, end: u32) -> Self

§Panics

§Examples

pub const fn get_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

pub const fn get_value_range(self, start: u32, end: u32) -> Self

§Panics

§Examples

pub const fn get_value_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

impl Bitwise<u8>

§Set ops for u8.

pub const fn is_set(self, nth: u32) -> bool

§Panics

§Examples

pub const fn is_set_checked(self, nth: u32) -> Result<bool, MismatchedBounds> ⓘ

§Errors

§Examples

pub const fn set(self, nth: u32) -> Self

§Panics

§Examples

pub const fn set_checked(self, nth: u32) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

pub const fn is_set_range(self, start: u32, end: u32) -> bool

§Panics

§Examples

pub const fn is_set_range_checked( self, start: u32, end: u32, ) -> Result<bool, MismatchedBounds> ⓘ

§Errors

§Examples

pub const fn set_range(self, start: u32, end: u32) -> Self

§Panics

§Examples

pub const fn set_range_checked( self, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

pub const fn set_all(self) -> Self

§Examples

pub const fn set_value_range(self, value: u8, start: u32, end: u32) -> Self

§Panics

§Examples

pub const fn set_value_range_checked( self, value: u8, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

pub const fn set_value_range_checked_strict( self, value: u8, start: u32, end: u32, ) -> Result<Self, MismatchedBounds> ⓘ

§Errors

§Examples

impl Bitwise<u8>

§Unset ops for u8.

pub const fn is_unset(self, nth: u32) -> bool

Struct Bitwise

§Implementations for `u8`.

§Constants and mask constructors for `u8`.

§Get methods for `u8`.

§Set ops for `u8`.

§Unset ops for `u8`.

§Flip ops for `u8`.

§Reverse ops for `u8`.

§Count ops for `u8`.