BitBasis

@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

@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

@lbit_str -> LongBitStr

Long bit string version of @bit_str macro.

@ldit_str -> LongDitStr

Long dit string version of @dit_str macro.

==(lhs::SubDitStr{D,N,T}, rhs::DitStr{D,N,T}) -> Bool
==(lhs::DitStr{D,N,T}, rhs::SubDitStr{D,N,T}) -> Bool
==(lhs::SubDitStr{D,N,T}, rhs::SubDitStr{D,N,T}) -> Bool

Compare the equality between SubDitStr and DitStr.

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

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.

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.

btruncate(b, n)

Truncate bits b to given length n.

controldo(f, itr::IterControl)

Execute f while iterating itr.

controller([T=Int, ]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) |> BitStr{4}
0000 ₍₂₎

group_shift!(nbits, positions)

Shift bits on positions together.

hypercubic(A::Array) -> Array

get the hypercubic representation for an array.

indicator(::Type{T}, k) -> T

Return an integer with k-th bit set to 1.

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

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

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) |> BitStr{4}
0000 ₍₂₎

julia> neg(0b0111, 4) |> BitStr{4}
1000 ₍₂₎

next_reordered_basis(basis, takers, differ)

Returns the next reordered basis accroding to current basis.

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.

packbits(arr::AbstractArray) -> AbstractArray

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

readat(x, loc...) -> Integer

Read the dit config at given location.

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) |> BitStr{4}
1111 ₍₂₎

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

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

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

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.

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

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 ₍₃₎

DitStr(dit::SubDitStr{D,N,T}) -> DitStr{D,N,T}

Raise type SubDitStr to DitStr.

julia> x = DitStr{3, 5}(71)
02122 ₍₃₎

julia> sx =  SubDitStr(x, 2, 4)
SubDitStr{3, 5, Int64}(02122 ₍₃₎, 1, 3)

julia> DitStr(sx)
212 ₍₃₎

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.

LongLongUInt{C} <: Integer

A LongLongUInt{C} is an integer with C UInt numbers to store the value.

ReorderedBasis{N, T}

Lazy reorderd basis.

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

Returns a lazy set of reordered basis.

SubDitStr{D,N,T<:Integer} <: Integer

The struct as a SubString-like object for DitStr(SubString is an official implementation of sliced strings, see String for reference). This slicing returns a view into the parent DitStr instead of making a copy (similar to the @views macro for strings).

SubDitStr can be used to describe the qubit configuration within the subspace of the entire Hilbert space.It provides similar getindex, length functions as DitStr.

SubDitStr(dit::DitStr{D,N,T}, i::Int, j::Int)
SubDitStr(dit::DitStr{D,N,T}, r::AbstractUnitRange{<:Integer})

Or by @views macro for DitStr (this macro makes your life easier by supporting begin and end syntax):

@views dit[i:j]

Returns a SubDitStr.

Examples

julia> x = DitStr{3, 5}(71)
02122 ₍₃₎

julia> sx =  SubDitStr(x, 2, 4) 
SubDitStr{3, 5, Int64}(02122 ₍₃₎, 1, 3)

julia> @views x[2:end] 
SubDitStr{3, 5, Int64}(02122 ₍₃₎, 1, 4)

julia> sx == dit"212;3"
true