Frameworks

const eager = Eager()

Singleton instance of Eager.

const lazy = Lazy()

Singleton instance of Lazy.

Tuple(data::Data)

Convert Data to Tuple.

Action

Abstract type for all actions.

Algorithm(name::Symbol, frontend::Frontend, parameters::Parameters=Parameters(frontend), map::Function=identity; dir::String=".", timer::TimerOutput=TimerOutput())

Construct an algorithm.

Algorithm{F<:Frontend, P<:Parameters, M<:Function} <: Function

An algorithm associated with an frontend.

(alg::Algorithm)(assign::Assignment, checkoptions::Bool=true; options...) -> Assignment
(assign::Assignment)(alg::Algorithm, checkoptions::Bool=true; options...) -> Assignment

Run an assignment based on an algorithm.

The difference between these two methods is that the first uses the parameters of assign as the current parameters while the second uses those of alg.

(alg::Algorithm)(name::Symbol, action::Action, dependencies::ZeroOrMore{Assignment}; dir::String=alg.dir, delay::Bool=false, options...) -> Assignment
(alg::Algorithm)(name::Symbol, action::Action, parameters::Parameters, dependencies::ZeroOrMore{Assignment}; dir::String=alg.dir, delay::Bool=false, options...) -> Assignment
(alg::Algorithm)(name::Symbol, action::Action, parameters::Parameters=Parameters(), map::Function=identity, dependencies::ZeroOrMore{Assignment}=(); dir::String=alg.dir, delay::Bool=false, options...) -> Assignment

Add an assignment on a algorithm by providing the contents of the assignment, and run this assignment.

Assignment{A<:Action, P<:Parameters, M<:Function, N, D<:Data} <: Function

An assignment associated with an action.

CategorizedGenerator{V, C, A<:NamedTuple, B<:NamedTuple, P<:Parameters, D<:Boundary, S<:ExpansionStyle} <: Generator{V}

Categorized generator that groups the (representations of) quantum operators in a quantum lattice system into three categories, i.e., the constant, the alterable, and the boundary.

Data

Abstract type for the data of an action.

Eager <: ExpansionStyle

Eager expansion style with eager computation so that similar terms are combined in the final result.

ExpansionStyle

Expansion style of a generator of (representations of) quantum operators. It has two singleton subtypes, Eager and Lazy.

Formula{V, F<:Function, P<:Parameters}

Representation of a quantum lattice system with an explicit analytical formula.

(formula::Formula)(args...; kwargs...) -> valtype(formula)

Get the result of a Formula.

Frontend

Frontend of algorithms applied to a quantum lattice system.

Generator{V}

Generator of (representations of) quantum operators in a quantum lattice system.

Generator(constops, alterops::NamedTuple, boundops::NamedTuple, parameters::Parameters, boundary::Boundary, style::ExpansionStyle) -> CategorizedGenerator

Construct a CategorizedGenerator.

Generator(operators::CategorizedGenerator{<:Operators}, bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, half::Bool) -> OperatorGenerator
Generator(bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain, style::ExpansionStyle=eager; half::Bool=false) -> OperatorGenerator

Construct an OperatorGenerator.

Lazy <: ExpansionStyle

Lazy expansion style with lazy computation so that similar terms are not combined in the final result.

OperatorGenerator{V<:Operators, CG<:CategorizedGenerator{V}, B<:Bond, H<:Hilbert, TS<:ZeroAtLeast{Term}} <: Generator{V}

A generator of operators based on the terms, bonds and Hilbert space of a quantum lattice system.

OperatorGenerator(bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain, style::ExpansionStyle=eager; half::Bool=false)

Construct a generator of quantum operators based on the input bonds, Hilbert space, terms and (twisted) boundary condition.

When the boundary condition is plain, the boundary operators will be set to be empty for simplicity and efficiency.

Parameters{Names}(values::Number...) where Names

A NamedTuple that contains the key-value pairs.

Parameters(algorithm::Algorithm)

Get the parameters of an algorithm.

Parameters(assignment::Assignment) -> Parameters

Get the parameters of an assignment.

Parameters(bound::Boundary)

Get the parameters of the twisted boundary condition.

Parameters(cat::CategorizedGenerator)

Get the complete set of parameters of a categorized generator of (representations of) quantum operators.

Parameters(formula::Formula) -> Parameters

Get the parameters of a Formula.

Parameters(gen::OperatorGenerator) -> Parameters

Get the parameters of an OperatorGenerator.

Parameters(ops::OperatorSet) -> NamedTuple{(), Tuple{}}

Get the parameters of an OperatorSet, which is defined to be an empty NamedTuple.

(transformation::LinearTransformation)(cat::CategorizedGenerator; kwargs...) -> CategorizedGenerator

Apply a linear transformation to a categorized generator of (representations of) quantum operators.

(transformation::LinearTransformation)(gen::OperatorGenerator; kwargs...) -> CategorizedGenerator

Get the transformation applied to a generator of quantum operators.

*(cat::CategorizedGenerator, factor::Number) -> CategorizedGenerator
*(factor::Number, cat::CategorizedGenerator) -> CategorizedGenerator

Multiply a categorized generator of (representations of) quantum operators with a factor.

+(cat₁::CategorizedGenerator, cat₂::CategorizedGenerator) -> CategorizedGenerator

Addition of two categorized generators of (representations of) quantum operators.

basename(obj::Union{Assignment, Algorithm}; prefix::String="", suffix::String="", extension::String="qld") -> String

Get the basename of the data file of an assignment/algorithm.

dirname(obj::Union{Assignment, Algorithm}) -> String

Get the dirname of the data file of an assignment/algorithm.

eltype(gen::Generator)
eltype(::Type{T}) where {T<:Generator}

Get the eltype of a Generator.

empty(cat::CategorizedGenerator) -> CategorizedGenerator
empty!(cat::CategorizedGenerator) -> CategorizedGenerator

Get an empty copy of a categorized generator or empty a categorized generator of (representations of) quantum operators.

empty(gen::OperatorGenerator) -> OperatorGenerator
empty!(gen::OperatorGenerator) -> OperatorGenerator

Get an empty copy of or empty an operator generator.

isempty(cat::CategorizedGenerator) -> Bool

Judge whether a categorized generator is empty.

isempty(gen::OperatorGenerator) -> Bool

Judge whether an OperatorGenerator is empty.

iterate(gen::Generator)
iterate(::Generator, state)

Iterate over a Generator.

match(params₁::Parameters, params₂::Parameters; atol=atol, rtol=rtol) -> Bool

Judge whether the second set of parameters matches the first.

pathof(obj::Union{Assignment, Algorithm}; prefix::String="", suffix::String="", extension::String="qld") -> String

Get the path of the data file of an assignment/algorithm.

show(io::IO, alg::Algorithm)

Show an algorithm.

show(io::IO, assign::Assignment)

Show an assignment.

show(io::IO, ::MIME"text/plain", alg::Algorithm)

Show an algorithm.

Optionally, some parameters of the algorithm can be filtered by specifying the :select context in io. Besides, the maximum number of decimals of the parameters can also be specified by the :ndecimal context in io.

show(io::IO, ::MIME"text/plain", assign::Assignment)

Show an assignment.

Optionally, some parameters of the algorithm can be filtered by specifying the :select context in io. Besides, the maximum number of decimals of the parameters can also be specified by the :ndecimal context in io.

summary(alg::Algorithm)

Provide a summary of an algorithm.

valtype(assign::Assignment)
valtype(::Type{<:Assignment})

Type of the data (result) of an assignment.

valtype(formula::Formula)
valtype(::Type{<:Formula{V}})

Get the valtype of a Formula.

valtype(gen::Generator)
valtype(::Type{<:Generator{V}}) where V

Get the valtype of a Generator.

checkoptions(::Type{A}; options...) where {A<:Assignment}

Check whether the keyword arguments are legal options of a certain type of Assignment.

datatype(::Type{A}, ::Type{F}) where {A<:Action, F<:Frontend}

Get the concrete subtype of Data according to the types of an Action and a Frontend.

hasoption(::Type{A}, option::Symbol) where {A<:Assignment} -> Bool

Judge whether a certain type of Assignment has an option.

options(::Type{<:Assignment}) -> NamedTuple

Get the options of a certain type of Assignment.

optionsinfo(::Type{A}; level::Int=1) where {A<:Assignment} -> String

Get the complete info of the options of a certain type of Assignment, including that of its dependencies.

qldload(filename::String) -> Dict{String, Any}
qldload(filename::String, name::String) -> Any
qldload(filename::String, name₁::String, name₂::String, names::String...) -> Tuple

Load data from a qld file.

qldsave(filename::String, args...; mode::String="a+")

Save arbitrary data to a qld file.

qldsave(obj::Union{Assignment, Algorithm}, objs::Union{Assignment, Algorithm}...; mode::String="a+", prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="")

Save a series of assignments/algorithms to qld files.

run!(alg::Algorithm, assign::Assignment; options...)

Run an assignment based on an algorithm.

scalartype(::Type{F}) where {F<:Formula}

Get the scalar type of a Formula.

scalartype(::Type{T}) where {T<:Generator}

Get the scalar type of a Generator.

dlmsave(assignment::Assignment, delim='	'; prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="")

Save the data of an assignment to a delimited file.

expand!(result, gen::Generator) -> typeof(result)

Expand the generator to add the (representations of) quantum operators in a quantum lattice system to result.

expand(cat::CategorizedGenerator, ::Lazy)

Expand a categorized generator to get the (representations of) quantum operators in a quantum lattice system.

expand(gen::Generator)
expand(gen::Generator, ::Eager)
expand(gen::Generator, ::Lazy)

Expand the generator to get the (representations of) quantum operators in a quantum lattice system.

expand(gen::OperatorGenerator, name::Symbol) -> Operators
expand(gen::OperatorGenerator, i::Int) -> Operators
expand(gen::OperatorGenerator, name::Symbol, i::Int) -> Operators

Expand an operator generator to get:

1. the operators of a specific term;
2. the operators on a specific bond;
3. the operators of a specific term on a specific bond.

reset!(cat::CategorizedGenerator, transformation::LinearTransformation, source::CategorizedGenerator; kwargs...)

Reset a categorized generator by its source categorized generator of (representations of) quantum operators and the corresponding linear transformation.

reset!(cat::CategorizedGenerator, transformation::LinearTransformation, source::OperatorGenerator; kwargs...)

Reset a categorized generator by its source operator generator of (representations of) quantum operators and the corresponding linear transformation.

reset!(gen::OperatorGenerator, bonds::AbstractVector{<:Bond}, hilbert::Hilbert; vectors::AbstractVector{<:AbstractVector}=gen.operators.boundary.vectors) -> OperatorGenerator

Reset an operator generator by a new lattice and the corresponding new hilbert space.

str(params::Parameters; ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Convert a set of Parameters to a string with each number hosting at most ndecimal decimal places. Here, the select function can select the key-value pairs to be contained by the keys.

str(obj::Union{Assignment, Algorithm}; prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Get the string representation of an assignment/algorithm.

update!(action::Action; parameters...) -> Action

Update the parameters of an action.

update!(alg::Algorithm; parameters...) -> Algorithm

Update the parameters of an algorithm and its associated frontend.

update!(assign::Assignment; parameters...) -> Assignment

Update the parameters of an assignment and the status of its associated action.

update!(cat::CategorizedGenerator, transformation::LinearTransformation, source::CategorizedGenerator; kwargs...) -> CategorizedGenerator

Update the parameters (including the boundary parameters) of a categorized generator based on its source categorized generator of (representations of) quantum operators and the corresponding linear transformation.

!!! Note The coefficients of boundops are also updated due to the change of the boundary parameters.

update!(cat::CategorizedGenerator, transformation::LinearTransformation, source::OperatorGenerator; kwargs...) -> CategorizedGenerator

Update the parameters (including the boundary parameters) of a categorized generator based on its source operator generator of (representations of) quantum operators and the corresponding linear transformation.

!!! Note The coefficients of boundops are also updated due to the change of the boundary parameters.

update!(cat::CategorizedGenerator{<:OperatorSum}; parameters...) -> CategorizedGenerator

Update the parameters (including the boundary parameters) of a categorized generator of (representations of) quantum operators.

!!! Note The coefficients of boundops are also updated due to the change of the boundary parameters.

update!(formula::Formula; parameters...) -> Formula

Update the parameters of a Formula in place and return itself after update.

update!(gen::OperatorGenerator; parameters...) -> typeof(gen)

Update the coefficients of the terms in a generator.

update(params::NamedTuple; parameters...) -> Parameters

Update a set of Parameters and return the updated one.

@recipe plot(assignment::Assignment)

Define the recipe for the visualization of an assignment of an algorithm.