BitBasis

Types and operations for basis represented by bits in linear algebra.

For more details please ref to BitBasis.jl.

BitBasis.@bit_strMacro
@bit_str -> BitStr64

Construct a bit string. such as bit"0000". The bit strings also supports string bcat. Just use it like normal strings.

Example

julia> bit"10001"
10001 ₍₂₎

julia> bit"100_111_101"
100111101 ₍₂₎

julia> bcat(bit"1001", bit"11", bit"1110")
1001111110 ₍₂₎

julia> onehot(bit"1001")
16-element Array{Float64,1}:
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 1.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
BitBasis.@lbit_strMacro
@bit_str -> LongBitStr

Long bit string version of @bit_str macro.

BitBasis.alloneMethod
allone(index::Integer, mask::Integer) -> Bool

Return true if all masked position of index is 1.

Example

true if all masked positions are 1.

julia> allone(0b1011, 0b1011)
true

julia> allone(0b1011, 0b1001)
true

julia> allone(0b1011, 0b0100)
false
BitBasis.anyoneMethod
anyone(index::Integer, mask::Integer) -> Bool

Return true if any masked position of index is 1.

Example

true if any masked positions is 1.

julia> anyone(0b1011, 0b1001)
true

julia> anyone(0b1011, 0b1100)
true

julia> anyone(0b1011, 0b0100)
false
BitBasis.baddrsMethod
baddrs(b::Integer) -> Vector

get the locations of nonzeros bits, i.e. the inverse operation of bmask.

BitBasis.basisMethod
basis([IntType], nbits::Int) -> UnitRange{IntType}
basis([IntType], state::AbstractArray) -> UnitRange{IntType}

Returns the UnitRange for basis in Hilbert Space of nbits qubits. If an array is supplied, it will return a basis having the same size with the first diemension of array.

BitBasis.bdistanceMethod
bdistance(i::Integer, j::Integer) -> Int

Return number of different bits.

BitBasis.bfloat_rMethod
bfloat_r(b::Integer; nbits::Int=bit_length(b)) -> Float64

float view, with reversed bit numbering. See also bfloat.

BitBasis.bint_rMethod
bint_r(b; nbits::Int) -> Integer

integer read in inverse order.

BitBasis.bit_lengthMethod
bit_length(x::Integer) -> Int

Return the number of bits required to represent input integer x.

BitBasis.bit_literalMethod
bit_literal(xs...)

Create a BitStr by input bits xs.

Example

julia> bit_literal(1, 0, 1, 0, 1, 1)
110101 ₍₂₎
BitBasis.bitarrayMethod
bitarray(v::Vector, [nbits::Int]) -> BitArray
bitarray(v::Int, nbits::Int) -> BitArray
bitarray(nbits::Int) -> Function

Construct BitArray from an integer vector, if nbits not supplied, it is 64. If an integer is supplied, it returns a function mapping a Vector/Int to bitarray.

BitBasis.bmaskFunction
bmask(::Type{T}) where T <: Integer -> zero(T)
bmask([T::Type], positions::Int...) -> T
bmask([T::Type], range::UnitRange{Int}) -> T

Return an integer mask of type T where 1 is the position masked according to positions or range. Directly use T will return an empty mask 0.

BitBasis.breflectFunction
breflect(b::Integer[, masks::Vector{Integer}]; nbits) -> Integer

Return left-right reflected integer.

Example

Reflect the order of bits.

julia> breflect(0b1011; nbits=4) == 0b1101
true
BitBasis.breflectMethod
breflect(bit_str[, masks])

Return left-right reflected bit string.

BitBasis.bsizeofMethod
bsizeof(::Type)

Returns the size of given type in number of binary digits.

BitBasis.controldoMethod
controldo(f, itr::IterControl)

Execute f while iterating itr.

Note

this is faster but equivalent than using itr as an iterator. See also itercontrol.

BitBasis.controllerMethod
controller(cbits, cvals) -> Function

Return a function that checks whether a basis at cbits takes specific value cvals.

BitBasis.flipMethod
flip(index::Integer, mask::Integer) -> Integer

Return an Integer with bits at masked position flipped.

Example

julia> flip(0b1011, 0b1011) |> bit(len=4)
0000 (0)
BitBasis.hypercubicMethod
hypercubic(A::Array) -> Array

get the hypercubic representation for an array.

BitBasis.indices_withMethod
indices_with(n::Int, locs::Vector{Int}, vals::Vector{Int}) -> Vector{Int}

Return indices with specific positions locs with value vals in a hilbert space of n qubits.

BitBasis.invorderMethod
invorder(X::AbstractVecOrMat)

Inverse the order of given vector/matrix X.

BitBasis.ismatchMethod
ismatch(index::Integer, mask::Integer, target::Integer) -> Bool

Return true if bits at positions masked by mask equal to 1 are equal to target.

Example

julia> n = 0b11001; mask = 0b10100; target = 0b10000;

julia> ismatch(n, mask, target)
true
BitBasis.log2dim1Method
log2dim1(X)

Returns the log2 of the first dimension's size.

BitBasis.log2iFunction
log2i(x::Integer) -> Integer

Return log2(x), this integer version of log2 is fast but only valid for number equal to 2^n.

BitBasis.negMethod
neg(index::Integer, nbits::Int) -> Integer

Return an integer with all bits flipped (with total number of bit nbits).

Example

julia> neg(0b1111, 4) |> bit(len=4)
0000 (0)

julia> neg(0b0111, 4) |> bit(len=4)
1000 (8)
BitBasis.onehotMethod
onehot([T=Float64], bit_str[, nbatch])

Returns an onehot vector in type Vector{T}, or a batch of onehot vector in type Matrix{T}, where the bit_str-th element is one.

BitBasis.onehotMethod
onehot([T=Float64], nbits, x::Integer; nbatch::Int])

Create an onehot vector in type Vector{T} or a batch of onehot vector in type Matrix{T}, where index x + 1 is one.

BitBasis.packbitsMethod
packbits(arr::AbstractArray) -> AbstractArray

pack bits to integers, usually take a BitArray as input.

BitBasis.readbitMethod
readbit(x, loc...)

Read the bit config at given location.

BitBasis.reorderFunction
reorder(X::AbstractArray, orders)

Reorder X according to orders.

Tip

Although orders can be any iterable, Tuple is preferred inorder to gain as much performance as possible. But the conversion won't take much anyway.

BitBasis.setbitMethod
setbit(index::Integer, mask::Integer) -> Integer

set the bit at masked position to 1.

Example

julia> setbit(0b1011, 0b1100) |> bit(len=4)
1111 (15)

julia> setbit(0b1011, 0b0100) |> bit(len=4)
1111 (15)

julia> setbit(0b1011, 0b0000) |> bit(len=4)
1011 (11)
BitBasis.swapbitsMethod
swapbits(n::Integer, mask_ij::Integer) -> Integer
swapbits(n::Integer, i::Int, j::Int) -> Integer

Return an integer with bits at i and j flipped.

Example

julia> swapbits(0b1011, 0b1100) == 0b0111
true
Tip

locations i and j specified by mask could be faster when bmask is not straight forward but known by constant.

Warning

mask_ij should only contain two 1, swapbits will not check it, use at your own risk.

BitBasis.BitStrType
BitStr{N,T} <: Integer

struct for bit string with fixed length N, the storage type is T.

BitStr{N,T}(value)
BitStr64{N}(value)
LongBitStr{N}(value)

Returns a BitStr.

Example

BitStr supports some basic arithmetic operations. It acts like an integer, but supports some frequently used methods for binary basis.

julia> bit"0101" * 2
1010 ₍₂₎

julia> bcat(bit"101" for i in 1:10)
101101101101101101101101101101 (766958445)

julia> repeat(bit"101", 2)
101101 ₍₂₎

julia> bit"1101"[2]
0
BitBasis.IterControlType
IterControl{S}
IterControl(n::Int, base::Int, masks, ks) -> IterControl

Iterator to iterate through controlled subspace. See also itercontrol. S is the number of shifts, n is the size of Hilbert space, base is the base of counter, masks and ks are helpers for enumerating over the target Hilbert Space.

BitBasis.ReorderedBasisMethod
ReorderedBasis(orders::NTuple{N, <:Integer})

Returns a lazy set of reordered basis.

BitBasis.unsafe_reorderFunction
unsafe_reorder(X::AbstractArray, orders)

Reorder X according to orders.

Warning

unsafe_reorder won't check whether the length of orders and the size of first dimension of X match, use at your own risk.

BitBasis.unsafe_subMethod
unsafe_sub(a::UnitRange, b::NTuple{N}) -> NTuple{N}

Returns result in type Tuple of a .- b. This will not check the length of a and b, use at your own risk.

BitBasis.unsafe_subMethod
unsafe_sub(a::UnitRange{T}, b::Vector{T}) where T

Returns a .- b, fallback version when b is a Vector.