Crate bitit 

Bitit

A library for bitwise iteration over Rust integers.

Provides simple and efficient iterators for binary integer types.

Examples

use bitit::BitIter;

let x = 0b10101100u8;

// Iterating each bit:
let mut bits = x.bits();
assert_eq!(bits.next(), Some(false));
assert_eq!(bits.next(), Some(false));
assert_eq!(bits.next(), Some(true));

// Or just the ones:
let mut ones = x.ones();
assert_eq!(ones.next(), Some(0b00000100u8));
assert_eq!(ones.next(), Some(0b00001000u8));
assert_eq!(ones.next_back(), Some(0b10000000u8));

// Or the zeros, even with indices:
let mut zero_indices = x.zero_indices();
assert_eq!(zero_indices.next(), Some(0));
assert_eq!(zero_indices.next(), Some(1));
assert_eq!(zero_indices.next_back(), Some(6));

// Works with floats too like this:
let f = -5.0f64;
let mut ieee_bits = f.to_bits().bits_rev();

// Now we can see its bits, such as the sign bit:
if ieee_bits.next() == Some(true) {
    println!("{f} is negative.");
} else {
    println!("{f} is positive.");
}

cargo run -q
-5 is negative.

Features

Bitit provides the following iterators with the BitIter trait:

• Iterating ones from least to most significant with BitIter::ones
• Iterating zeros from least to most significant with BitIter::zeros
• Iterating the bitwise indices of all ones with BitIter::one_indices
• Iterating the bitwise indices of all zeros with BitIter::zero_indices
• Iterating all bits as booleans from least to most significant with BitIter::bits
• Iterating all bits as booleans from most to least significant with BitIter::bits_rev
• The ability to reverse all iterators (except BitIter::bits which has BitIter::bits_rev) with Iterator::rev

The BitIter trait is implemented for all signed and unsigned primitive integers i8, u8, i16, etc. as well as usize and isize.

Structs

Bits

An iterator over the bits in a value. Represents each bit from least significant to most significant as a boolean.

BitsRev

An iterator over the bits in a value in reverse. Represents each bit from most significant to lease significant as a boolean.

OneIndices

An iterator over the indices of the 1-bits in a binary value.

Ones

An iterator over the 1-bits in a binary value. Represents each bit as a single-bit mask.

ZeroIndices

An iterator over the indices of the 0-bits in a binary value.

Zeros

An iterator over the 0-bits in a binary value. Represents each bit as a single-bit mask.

Traits

BitIter

A trait for easy access of bitit iterators.