Degrees of freedom

(INDEX::Type{<:Index})(pid::PID, iid::IID) -> INDEX

Get the corresponding index from a pid and an iid.

AbstractOID <: SimpleID

Abstract type of operator id.

Boundary{Names}(values::AbstractVector{Float}, vectors::AbstractVector{<:AbstractVector{Float}}) where Names

Boundary twist of operators.

(bound::Boundary)(operator::Operator) -> Operator

Get the boundary twisted operator.

Config{I}(map::Function, pids::AbstractVector{<:PID}) where {I<:Internal}

Configuration of the internal degrees of freedom at a lattice.

Here, map maps a PID to an Internal.

IID <: SimpleID

The id of an internal degree of freedom.

Index{P<:PID, I<:IID} <: SimpleID

The index of a degree of freedom, which consist of the spatial part and the internal part.

Internal{I<:IID} <: CartesianVectorSpace{I}

The whole internal degrees of freedom at a single point.

LaTeX{SP, SB}(body) where {SP, SB}

LaTeX string representation.

Metric <: Function

The rules for measuring a concrete oid so that oids can be compared.

As a function, every instance should accept only one positional argument, i.e. the concrete oid to be measured.

OID(index::Index, rcoord, icoord)
OID(index::Index; rcoord, icoord)

Operator id.

OIDToTuple{Fields} <: Metric

A rule that converts an oid to a tuple by iterating over a set of selected fields in a specific order.

(oidtotuple::OIDToTuple)(index::Index) -> Tuple
(oidtotuple::OIDToTuple)(oid::OID) -> Tuple

Convert a concrete oid to a tuple.

OIDToTuple(::Type{C}) where {C<:Config}

Construct the convertion rule from the information of Config.

OIDToTuple(::Type{I}) where {I<:Index}
OIDToTuple(::Type{I}) where {I<:OID}

Construct the convertion rule from the information of subtypes of AbstractOID.

Operator{V<:Number, I<:ID{AbstractOID}} <: Element{V, I}

Abstract type for an operator.

Operators(opts::Operator...)

A set of operators.

Type alias for Elements{<:ID{AbstractOID}, <:Operator}.

Table{I, B<:Metric} <: CompositeDict{I, Int}

The table of oid-sequence pairs.

Table(config::Config, by::Metric=OIDToTuple(typeof(config))) -> Table

Get the oid-sequence table of the whole internal degrees of freedom of a lattice by use of their configurations.

Table(oids::AbstractVector{<:AbstractOID}, by::Metric=OIDToTuple(eltype(oids)))

Convert a set of concrete oids to the corresponding table of oid-sequence pairs.

The input oids are measured by the input by function with the duplicates removed. The resulting unique values are sorted, which determines the sequence of the input oids. Note that two oids have the same sequence if their converted values are equal to each other.

==(bound1::Boundary, bound2::Boundary) -> Bool

Judge whether two boundaries conditions are equivalent to each other.

adjoint(opts::Operators) -> Operators

Get the adjoint of a set of operators.

adjoint(index::Index) -> typeof(index)

Get the adjoint of an index.

adjoint(oid::OID) -> typeof(oid)
adjoint(oid::ID{OID, N}) where N -> typeof(oid)

Get the adjoint of an operator id.

adjoint(opt::Operator) -> Operator

Get the adjoint of an operator.

angle(bound::Boundary, operator::Operator) -> Float

Get the boundary twist phase of an operator.

angle(id::ID{AbstractOID}, vectors::AbstractVector{<:AbstractVector{Float}}, values::AbstractVector{Float}) -> Float

Get the total twist phase of an id.

filter(f::Function, oidtotuple::OIDToTuple) -> OIDToTuple

Filter the selected fields.

getindex(table::Table, oid::AbstractOID) -> Int

Inquiry the sequence of an oid.

haskey(table::Table, oid::AbstractOID) -> Bool
haskey(table::Table, id::ID{AbstractOID}) -> Tuple{Vararg{Bool}}

Judge whether a single oid or a set of oids have been assigned with sequences in table.

isequal(bound1::Boundary, bound2::Boundary) -> Bool

Judge whether two boundaries conditions are equivalent to each other.

keys(bound::Boundary) -> Tuple{Vararg{Symbol}}
keys(::Type{<:Boundary{Names}}) where Names -> Names

Get the names of the boundary parameters.

keys(::OIDToTuple{Fields}) where Fields -> Fields
keys(::Type{<:OIDToTuple{Fields}}) where Fields -> Fields

Get the names of the selected fields.

repr(oid::AbstractOID) -> String
repr(oid::OID, l::LaTeX) -> String

LaTeX string representation of an oid.

repr(opts::Operators) -> String

Get the string representation of a set of operators in the LaTeX format.

repr(opt::Operator) -> String

Get the string representation of an operator in the LaTeX format.

show(io::IO, i::Internal)

Show an internal.

show(io::IO, ::MIME"text/latex", opts::Operators)

Show LaTeX formed operators.

show(io::IO, ::MIME"text/latex", opt::Operator)

Show an operator.

show(io::IO, oid::OID)

Show an operator id.

show(io::IO, opt::Operator)

Show an operator.

summary(io::IO, opts::Operators)

Print a brief description of a set of operators to an io.

union(tables::Table...) -> Table

Unite several oid-sequence tables.

union(::Type{P}, ::Type{I}) where {P<:PID, I<:IID}

Combine a concrete PID type and a concrete IID type to a concrete Index type.

valtype(::Type{<:OIDToTuple}, ::Type{<:Index})
valtype(::Type{<:OIDToTuple}, ::Type{<:OID})

Get the valtype of applying an OIDToTuple rule to a subtype of AbstractOID.

iid(index::Index) -> IID

Get the internal part of an index.

iidtype(index::Index)
iidtype(::Type{<:Index{<:PID, I}}) where {I<:IID}

Get the type of the internal part of an index.

isHermitian(opts::Operators) -> Bool

Judge whether a set of operators as a whole is Hermitian.

isHermitian(opt::Operator) -> Bool

Judge whether an operator is Hermitian.

isHermitian(id::ID{AbstractOID, N}) where N -> Bool

Judge whether an operator id is Hermitian.

latexformat(T::Type{<:AbstractOID}) -> LaTeX
latexformat(T::Type{<:AbstractOID}, l::LaTeX) -> LaTeX

Get/Set the LaTeX format for a subtype of Operator.

latexname(T::Type{<:AbstractOID}) -> Symbol

Get the name of a type of AbstractOID in the latex format lookups.

oidtype(I::Type{<:Internal}, P::Type{<:Point}, ::Val)

Get the compatible oid type from the combination of the internal part and the spatial part.

pid(index::Index) -> PID

Get the spatial part of an index.

plain

Plain boundary condition without any twist.

script(::Val{:BD}, oid::AbstractOID, l::LaTeX) -> Any
script(::Val{:SP}, oid::AbstractOID, l::LaTeX) -> Tuple
script(::Val{:SB}, oid::AbstractOID, l::LaTeX) -> Tuple

Get the body/superscript/subscript of the LaTeX string representation of an oid.

script(::Val{:integeralicoord}, oid::OID; vectors, kwargs...)

Get the integeral script of the icoord of an oid.

script(::Val{:rcoord}, oid::OID; kwargs...) -> String
script(::Val{:icoord}, oid::OID; kwargs...) -> String

Get the :rcoord/:icoord script of an oid.

script(::Val{attr}, oid::OID; kwargs...) where attr

Get the attr script of an oid, which is contained in its index.

twist(operator::Operator, vectors::AbstractVector{<:AbstractVector{Float}}, values::AbstractVector{Float}) -> Operator

Twist an operator.

icoord(opt::Operator) -> SVector

Get the whole icoord of an operator.

pidtype(index::Index)
pidtype(::Type{<:Index{P}}) where {P<:PID}

Get the type of the spatial part of an index.

rcoord(opt::Operator) -> SVector

Get the whole rcoord of an operator.

reset!(config::Config, pids) -> Config

Reset the config with new pids.

reset!(table::Table, oids::AbstractVector{<:AbstractOID}) -> Table

Reset a table by a new set of oids.

reset!(table::Table, config::Config) -> Table

Reset a table by a complete configuration of internal degrees of freedom on a lattice.

update!(bound::Boundary, args...; kwargs...) -> Boundary

Update the values of the boundary twisted phase.

sequence(opt::Operator, table::AbstractDict) -> NTuple{rank(opt), Int}

Get the sequence of the oids of an operator according to a table.