GitHub

BitBasis

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

For more details please ref to BitBasis.jl.

BitBasis.@bit_str — Macro
@bit_str -> BitStr64

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

Example

julia> bit"10001"
10001 ₍₂₎

julia> bit"100_111_101"
100111101 ₍₂₎

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

julia> onehot(bit"1001")
16-element Vector{ComplexF64}:
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 1.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
source
BitBasis.@dit_str — Macro
@dit_str -> DitStr64

Construct a dit string. such as dit"0201;3". The dit strings also supports string join. Just use it like normal strings.

Example

julia> dit"10201;3"
10201 ₍₃₎

julia> dit"100_121_121;3"
100121121 ₍₃₎

julia> join(dit"1021;3", dit"11;3", dit"1210;3")
1021111210 ₍₃₎

julia> onehot(dit"1021;3")
81-element Vector{ComplexF64}:
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
     ⋮
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
source
BitBasis.allone — Method
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.anyone — Method
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.baddrs — Method
baddrs(b::Integer) -> Vector

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

source
BitBasis.basis — Method
basis(ditstr) -> UnitRange{DitStr{D,N,T}}
basis(DitStr{D,N,T}) -> UnitRange{DitStr{D,N,T}}

Returns the UnitRange for basis in Hilbert Space of qudits.

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

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

source
BitBasis.bit_length — Method
bit_length(x::Integer) -> Int

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

source
BitBasis.bitarray — Method
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.bmask — Function
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.

source
BitBasis.breflect — Function
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.controldo — Method
controldo(f, itr::IterControl)

Execute f while iterating itr.

Note

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

source
BitBasis.controller — Method
controller([T=Int, ]cbits, cvals) -> Function

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

source
BitBasis.flip — Method
flip(index::Integer, mask::Integer) -> Integer

Return an Integer with bits at masked position flipped.

Example

julia> flip(0b1011, 0b1011) |> BitStr{4}
0000 ₍₂₎
source
BitBasis.indices_with — Method
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.ismatch — Method
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
source
BitBasis.itercontrol — Method
itercontrol([T=Int], nbits, positions, bit_configs)

Returns an iterator which iterate through controlled subspace of bits.

Example

To iterate through all the bits satisfy 0xx10x1 where x means an arbitrary bit.

julia> for each in itercontrol(7, [1, 3, 4, 7], (1, 0, 1, 0))
           println(string(each, base=2, pad=7))
       end
0001001
0001011
0011001
0011011
0101001
0101011
0111001
0111011
source
BitBasis.log2i — Function
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.neg — Method
neg(index::Integer, nbits::Int) -> Integer

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

Example

julia> neg(0b1111, 4) |> BitStr{4}
0000 ₍₂₎

julia> neg(0b0111, 4) |> BitStr{4}
1000 ₍₂₎
source
BitBasis.onehot — Method
onehot([T=Float64], dit_str[; nbatch])

Create an onehot vector in type Vector{T} or a batch of onehot vector in type Matrix{T}, where index x + 1 is one. One can specify the value of the nonzero entry by inputing a pair.

source
BitBasis.packbits — Method
packbits(arr::AbstractArray) -> AbstractArray

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

source
BitBasis.reorder — Function
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.setbit — Method
setbit(index::Integer, mask::Integer) -> Integer

set the bit at masked position to 1.

Example

julia> setbit(0b1011, 0b1100) |> BitStr{4}
1111 ₍₂₎

julia> setbit(0b1011, 0b0100) |> BitStr{4}
1111 ₍₂₎

julia> setbit(0b1011, 0b0000) |> BitStr{4}
1011 ₍₂₎
source
BitBasis.swapbits — Method
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.unsafe_reorder — Function
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_sub — Method
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_sub — Method
unsafe_sub(a::UnitRange{T}, b::Vector{T}) where T

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

source
BitBasis.BitStr — Type
BitStr{N,T} <: Integer

The struct for bit string with fixed length N and storage type T. It is an alias of DitStr{2,N,T}.

BitStr{N,T}(integer)
BitStr64{N}(integer)
BitStr64(vector)
LongBitStr{N}(integer)
LongBitStr(vector)

Returns a BitStr. When the input is an integer, the bits are read from right to left. When the input is a vector, the bits are read from left to right.

Examples

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> join([bit"101" for i in 1:10])
"101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎101 ₍₂₎"

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

julia> bit"1101"[2]
0
source
BitBasis.DitStr — Type
DitStr{D,N,T<:Integer} <: Integer

The struct for dit string with fixed length N and storage type T, where dit is a extension of dit from binary system to a d-ary system.

DitStr{D,N,T}(integer)
DitStr{D,N}(integer)
DitStr{D}(vector)

Returns a DitStr. When the input is an integer, the dits are read from right to left. When the input is a vector, the dits are read from left to right.

Examples

julia> DitStr{3}([1,2,1,1,0])
01121 ₍₃₎

julia> DitStr{3, 5}(71)
02122 ₍₃₎
source
BitBasis.IterControl — Type
IterControl{S}
IterControl(n::Int, base::Int, masks, factors) -> IterControl

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

source