Intrinsics

AddressConflictError <: Exception

Address conflict error in Block Construction.

IterControl{N, C}

N is the size of hilber space, C is the number of shifts.

QubitMismatchError <: Exception

Qubit number mismatch error when applying a Block to a Register or concatenating Blocks.

ishermitian(op) -> Bool

check if this operator is hermitian.

basis(num_bit::Int) -> UnitRange{Int}
basis(state::AbstractArray) -> UnitRange{Int}

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

batch_normalize

normalize a batch of vector.

batch_normalize!(matrix)

normalize a batch of vector.

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

Return number of different bits.

bit_length(x::Int) -> Int

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

bitarray(v::Vector, [num_bit::Int]) -> BitArray
bitarray(v::Int, num_bit::Int) -> BitArray
bitarray(num_bit::Int) -> Function

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

bmask(ibit::Int...) -> Int
bmask(bits::UnitRange{Int}) ->Int

Return an integer with specific position masked, which is offten used as a mask for binary operations.

breflect(num_bit::Int, b::Int[, masks::Vector{Int}]) -> Int

Return left-right reflected integer.

bsizeof(x) -> Int

Return the size of object, in number of bit.

controller(cbits, cvals) -> Function

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

control-unitary

fidelity_mix(m1::Matrix, m2::Matrix)

Fidelity for mixed states.

Reference: http://iopscience.iop.org/article/10.1088/1367-2630/aa6a4b/meta

fidelity for pure states.

flip(index::Int, mask::Int) -> Int

Return an Integer with bits at masked position flipped.

general_controlled_gates(num_bit::Int, projectors::Vector{Tp}, cbits::Vector{Int}, gates::Vector{AbstractMatrix}, locs::Vector{Int}) -> AbstractMatrix

Return general multi-controlled gates in hilbert space of num_bit qubits,

• projectors are often chosen as P0 and P1 for inverse-Control and Control at specific position.

• cbits should have the same length as projectors, specifing the controling positions.

• gates are a list of controlled single qubit gates.

• locs should have the same length as gates, specifing the gates positions.

hilbertkron(num_bit::Int, gates::Vector{AbstractMatrix}, locs::Vector{Int}) -> AbstractMatrix

Return general kronecher product form of gates in Hilbert space of num_bit qubits.

• gates are a list of matrices.

• start_locs should have the same length as gates, specifing the gates starting positions.

indices_with(num_bit::Int, poss::Vector{Int}, vals::Vector{Int}) -> Vector{Int}

Return indices with specific positions poss with value vals in a hilbert space of num_bit qubits.

isreflexive(op) -> Bool

check if this operator is reflexive.

isunitary(op) -> Bool

check if this operator is a unitary operator.

itercontrol(num_bit::Int, poss::Vector{Int}, vals::Vector{Int}) -> IterControl

Return the iterator for basis with poss controlled to values vals, with the total number of bits num_bit.

log2i(x::Integer) -> Integer

Return log2(x), this integer version of log2 is fast but only valid for number equal to 2^n. Ref: https://stackoverflow.com/questions/21442088

neg(index::Int, num_bit::Int) -> Int

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

onehotvec(::Type{T}, num_bit::Int, x::DInt) -> Vector{T}

one-hot wave vector.

packbits(arr::AbstractArray) -> AbstractArray

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

Reordered Basis

setbit(index::Int, mask::Int) -> Int

set the bit at masked position to 1.

swapbits(num::Int, mask12::Int) -> Int

Return an integer with bits at i and j flipped.

takebit(index::Int, ibit::Int) -> Int

Return a bit at specific position.

testall(index::Int, mask::Int) -> Bool

Return true if all masked position of index is 1.

testany(index::Int, mask::Int) -> Bool

Return true if any masked position of index is 1.

testval(index::Int, mask::Int, onemask::Int) -> Bool

Return true if values at positions masked by mask with value 1 at positions masked by onemask and 0 otherwise.

sort(t::Tuple; lt=isless, by=identity, rev::Bool=false) -> ::Tuple

Sorts the tuple t.

sortperm(t::Tuple; lt=isless, by=identity, rev::Bool=false) -> ::Tuple

Computes a tuple that contains the permutation required to sort t.

turn a vector/matrix to static vector/matrix (only if its length <= 256).