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

source
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
source
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
source
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.

source
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.

source
BitBasis.bmaskFunction
bmask(::Type{T}) where T <: Integer -> zero(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.

source
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
source
BitBasis.controllerMethod
controller(cbits, cvals) -> Function

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

source
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)
source
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.

source
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;

true
source
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.

source
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)
source
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.

source
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.

source
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.

source
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)
source
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.

source
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
source
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.

source
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.

source
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.

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

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

source