BitBasis

@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

@bit_str -> LongBitStr

Long bit string version of @bit_str macro.

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

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

baddrs(b::Integer) -> Vector

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

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.

bdistance(i::Integer, j::Integer) -> Int

Return number of different bits.

bfloat(b::Integer; nbits::Int=bit_length(b)) -> Float64

float view, with current bit numbering. See also bfloat_r.

Ref: wiki: bit numbering

bfloat(b::BitStr) -> Float64

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

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

bfloat_r(b::BitStr) -> Float64

bint(b::BitStr) -> Integer

bint(b; nbits=nothing) -> Int

integer view, with LSB 0 bit numbering. See also wiki: bit numbering

bint_r(b; nbits::Int) -> Integer

integer read in inverse order.

bint_r(b::BitStr) -> Integer

bit_length(x::Integer) -> Int

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

bit_literal(xs...)

Create a BitStr by input bits xs.

Example

julia> bit_literal(1, 0, 1, 0, 1, 1)
110101 ₍₂₎

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.

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.

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

breflect(bit_str[, masks])

Return left-right reflected bit string.

bsizeof(::Type)

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

truncate(b, n)

Truncate bits b to given length n.

controldo(f, itr::IterControl)

Execute f while iterating itr.

controller(cbits, cvals) -> Function

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

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)

group_shift!(nbits, positions)

Shift bits on positions together.

hypercubic(A::Array) -> Array

get the hypercubic representation for an array.

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.

invorder(X::AbstractVecOrMat)

Inverse the order of given vector/matrix X.

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

log2dim1(X)

Returns the log2 of the first dimension's size.

log2i(x::Integer) -> Integer

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

neg(b::BitStr) -> BitStr

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)

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.

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.

packbits(arr::AbstractArray) -> AbstractArray

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

readbit(x, loc...)

Read the bit config at given location.

reorder(X::AbstractArray, orders)

Reorder X according to orders.

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)

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

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

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.

ReorderedBasis{N, T}

Lazy reorderd basis.

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

Returns a lazy set of reordered basis.

next_reordered_basis(basis, takers, differ)

Returns the next reordered basis accroding to current basis.

unsafe_reorder(X::AbstractArray, orders)

Reorder X according to orders.

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.

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

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