Trait malachite_base::num::logic::traits::BitIterable

pub trait BitIterable {
    type BitIterator: DoubleEndedIterator<Item = bool> + Index<u64>;

    // Required method
    fn bits(self) -> Self::BitIterator;
}

Defines an iterator over a value’s bits.

Required Associated Types

type BitIterator: DoubleEndedIterator<Item = bool> + Index<u64>

Required Methods

fn bits(self) -> Self::BitIterator

Returns a double-ended iterator over a number’s bits. When iterating in the forward direction, the iterator ends after the producing the number’s most-significant bit.

Implementations on Foreign Types

impl BitIterable for i8

fn bits(self) -> PrimitiveSignedBitIterator<u8, i8>

Returns a double-ended iterator over the bits of a signed primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing sign bits going forward, or leading sign bits going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveSignedBitIterator<u8, i8>

impl BitIterable for i16

fn bits(self) -> PrimitiveSignedBitIterator<u16, i16>

Returns a double-ended iterator over the bits of a signed primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing sign bits going forward, or leading sign bits going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveSignedBitIterator<u16, i16>

impl BitIterable for i32

fn bits(self) -> PrimitiveSignedBitIterator<u32, i32>

Returns a double-ended iterator over the bits of a signed primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing sign bits going forward, or leading sign bits going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveSignedBitIterator<u32, i32>

impl BitIterable for i64

fn bits(self) -> PrimitiveSignedBitIterator<u64, i64>

Returns a double-ended iterator over the bits of a signed primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing sign bits going forward, or leading sign bits going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveSignedBitIterator<u64, i64>

impl BitIterable for i128

fn bits(self) -> PrimitiveSignedBitIterator<u128, i128>

Returns a double-ended iterator over the bits of a signed primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing sign bits going forward, or leading sign bits going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveSignedBitIterator<u128, i128>

impl BitIterable for isize

fn bits(self) -> PrimitiveSignedBitIterator<usize, isize>

Returns a double-ended iterator over the bits of a signed primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing sign bits going forward, or leading sign bits going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveSignedBitIterator<usize, isize>

impl BitIterable for u8

fn bits(self) -> PrimitiveUnsignedBitIterator<u8>

Returns a double-ended iterator over the bits of an unsigned primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveUnsignedBitIterator<u8>

impl BitIterable for u16

fn bits(self) -> PrimitiveUnsignedBitIterator<u16>

Returns a double-ended iterator over the bits of an unsigned primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveUnsignedBitIterator<u16>

impl BitIterable for u32

fn bits(self) -> PrimitiveUnsignedBitIterator<u32>

Returns a double-ended iterator over the bits of an unsigned primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveUnsignedBitIterator<u32>

impl BitIterable for u64

fn bits(self) -> PrimitiveUnsignedBitIterator<u64>

Returns a double-ended iterator over the bits of an unsigned primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveUnsignedBitIterator<u64>

impl BitIterable for u128

fn bits(self) -> PrimitiveUnsignedBitIterator<u128>

Returns a double-ended iterator over the bits of an unsigned primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveUnsignedBitIterator<u128>

impl BitIterable for usize

fn bits(self) -> PrimitiveUnsignedBitIterator<usize>

Returns a double-ended iterator over the bits of an unsigned primitive integer.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a [Vec] of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type BitIterator = PrimitiveUnsignedBitIterator<usize>

Implementors