BitArrayView{V, N, T} <: AbstractArray{V, N}

View an object of type T as an AbstractArray{V, N} where V is the eltype and N the number of dimensions.

bitmatview([::Type{V} = Bool], str, [ncols::Integer = isqrt(bitlength(str))]; kwargs...)

Return a view of the bitstring str as a matrix, a BitMatrixView{V, T} <: AbstractMatrix{T}.

If ncols is supplied, the number of rows will be the largest compatible with the length of str. On construction str will be validated as a bitstring. If the keyword arg check=false is passed, then no such check is made.

bitvecview([::Type{T} = Bool], str::AbstractString; check=true)

Return a view of the bitstring str as an AbstractVector{T}.

No data is copied. If check is true, then str is validated upon construction. A valid str must consist of only '0' and '1'. Passing false for check with invalid str will likely give incorrect results, silently.

If you instead convert str to Vector{Bool}, construction may take longer, but accessing will be faster. So bitvecview might be more useful if you want to do only a few operations.

To convert str to a Vector{T} call collect or copy on the returned view of str. Likewise Tuple and BitVector can be used to convert to the corresponding types.

is_little_endian(bv::BitArrayView)

Return true if the bits in the representation bv of parent(bv), where the latter is a bitsttype, have the least significant bit at index 1.

For other wrapped types, such as String, return true if the indexing is not reversed.

Chunks{T<:Unsigned}

Chunks is a wrapper used to pass data to constructors of AbstractBitArray that is intended to be used directly as "chunks". If an un-wrapped array is passed it is assumed to be interpreted as an array of Bools.

People have discussed constructing Base.BitArray by passing chunks. Something like Chunk would be useful there, to distinguish clearly from existing methods.

get_one_bit_masks(::Type{uint_type})

Return an array of all single bit (powers of two) masks for uint_type.

Masks are generated when BitsX is compiled. If masks are not available for a type, then the sentinel nothing is returned. This signifies that a routine that does not require masks should be used.

min_uint_bit_width(nbits::Integer)

Return the minimum width in bits of the unsigned integer needed to represent nbits bits. The widths are restricted to multiples of eight.

min_uint_byte_width(n_bits::Integer)

Return the minimum width in bytes of the unsigned integer needed to represent nbits bits. The widths are restricted to multiples of eight.

min_uint_type(nbits::Integer)

Return the smallest unsigned integer type large enough to store nbits bits. The number of bits in the type returned is a multiple of 8.

uint_type(n_bits::Integer)

Return an n_bits-bit unsigned integers type UIntn_bits. n_bits must be a positive mulitple of 8.

If UIntn does not exist, construct UIntn and Intn.

uint_type_bytes(n_bytes::Integer)

Return an n_bytes-byte unsigned integer type.

The returned type is named UIntX where X = 8 * n_bytes. If UIntX does not exist construct UIntX and IntX.