Element{T}

Type definition. A matrix.

MatArray{T}

Type definition. A matrix of matrix.

VecArray{T}

Type definition. A vector of matrix.

CnAbstractType

Top abstract type for all objects defined on contour.

CnAbstractMatrix{T}

Abstract matrix type defined on contour.

CnAbstractVector{T}

Abstract vector type defined on contour.

CnAbstractFunction{T}

Abstract contour function.

Cn

𝐿-shape Kadanoff-Baym contour. It includes the following members:

• ntime -> Number of time slices in real time axis [0, 𝑡max].
• ntau -> Number of time slices in imaginary time axis [0, β].
• ndim1 -> Size of operators that stored in the contour.
• ndim2 -> Size of operators that stored in the contour.
• tmax -> Maximum 𝑡.
• beta -> β, inverse temperature.
• dt -> δ𝑡, time step in real axis.
• dtau -> δτ, time step in imaginary axis.

See also: CnAbstractType.

Cf{T}

It is a square-matrix-valued or rectangle-matrix-valued function of time.

See also: ℱ, 𝒻.

Gᵐᵃᵗ{T}

Matsubara component ($G^M$) of contour Green's function. We usually call this component mat. Here we just assume $au ≥ 0$. While for $au < 0$, please turn to the Gᵐᵃᵗᵐ{T} struct.

See also: Gʳᵉᵗ, Gˡᵐⁱˣ, Gˡᵉˢˢ.

Gʳᵉᵗ{T}

Retarded component ($G^R$) of contour Green's function. We usually call this component ret.

See also: Gᵐᵃᵗ, Gˡᵐⁱˣ, Gˡᵉˢˢ.

Gˡᵐⁱˣ{T}

Left-mixing component ($G^{⌉}$) of contour Green's function. We usually call this component lmix.

See also: Gᵐᵃᵗ, Gʳᵉᵗ, Gˡᵉˢˢ.

Gˡᵉˢˢ{T}

Lesser component ($G^{<}$) of contour Green's function. We usually call this component less.

See also: Gᵐᵃᵗ, Gʳᵉᵗ, Gˡᵐⁱˣ.

Gᵐᵃᵗᵐ{T}

Matsubara component ($G^M$) of contour Green's function. It is designed for $au < 0$ case. It is not an independent component. It can be inferred or deduced from the Gᵐᵃᵗ{T} struct. We usually call this component matm.

See also: Gʳᵉᵗ, Gˡᵐⁱˣ, Gˡᵉˢˢ.

Gᵃᵈᵛ{T}

Advanced component ($G^{A}$) of contour Green's function. We usually call this component adv.

Note that currently we do not need this component explicitly. However, for the sake of completeness, we still define an empty struct for it.

See also: Gᵐᵃᵗ, Gˡᵐⁱˣ, Gˡᵉˢˢ.

Gʳᵐⁱˣ{T}

Right-mixing component ($G^{⌈}$) of contour Green's function. We usually call this component rmix.

See also: Gᵐᵃᵗ, Gʳᵉᵗ, Gˡᵉˢˢ.

Gᵍᵗʳ{T}

Greater component ($G^{>}$) of contour Green's function. We usually call this component gtr.

See also: Gʳᵉᵗ, Gˡᵐⁱˣ, Gˡᵉˢˢ.

gᵐᵃᵗ{S}

Matsubara component ($G^{M}$) of contour Green's function at given time step tstp. Actually, gᵐᵃᵗ{S} is equivalent to Gᵐᵃᵗ{T}.

See also: gʳᵉᵗ, gˡᵐⁱˣ, gˡᵉˢˢ.

gʳᵉᵗ{S}

Retarded component ($G^{R}$) of contour Green's function at given time step tstp. Actually, it denotes $G^{R}(tᵢ = tstp, tⱼ)$.

See also: gᵐᵃᵗ, gˡᵐⁱˣ, gˡᵉˢˢ.

gˡᵐⁱˣ{S}

Left-mixing component ($G^{⌉}$) of contour Green's function at given time step tstp. Actually, it denotes $G^{⌉}(tᵢ ≡ tstp, τⱼ)$.

See also: gᵐᵃᵗ, gʳᵉᵗ, gˡᵉˢˢ.

gˡᵉˢˢ{S}

Lesser component ($G^{<}$) of contour Green's function at given time step tstp. Actually, it denotes $G^{<}(tᵢ, tⱼ ≡ tstp)$.

See also: gᵐᵃᵗ, gʳᵉᵗ, gˡᵐⁱˣ.

gᵐᵃᵗᵐ{S}

Matsubara component ($G^M$) of contour Green's function at given time step tstp = 0. It is designed for $au < 0$ case. It is not an independent component. It can be constructed from the gᵐᵃᵗ{T} struct.

See also: gʳᵉᵗ, gˡᵐⁱˣ, gˡᵉˢˢ.

gᵃᵈᵛ{S}

Advanced component ($G^{A}$) of contour Green's function at given time step tstp.

Note that currently we do not need this component explicitly. However, for the sake of completeness, we still define an empty struct for it.

See also: gᵐᵃᵗ, gˡᵐⁱˣ, gˡᵉˢˢ.

gʳᵐⁱˣ{S}

Right-mixing component ($G^{⌈}$) of contour Green's function at given time step tstp. Actually, it denotes $G^{⌈}(τᵢ, tⱼ ≡ tstp)$

See also: gᵐᵃᵗ, gʳᵉᵗ, gˡᵉˢˢ.

gᵍᵗʳ{S}

Greater component ($G^{>}$) of contour Green's function at given time step tstp.

See also: gʳᵉᵗ, gˡᵐⁱˣ, gˡᵉˢˢ.

ℱ{T}

Standard contour-ordered Green's function. It includes four independent components, namely mat, ret, lmix, and less.

𝒻{S}

Standard contour-ordered Green's function at given time step tstp. It includes four independent components, namely mat, ret, lmix, and less. If tstp = 0, it denotes the equilibrium state (only the mat component is valid). On the other hand, tstp > 0 means nonequilibrium state.

refresh!(C::Cn)

Update the dt and dtau parameters of contour.

See also: Cn.

getdims(C::Cn)

Return the dimensional parameters of contour.

See also: Cn.

getdims(cf::Cf{T})

Return the dimensional parameters of contour function.

See also: Cf.

getdims(mat::Gᵐᵃᵗ{T})

Return the dimensional parameters of contour function.

See also: Gᵐᵃᵗ.

getdims(ret::Gʳᵉᵗ{T})

Return the dimensional parameters of contour function.

See also: Gʳᵉᵗ.

getdims(lmix::Gˡᵐⁱˣ{T})

Return the dimensional parameters of contour function.

See also: Gˡᵐⁱˣ.

getdims(less::Gˡᵉˢˢ{T})

Return the dimensional parameters of contour function.

See also: Gˡᵉˢˢ.

getdims(cfm::ℱ{T})

Return the dimensional parameters of contour Green's function.

See also: ℱ.

getdims(mat::gᵐᵃᵗ{S})

Return the dimensional parameters of contour function.

See also: gᵐᵃᵗ.

getdims(ret::gʳᵉᵗ{S})

Return the dimensional parameters of contour function.

See also: gʳᵉᵗ.

getdims(lmix::gˡᵐⁱˣ{S})

Return the dimensional parameters of contour function.

See also: gˡᵐⁱˣ.

getdims(less::gˡᵉˢˢ{S})

Return the dimensional parameters of contour function.

See also: gˡᵉˢˢ.

getdims(cfv::𝒻{S})

Return the dimensional parameters of contour Green's function.

See also: 𝒻.

getntime(cfm::ℱ{T})

Return the ntime parameter of contour Green's function.

getntau(cfm::ℱ{T})

Return the ntau parameter of contour Green's function.

getntau(cfv::𝒻{S})

Return the ntau parameter of contour Green's function.

getsign(cfm::ℱ{T})

Return the sign parameter of contour Green's function.

getsign(cfv::𝒻{S})

Return the sign parameter of contour Green's function.

getsize(cf::Cf{T})

Return the nominal size of contour function, i.e ntime. Actually, the real size of contour function should be ntime + 1.

See also: Cf.

getsize(mat::Gᵐᵃᵗ{T})

Return the size of contour function. Here, it should be ntau.

See also: Gᵐᵃᵗ.

getsize(ret::Gʳᵉᵗ{T})

Return the size of contour function.

See also: Gʳᵉᵗ.

getsize(lmix::Gˡᵐⁱˣ{T})

Return the size of contour function.

See also: Gˡᵐⁱˣ.

getsize(less::Gˡᵉˢˢ{T})

Return the size of contour function.

See also: Gˡᵉˢˢ.

getsize(mat::gᵐᵃᵗ{S})

Return the size of contour function.

See also: gᵐᵃᵗ.

getsize(ret::gʳᵉᵗ{S})

Return the size of contour function.

See also: gʳᵉᵗ.

getsize(lmix::gˡᵐⁱˣ{S})

Return the size of contour function.

See also: gˡᵐⁱˣ.

getsize(less::gˡᵉˢˢ{S})

Return the size of contour function.

See also: gˡᵉˢˢ.

gettstp(cfv::𝒻{S})

Return the tstp parameter of contour Green's function.

equaldims(C::Cn)

Return whether the dimensional parameters are equal.

See also: Cn.

equaldims(cf::Cf{T})

Return whether the dimensional parameters are equal.

See also: Cf.

equaldims(mat::Gᵐᵃᵗ{T})

Return whether the dimensional parameters are equal.

See also: Gᵐᵃᵗ.

equaldims(ret::Gʳᵉᵗ{T})

Return whether the dimensional parameters are equal.

See also: Gʳᵉᵗ.

equaldims(lmix::Gˡᵐⁱˣ{T})

Return whether the dimensional parameters are equal.

See also: Gˡᵐⁱˣ.

equaldims(less::Gˡᵉˢˢ{T})

Return whether the dimensional parameters are equal.

See also: Gˡᵉˢˢ.

equaldims(cfm::ℱ{T})

Return whether the dimensional parameters are equal.

See also: ℱ.

equaldims(mat::gᵐᵃᵗ{S})

Return whether the dimensional parameters are equal.

See also: gᵐᵃᵗ.

equaldims(ret::gʳᵉᵗ{S})

Return whether the dimensional parameters are equal.

See also: gʳᵉᵗ.

equaldims(lmix::gˡᵐⁱˣ{S})

Return whether the dimensional parameters are equal.

See also: gˡᵐⁱˣ.

equaldims(less::gˡᵉˢˢ{S})

Return whether the dimensional parameters are equal.

See also: gˡᵉˢˢ.

equaldims(cfv::𝒻{S})

Return whether the dimensional parameters are equal.

See also: 𝒻.

iscompatible(cf1::Cf{T}, cf2::Cf{T})

Judge whether two Cf objects are compatible.

iscompatible(C::Cn, cf::Cf{T})

Judge whether C (which is a Cn object) is compatible with cf (which is a Cf{T} object).

iscompatible(cf::Cf{T}, C::Cn)

Judge whether C (which is a Cn object) is compatible with cf (which is a Cf{T} object).

iscompatible(mat1::Gᵐᵃᵗ{T}, mat2::Gᵐᵃᵗ{T})

Judge whether two Gᵐᵃᵗ objects are compatible.

iscompatible(C::Cn, mat::Gᵐᵃᵗ{T})

Judge whether C (which is a Cn object) is compatible with mat (which is a Gᵐᵃᵗ{T} object).

iscompatible(mat::Gᵐᵃᵗ{T}, C::Cn)

Judge whether C (which is a Cn object) is compatible with mat (which is a Gᵐᵃᵗ{T} object).

iscompatible(ret1::Gʳᵉᵗ{T}, ret2::Gʳᵉᵗ{T})

Judge whether two Gʳᵉᵗ objects are compatible.

iscompatible(C::Cn, ret::Gʳᵉᵗ{T})

Judge whether C (which is a Cn object) is compatible with ret (which is a Gʳᵉᵗ{T} object).

iscompatible(ret::Gʳᵉᵗ{T}, C::Cn)

Judge whether C (which is a Cn object) is compatible with ret (which is a Gʳᵉᵗ{T} object).

iscompatible(lmix1::Gˡᵐⁱˣ{T}, lmix2::Gˡᵐⁱˣ{T})

Judge whether two Gˡᵐⁱˣ objects are compatible.

iscompatible(C::Cn, lmix::Gˡᵐⁱˣ{T})

Judge whether C (which is a Cn object) is compatible with lmix (which is a Gˡᵐⁱˣ{T} object).

iscompatible(lmix::Gˡᵐⁱˣ{T}, C::Cn)

Judge whether C (which is a Cn object) is compatible with lmix (which is a Gˡᵐⁱˣ{T} object).

iscompatible(less1::Gˡᵉˢˢ{T}, less2::Gˡᵉˢˢ{T})

Judge whether two Gˡᵉˢˢ objects are compatible.

iscompatible(C::Cn, less::Gˡᵉˢˢ{T})

Judge whether C (which is a Cn object) is compatible with less (which is a Gˡᵉˢˢ{T} object).

iscompatible(less::Gˡᵉˢˢ{T}, C::Cn)

Judge whether C (which is a Cn object) is compatible with less (which is a Gˡᵉˢˢ{T} object).

iscompatible(mat1::gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S})

Judge whether two gᵐᵃᵗ objects are compatible.

iscompatible(mat1::gᵐᵃᵗ{S}, mat2::Gᵐᵃᵗ{S})

Judge whether the gᵐᵃᵗ and Gᵐᵃᵗ objects are compatible.

iscompatible(mat1::Gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S})

Judge whether the gᵐᵃᵗ and Gᵐᵃᵗ objects are compatible.

iscompatible(C::Cn, mat::gᵐᵃᵗ{S})

Judge whether C (which is a Cn object) is compatible with mat (which is a gᵐᵃᵗ{S} object).

iscompatible(mat::gᵐᵃᵗ{S}, C::Cn)

Judge whether C (which is a Cn object) is compatible with mat (which is a gᵐᵃᵗ{S} object).

iscompatible(ret1::gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S})

Judge whether two gʳᵉᵗ objects are compatible.

iscompatible(ret1::gʳᵉᵗ{S}, ret2::Gʳᵉᵗ{S})

Judge whether the gʳᵉᵗ and Gʳᵉᵗ objects are compatible.

iscompatible(ret1::Gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S})

Judge whether the gʳᵉᵗ and Gʳᵉᵗ objects are compatible.

iscompatible(C::Cn, ret::gʳᵉᵗ{S})

Judge whether C (which is a Cn object) is compatible with ret (which is a gʳᵉᵗ{S} object).

iscompatible(ret::gʳᵉᵗ{S}, C::Cn)

Judge whether C (which is a Cn object) is compatible with ret (which is a gʳᵉᵗ{S} object).

iscompatible(lmix1::gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S})

Judge whether two gˡᵐⁱˣ objects are compatible.

iscompatible(lmix1::gˡᵐⁱˣ{S}, lmix2::Gˡᵐⁱˣ{S})

Judge whether the gˡᵐⁱˣ and Gˡᵐⁱˣ objects are compatible.

iscompatible(lmix1::Gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S})

Judge whether the gˡᵐⁱˣ and Gˡᵐⁱˣ objects are compatible.

iscompatible(C::Cn, lmix::gˡᵐⁱˣ{S})

Judge whether C (which is a Cn object) is compatible with lmix (which is a gˡᵐⁱˣ{S} object).

iscompatible(lmix::gˡᵐⁱˣ{S}, C::Cn)

Judge whether C (which is a Cn object) is compatible with lmix (which is a gˡᵐⁱˣ{S} object).

iscompatible(less1::gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S})

Judge whether two gˡᵉˢˢ objects are compatible.

iscompatible(less1::gˡᵉˢˢ{S}, less2::Gˡᵉˢˢ{S})

Judge whether the gˡᵉˢˢ and Gˡᵉˢˢ objects are compatible.

iscompatible(less1::Gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S})

Judge whether the gˡᵉˢˢ and Gˡᵉˢˢ objects are compatible.

iscompatible(C::Cn, less::gˡᵉˢˢ{S})

Judge whether C (which is a Cn object) is compatible with less (which is a gˡᵉˢˢ{S} object).

iscompatible(less::gˡᵉˢˢ{S}, C::Cn)

Judge whether C (which is a Cn object) is compatible with less (which is a gˡᵉˢˢ{S} object).

density(cfm::ℱ{T}, tstp::I64)

Returns the density matrix at given time step tstp. If tstp = 0, it denotes the equilibrium state. However, when tstp > 0, it means the nonequilibrium state.

See also: Gᵐᵃᵗ, Gˡᵉˢˢ.

density(cfv::𝒻{S}, tstp::I64)

Returns the density matrix at given time step tstp. If tstp = 0, it denotes the equilibrium state. However, when tstp > 0, it means the nonequilibrium state.

See also: gᵐᵃᵗ, gˡᵉˢˢ.

distance(mat1::Gᵐᵃᵗ{T}, mat2::Gᵐᵃᵗ{T})

Calculate distance between two Gᵐᵃᵗ objects.

distance(ret1::Gʳᵉᵗ{T}, ret2::Gʳᵉᵗ{T}, tstp::I64)

Calculate distance between two Gʳᵉᵗ objects at given time step tstp.

distance(lmix1::Gˡᵐⁱˣ{T}, lmix2::Gˡᵐⁱˣ{T}, tstp::I64)

Calculate distance between two Gˡᵐⁱˣ objects at given time step tstp.

distance(less1::Gˡᵉˢˢ{T}, less2::Gˡᵉˢˢ{T}, tstp::I64)

Calculate distance between two Gˡᵉˢˢ objects at given time step tstp.

distance(cfm1::ℱ{T}, cfm2::ℱ{T}, tstp::I64)

Calculate distance between two ℱ objects at given time step tstp.

distance(mat1::gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S})

Calculate distance between two gᵐᵃᵗ objects.

distance(mat1::gᵐᵃᵗ{S}, mat2::Gᵐᵃᵗ{S})

Calculate distance between a gᵐᵃᵗ object and a Gᵐᵃᵗ object.

distance(mat1::Gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S})

Calculate distance between a gᵐᵃᵗ object and a Gᵐᵃᵗ object.

distance(ret1::gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S})

Calculate distance between two gʳᵉᵗ objects.

distance(ret1::gʳᵉᵗ{S}, ret2::Gʳᵉᵗ{S}, tstp::I64)

Calculate distance between a gʳᵉᵗ object and a Gʳᵉᵗ object at given time step tstp.

distance(ret1::Gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S}, tstp::I64)

Calculate distance between a gʳᵉᵗ object and a Gʳᵉᵗ object at given time step tstp.

distance(lmix1::gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S})

Calculate distance between two gˡᵐⁱˣ objects.

distance(lmix1::gˡᵐⁱˣ{S}, lmix2::Gˡᵐⁱˣ{S}, tstp::I64)

Calculate distance between a gˡᵐⁱˣ object and a Gˡᵐⁱˣ object at given time step tstp.

distance(lmix1::Gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S}, tstp::I64)

Calculate distance between a gˡᵐⁱˣ object and a Gˡᵐⁱˣ object at given time step tstp.

distance(less1::gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S})

Calculate distance between two gˡᵉˢˢ objects.

distance(less1::gˡᵉˢˢ{S}, less2::Gˡᵉˢˢ{S}, tstp::I64)

Calculate distance between a gˡᵉˢˢ object and a Gˡᵉˢˢ object at given time step tstp.

distance(less1::Gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S}, tstp::I64)

Calculate distance between a gˡᵉˢˢ object and a Gˡᵉˢˢ object at given time step tstp.

distance(cfv1::𝒻{S}, cfv2::𝒻{S}, tstp::I64)

Calculate distance between two 𝒻 objects at given time step tstp.

distance(cfv1::𝒻{S}, cfm2::ℱ{S}, tstp::I64)

Calculate distance between a 𝒻 object and a ℱ object at given time step tstp.

distance(cfm1::ℱ{S}, cfv2::𝒻{S}, tstp::I64)

Calculate distance between a 𝒻 object and a ℱ object at given time step tstp.

memset!(cf::Cf{T}, x)

Reset all the matrix elements of cf to x. x should be a scalar number.

memset!(mat::Gᵐᵃᵗ{T}, x)

Reset all the matrix elements of mat to x. x should be a scalar number.

memset!(ret::Gʳᵉᵗ{T}, x)

Reset all the matrix elements of ret to x. x should be a scalar number.

memset!(ret::Gʳᵉᵗ{T}, tstp::I64, x)

Reset the matrix elements of ret at given time step tstp (and at all t where t < tstp) to x. x should be a scalar number.

memset!(lmix::Gˡᵐⁱˣ{T}, x)

Reset all the matrix elements of lmix to x. x should be a scalar number.

memset!(lmix::Gˡᵐⁱˣ{T}, tstp::I64, x)

Reset the matrix elements of lmix at given time step tstp to x. x should be a scalar number.

memset!(less::Gˡᵉˢˢ{T}, x)

Reset all the matrix elements of less to x. x should be a scalar number.

memset!(less::Gˡᵉˢˢ{T}, tstp::I64, x)

Reset the matrix elements of less at given time step tstp (and at all t where t < tstp) to x. x should be a scalar number.

memset!(cfm::ℱ{T}, x)

Reset all the matrix elements of cfm to x. x should be a scalar number.

memset!(cfm::ℱ{T}, tstp::I64, x)

Reset the matrix elements of cfm at given time step tstp to x. x should be a scalar number. Note that tstp = 0 means the equilibrium state, at this time this function will reset the Matsubara component only (mat). However, when tstp > 0, the ret, lmix, and less components will be changed.

memset!(mat::gᵐᵃᵗ{S}, x)

Reset all the vector elements of mat to x. x should be a scalar number.

memset!(ret::gʳᵉᵗ{S}, x)

Reset all the vector elements of ret to x. x should be a scalar number.

memset!(lmix::gˡᵐⁱˣ{S}, x)

Reset all the matrix elements of lmix to x. x should be a scalar number.

memset!(less::gˡᵉˢˢ{S}, x)

Reset all the matrix elements of less to x. x should be a scalar number.

memset!(cfv::𝒻{S}, x)

Reset all the matrix elements of cfv to x. x should be a scalar number.

memset!(cfv::𝒻{S}, tstp::I64, x)

Reset all the matrix elements of cfv to x. x should be a scalar number. If tstp = 0, only the mat component is updated. On the other hand, if tstp > 0, the ret, lmix, and less components will be updated.

zeros!(cf::Cf{T})

Reset all the matrix elements of cf to zero.

zeros!(mat::Gᵐᵃᵗ{T})

Reset all the matrix elements of mat to zero.

zeros!(ret::Gʳᵉᵗ{T})

Reset all the matrix elements of ret to zero.

zeros!(ret::Gʳᵉᵗ{T}, tstp::I64)

Reset the matrix elements of ret at given time step tstp (and at all t where t < tstp) to zero.

zeros!(lmix::Gˡᵐⁱˣ{T})

Reset all the matrix elements of lmix to zero.

zeros!(lmix::Gˡᵐⁱˣ{T}, tstp::I64)

Reset the matrix elements of lmix at given time step tstp to zero.

zeros!(less::Gˡᵉˢˢ{T})

Reset all the matrix elements of less to zero.

zeros!(less::Gˡᵉˢˢ{T}, tstp::I64)

Reset the matrix elements of less at given time step tstp (and at all t where t < tstp) to zero.

zeros!(cfm::ℱ{T})

Reset all the matrix elements of cfm to zero.

zeros!(cfm::ℱ{T}, tstp::I64)

Reset the matrix elements of cfm at given time step tstp to zero.

zeros!(mat::gᵐᵃᵗ{S})

Reset all the vector elements of mat to zero.

zeros!(ret::gʳᵉᵗ{S})

Reset all the vector elements of ret to zero.

zeros!(lmix::gˡᵐⁱˣ{S})

Reset all the matrix elements of lmix to zero.

zeros!(less::gˡᵉˢˢ{S})

Reset all the matrix elements of less to zero.

zeros!(cfv::𝒻{S})

Reset all the matrix elements of cfv to zero.

zeros!(cfv::𝒻{S}, tstp::I64)

Reset all the matrix elements of cfv to zero at given time step tstp.

memcpy!(src::Cf{T}, dst::Cf{T})

Copy all the matrix elements from src to dst.

memcpy!(src::Gᵐᵃᵗ{T}, dst::Gᵐᵃᵗ{T})

Copy all the matrix elements from src to dst.

memcpy!(src::Gʳᵉᵗ{T}, dst::Gʳᵉᵗ{T})

Copy all the matrix elements from src to dst.

memcpy!(src::Gʳᵉᵗ{T}, dst::Gʳᵉᵗ{T}, tstp::I64)

Copy some matrix elements from src to dst. Only the matrix elements at given time step tstp (and at all t where t < tstp) are copied.

memcpy!(src::Gˡᵐⁱˣ{T}, dst::Gˡᵐⁱˣ{T})

Copy all the matrix elements from src to dst.

memcpy!(src::Gˡᵐⁱˣ{T}, dst::Gˡᵐⁱˣ{T}, tstp::I64)

Copy some matrix elements from src to dst. Only the matrix elements at given time step tstp are copied.

memcpy!(src::Gˡᵉˢˢ{T}, dst::Gˡᵉˢˢ{T})

Copy all the matrix elements from src to dst.

memcpy!(src::Gˡᵉˢˢ{T}, dst::Gˡᵉˢˢ{T}, tstp::I64)

Copy some matrix elements from src to dst. Only the matrix elements at given time step tstp (and at all t where t < tstp) are copied.

memcpy!(src::ℱ{T}, dst::ℱ{T}, tstp::I64)

Copy contour Green's function at given time step tstp. Note that tstp = 0 means the equilibrium state, at this time this function will copy the Matsubara component only (mat). However, when tstp > 0, the ret, lmix, and less components will be copied.

memcpy!(src::gᵐᵃᵗ{S}, dst::gᵐᵃᵗ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::Gᵐᵃᵗ{S}, dst::gᵐᵃᵗ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::gᵐᵃᵗ{S}, dst::Gᵐᵃᵗ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::gʳᵉᵗ{S}, dst::gʳᵉᵗ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::Gʳᵉᵗ{S}, dst::gʳᵉᵗ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::gʳᵉᵗ{S}, dst::Gʳᵉᵗ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::gˡᵐⁱˣ{S}, dst::gˡᵐⁱˣ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::Gˡᵐⁱˣ{S}, dst::gˡᵐⁱˣ{S}, tstp::I64)

Copy all the matrix elements from src to dst.

memcpy!(src::gˡᵐⁱˣ{S}, dst::Gˡᵐⁱˣ{S}, tstp::I64)

Copy all the matrix elements from src to dst.

memcpy!(src::gˡᵉˢˢ{S}, dst::gˡᵉˢˢ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::Gˡᵉˢˢ{S}, dst::gˡᵉˢˢ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::gˡᵉˢˢ{S}, dst::Gˡᵉˢˢ{S})

Copy all the matrix elements from src to dst.

memcpy!(src::𝒻{S}, dst::𝒻{S}, tstp::I64)

Extract data from a 𝒻 object (at given time step tstp), then copy them to another 𝒻 object.

See also: 𝒻.

memcpy!(cfm::ℱ{S}, cfv::𝒻{S}, tstp::I64)

Extract data from a ℱ object (at given time step tstp), then copy them to a 𝒻 object.

See also: ℱ, 𝒻.

memcpy!(cfv::𝒻{S}, cfm::ℱ{S}, tstp::I64)

Extract data from a 𝒻 object, then copy them to a ℱ object (at given time step tstp).

See also: ℱ, 𝒻.

incr!(cf1::Cf{T}, cf2::Cf{T}, α::T)

Add a Cf with given weight (α) to another Cf. Finally, cf1 will be changed.

incr!(mat1::Gᵐᵃᵗ{T}, mat2::Gᵐᵃᵗ{T}, α::T)

Add a Gᵐᵃᵗ with given weight (α) to another Gᵐᵃᵗ.

\[G^M_1 ⟶ G^M_1 + α * G^M_2.\]

incr!(ret1::Gʳᵉᵗ{T}, ret2::Gʳᵉᵗ{T}, tstp::I64, α::T)

Add a Gʳᵉᵗ with given weight (α) at given time step tstp (and at all t where t < tstp) to another Gʳᵉᵗ.

incr!(lmix1::Gˡᵐⁱˣ{T}, lmix2::Gˡᵐⁱˣ{T}, tstp::I64, α::T)

Add a Gˡᵐⁱˣ with given weight (α) at given time step tstp to another Gˡᵐⁱˣ.

incr!(less1::Gˡᵉˢˢ{T}, less2::Gˡᵉˢˢ{T}, tstp::I64, α::T)

Add a Gˡᵉˢˢ with given weight (α) at given time step tstp (and at all t where t < tstp) to another Gˡᵉˢˢ.

incr!(cfm1::ℱ{T}, cfm2::ℱ{T}, tstp::I64, α)

Adds a ℱ with given weight (α) to another ℱ (at given time step tstp).

incr!(cfm1::ℱ{T}, cfm2::ℱ{T}, α)

Adds a ℱ with given weight (α) to another ℱ (at all possible time step tstp).

incr!(mat1::gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S}, α::S)

Add a gᵐᵃᵗ with given weight (α) to another gᵐᵃᵗ.

incr!(mat1::Gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S}, α::S)

Add a gᵐᵃᵗ with given weight (α) to a Gᵐᵃᵗ.

incr!(mat1::gᵐᵃᵗ{S}, mat2::Gᵐᵃᵗ{S}, α::S)

Add a Gᵐᵃᵗ with given weight (α) to a gᵐᵃᵗ.

incr!(ret1::gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S}, α::S)

Add a gʳᵉᵗ with given weight (α) to another gʳᵉᵗ.

incr!(ret1::Gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S}, α::S)

Add a gʳᵉᵗ with given weight (α) to a Gʳᵉᵗ.

incr!(ret1::gʳᵉᵗ{S}, ret2::Gʳᵉᵗ{S}, α::S)

Add a Gʳᵉᵗ with given weight (α) to a gʳᵉᵗ.

incr!(lmix1::gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S}, α::S)

Add a gˡᵐⁱˣ with given weight (α) to another gˡᵐⁱˣ.

incr!(lmix1::Gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S}, tstp::I64, α::S)

Add a gˡᵐⁱˣ with given weight (α) to a Gˡᵐⁱˣ.

incr!(lmix1::gˡᵐⁱˣ{S}, lmix2::Gˡᵐⁱˣ{S}, tstp::I64, α::S)

Add a Gˡᵐⁱˣ with given weight (α) to a gˡᵐⁱˣ.

incr!(less1::gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S}, α::S)

Add a gˡᵉˢˢ with given weight (α) to another gˡᵉˢˢ.

incr!(less1::Gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S}, α::S)

Add a gˡᵉˢˢ with given weight (α) to a Gˡᵉˢˢ.

incr!(less1::gˡᵉˢˢ{S}, less2::Gˡᵉˢˢ{S}, α::S)

Add a Gˡᵉˢˢ with given weight (α) to a gˡᵉˢˢ.

incr!(cfv1::𝒻{S}, cfv2::𝒻{S}, tstp::I64, α)

Adds a 𝒻 with given weight (α) to another 𝒻 (at given time step tstp).

incr!(cfm::ℱ{S}, cfv::𝒻{S}, tstp::I64, α)

Adds a 𝒻 with given weight (α) to a ℱ (at given time step tstp).

incr!(cfv::𝒻{S}, cfm::ℱ{S}, tstp::I64, α)

Adds a ℱ with given weight (α) to a 𝒻 (at given time step tstp).

smul!(cf::Cf{T}, α::T)

Multiply a Cf with given weight (α).

smul!(x::Element{T}, cf::Cf{T})

Left multiply a Cf with given weight (x).

smul!(cf::Cf{T}, x::Element{T})

Right multiply a Cf with given weight (x).

smul!(mat::Gᵐᵃᵗ{T}, α::T)

Multiply a Gᵐᵃᵗ with given weight (α).

\[G^M ⟶ α * G^M.\]

smul!(x::Element{T}, mat::Gᵐᵃᵗ{T})

Left multiply a Gᵐᵃᵗ with given weight (x), which is actually a matrix.

smul!(mat::Gᵐᵃᵗ{T}, x::Element{T})

Right multiply a Gᵐᵃᵗ with given weight (x), which is actually a matrix.

smul!(ret::Gʳᵉᵗ{T}, tstp::I64, α::T)

Multiply a Gʳᵉᵗ with given weight (α) at given time step tstp (and at all t where t < tstp).

smul!(x::Element{T}, ret::Gʳᵉᵗ{T}, tstp::I64)

Left multiply a Gʳᵉᵗ with given weight (x) at given time step tstp (and at all t where t < tstp).

smul!(ret::Gʳᵉᵗ{T}, x::Cf{T}, tstp::I64)

Right multiply a Gʳᵉᵗ with given weight (x) at given time step tstp (and at all t where t < tstp).

smul!(lmix::Gˡᵐⁱˣ{T}, tstp::I64, α::T)

Multiply a Gˡᵐⁱˣ with given weight (α) at given time step tstp.

smul!(x::Element{T}, lmix::Gˡᵐⁱˣ{T}, tstp::I64)

Left multiply a Gˡᵐⁱˣ with given weight (x) at given time step tstp.

smul!(lmix::Gˡᵐⁱˣ{T}, x::Element{T}, tstp::I64)

Right multiply a Gˡᵐⁱˣ with given weight (x) at given time step tstp.

smul!(less::Gˡᵉˢˢ{T}, tstp::I64, α::T)

Multiply a Gˡᵉˢˢ with given weight (α) at given time step tstp (and at all t where t < tstp).

smul!(x::Cf{T}, less::Gˡᵉˢˢ{T}, tstp::I64)

Left multiply a Gˡᵉˢˢ with given weight (x) at given time step tstp (and at all t where t < tstp).

smul!(less::Gˡᵉˢˢ{T}, x::Element{T}, tstp::I64)

Right multiply a Gˡᵉˢˢ with given weight (x) at given time step tstp (and at all t where t < tstp).

smul!(cfm::ℱ{T}, tstp::I64, α)

Multiply a ℱ with given weight (α) at given time step tstp.

smul!(cff::Cf{T}, cfm::ℱ{T}, tstp::I64)

Left multiply a ℱ with given weight (Cf) at given time step tstp.

smul!(cfm::ℱ{T}, cff::Cf{T}, tstp::I64)

Right multiply a ℱ with given weight (Cf) at given time step tstp.

smul!(mat::gᵐᵃᵗ{S}, α::S)

Multiply a gᵐᵃᵗ with given weight (α).

smul!(x::Element{S}, mat::gᵐᵃᵗ{S})

Left multiply a gᵐᵃᵗ with given weight (x).

smul!(mat::gᵐᵃᵗ{S}, x::Element{S})

Right multiply a gᵐᵃᵗ with given weight (x).

smul!(ret::gʳᵉᵗ{S}, α::S)

Multiply a gʳᵉᵗ with given weight (α).

smul!(x::Element{S}, ret::gʳᵉᵗ{S})

Left multiply a gʳᵉᵗ with given weight (x).

smul!(ret::gʳᵉᵗ{S}, x::Cf{S})

Right multiply a gʳᵉᵗ with given weight (x).

smul!(lmix::gˡᵐⁱˣ{S}, α::S)

Multiply a gˡᵐⁱˣ with given weight (α).

smul!(x::Element{S}, lmix::gˡᵐⁱˣ{S})

Left multiply a gˡᵐⁱˣ with given weight (x).

smul!(lmix::gˡᵐⁱˣ{S}, x::Element{S})

Right multiply a gˡᵐⁱˣ with given weight (x).

smul!(less::gˡᵉˢˢ{S}, α::S)

Multiply a gˡᵉˢˢ with given weight (α).

smul!(x::Cf{S}, less::gˡᵉˢˢ{S})

Left multiply a gˡᵉˢˢ with given weight (x).

smul!(less::gˡᵉˢˢ{S}, x::Element{S})

Right multiply a gˡᵉˢˢ with given weight (x).

smul!(cfv::𝒻{S}, tstp::I64, α)

Multiply a 𝒻 with given weight (α) at given time step tstp.

smul!(cff::Cf{S}, cfv::𝒻{S}, tstp::I64)

Left multiply a 𝒻 with given weight (Cf) at given time step tstp.

smul!(cfv::𝒻{S}, cff::Cf{S}, tstp::I64)

Right multiply a 𝒻 with given weight (Cf) at given time step tstp.

read!(fname::AbstractString, cfm::ℱ{T})

Read the contour Green's functions from given file.

read!(fname::AbstractString, cfv::𝒻{S})

Read the contour Green's functions from given file.

write(fname::AbstractString, cfm::ℱ{T})

Write the contour Green's functions to given file.

write(fname::AbstractString, cfv::𝒻{S})

Write the contour Green's functions to given file.

Base.getindex(cf::Cf{T}, i::I64)

Visit the element stored in Cf object. If i = 0, it returns the element at Matsubara axis. On the other hand, if i > 0, it will return elements at real time axis.

Base.getindex(mat::Gᵐᵃᵗ{T}, ind::I64)

Visit the element stored in Gᵐᵃᵗ object.

Base.getindex(ret::Gʳᵉᵗ{T}, i::I64, j::I64)

Visit the element stored in Gʳᵉᵗ object. Here i and j are indices for real times.

Base.getindex(lmix::Gˡᵐⁱˣ{T}, i::I64, j::I64)

Visit the element stored in Gˡᵐⁱˣ object.

Base.getindex(less::Gˡᵉˢˢ{T}, i::I64, j::I64)

Visit the element stored in Gˡᵉˢˢ object.

Base.getindex(matm::Gᵐᵃᵗᵐ{T}, ind::I64)

Visit the element stored in Gᵐᵃᵗᵐ object.

Base.getindex(adv::Gᵃᵈᵛ{T}, ind::I64)

Visit the element stored in Gᵃᵈᵛ object.

Base.getindex(rmix::Gʳᵐⁱˣ{T}, i::I64, j::I64)

Visit the element stored in Gʳᵐⁱˣ object.

Base.getindex(gtr::Gᵍᵗʳ{T}, i::I64, j::I64)

Visit the element stored in Gᵍᵗʳ object.

Base.getindex(mat::gᵐᵃᵗ{S}, ind::I64)

Visit the element stored in gᵐᵃᵗ object.

Base.getindex(ret::gʳᵉᵗ{S}, j::I64)

Visit the element stored in gʳᵉᵗ object. Here j is index for real times.

Base.getindex(ret::gʳᵉᵗ{S}, i::I64, tstp::I64)

Visit the element stored in gʳᵉᵗ object. Here i is index for real times.

Base.getindex(lmix::gˡᵐⁱˣ{S}, j::I64)

Visit the element stored in gˡᵐⁱˣ object.

Base.getindex(less::gˡᵉˢˢ{S}, i::I64)

Visit the element stored in gˡᵉˢˢ object.

Base.getindex(less::gˡᵉˢˢ{S}, tstp::I64, j::I64)

Visit the element stored in gˡᵉˢˢ object.

Base.getindex(matm::gᵐᵃᵗᵐ{S}, ind::I64)

Visit the element stored in gᵐᵃᵗᵐ object.

Base.getindex(adv::gᵃᵈᵛ{S}, ind::I64)

Visit the element stored in gᵃᵈᵛ object.

Base.getindex(rmix::gʳᵐⁱˣ{S}, i::I64)

Visit the element stored in gʳᵐⁱˣ object.

Base.getindex(gtr::gᵍᵗʳ{S}, i::I64)

Visit the element stored in gᵍᵗʳ object.

Base.getindex(gtr::gᵍᵗʳ{S}, tstp::I64, j::I64)

Visit the element stored in gᵍᵗʳ object.

Base.getindex(cfm::ℱ{T}, tstp::I64)

Return contour Green's function at given time step tstp.

See also: ℱ, 𝒻.

Base.getindex(AW::AbstractWeights, inds::Vararg{I64})

Provide a fast access to the weights. AW denotes the type of weights, and inds is for the indices. This function works for the following structs only:

• PolynomialInterpolationWeights
• PolynomialDifferentiationWeights
• PolynomialIntegrationWeights
• BackwardDifferentiationWeights
• BoundaryConvolutionWeights

Base.getindex(GW::GregoryIntegrationWeights, inds::Vararg{I64})

Provide a fast access to the weights. GW denotes the type of weights, and inds is for the indices. This function works for the following structs only:

• GregoryIntegrationWeights

References :

See Remarks : Gregory Integration.

Base.setindex!(cf::Cf{T}, x::Element{T}, i::I64)

Setup the element in Cf object. If i = 0, it will setup the element at Matsubara axis to x. On the other hand, if i > 0, it will setup elements at real time axis.

Base.setindex!(cf::Cf{T}, v::T, i::I64)

Setup the element in Cf object. If i = 0, it will setup the element at Matsubara axis to v. On the other hand, if i > 0, it will setup elements at real time axis. Here, v should be a scalar number.

Base.setindex!(mat::Gᵐᵃᵗ{T}, x::Element{T}, ind::I64)

Setup the element in Gᵐᵃᵗ object.

Base.setindex!(mat::Gᵐᵃᵗ{T}, v::T, ind::I64)

Setup the element in Gᵐᵃᵗ object.

Base.setindex!(ret::Gʳᵉᵗ{T}, x::Element{T}, i::I64, j::I64)

Setup the element in Gʳᵉᵗ object.

Base.setindex!(ret::Gʳᵉᵗ{T}, v::T, i::I64, j::I64)

Setup the element in Gʳᵉᵗ object.

Base.setindex!(lmix::Gˡᵐⁱˣ{T}, x::Element{T}, i::I64, j::I64)

Setup the element in Gˡᵐⁱˣ object.

Base.setindex!(lmix::Gˡᵐⁱˣ{T}, v::T, i::I64, j::I64)

Setup the element in Gˡᵐⁱˣ object.

Base.setindex!(less::Gˡᵉˢˢ{T}, x::Element{T}, i::I64, j::I64)

Setup the element in Gˡᵉˢˢ object.

Base.setindex!(less::Gˡᵉˢˢ{T}, v::T, i::I64, j::I64)

Setup the element in Gˡᵉˢˢ object.

Base.setindex!(mat::gᵐᵃᵗ{S}, x::Element{S}, ind::I64)

Setup the element in gᵐᵃᵗ object.

Base.setindex!(mat::gᵐᵃᵗ{S}, v::S, ind::I64)

Setup the element in gᵐᵃᵗ object.

Base.setindex!(ret::gʳᵉᵗ{S}, x::Element{S}, j::I64)

Setup the element in gʳᵉᵗ object.

Base.setindex!(ret::gʳᵉᵗ{S}, v::S, j::I64)

Setup the element in gʳᵉᵗ object.

Base.setindex!(lmix::gˡᵐⁱˣ{S}, x::Element{S}, j::I64)

Setup the element in gˡᵐⁱˣ object.

Base.setindex!(lmix::gˡᵐⁱˣ{S}, v::S, j::I64)

Setup the element in gˡᵐⁱˣ object.

Base.setindex!(less::gˡᵉˢˢ{S}, x::Element{S}, i::I64)

Setup the element in gˡᵉˢˢ object.

Base.setindex!(less::gˡᵉˢˢ{S}, v::S, i::I64)

Setup the element in gˡᵉˢˢ object.

Base.setindex!(cfm::ℱ{S}, cfv::𝒻{S}, tstp::I64)

Setup contout Green's function at given time step tstp.

See also: ℱ, 𝒻.

Base.getproperty(cfm::ℱ{T}, symbol::Symbol)

Visit the properties stored in ℱ object. It provides access to the Matsubara (minus, matm), advanced (adv), right-mixing (rmix), and greater (gtr) components of the contour-ordered Green's function.

Base.getproperty(cfv::𝒻{S}, symbol::Symbol)

Visit the properties stored in 𝒻 object. It provides access to the Matsubara (minus, matm), advanced (adv), right-mixing (rmix), and greater (gtr) components of the contour-ordered Green's function at given time step tstp..

Base.show(io::IO, C::Cn)

Display Cn struct on the terminal.

See also: Cn.

Base.:+(cf1::Cf{T}, cf2::Cf{T})

Operation + for two Cf objects.

Base.:+(mat1::Gᵐᵃᵗ{T}, mat2::Gᵐᵃᵗ{T})

Operation + for two Gᵐᵃᵗ objects.

Base.:+(ret1::Gʳᵉᵗ{T}, ret2::Gʳᵉᵗ{T})

Operation + for two Gʳᵉᵗ objects.

Base.:+(lmix1::Gˡᵐⁱˣ{T}, lmix2::Gˡᵐⁱˣ{T})

Operation + for two Gˡᵐⁱˣ objects.

Base.:+(less1::Gˡᵉˢˢ{T}, less2::Gˡᵉˢˢ{T})

Operation + for two Gˡᵉˢˢ objects.

Base.:+(mat1::gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S})

Operation + for two gᵐᵃᵗ objects.

Base.:+(ret1::gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S})

Operation + for two gʳᵉᵗ objects.

Base.:+(lmix1::gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S})

Operation + for two gˡᵐⁱˣ objects.

Base.:+(less1::gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S})

Operation + for two gˡᵉˢˢ objects.

Base.:-(cf1::Cf{T}, cf2::Cf{T})

Operation - for two Cf objects.

Base.:-(mat1::Gᵐᵃᵗ{T}, mat2::Gᵐᵃᵗ{T})

Operation - for two Gᵐᵃᵗ objects.

Base.:-(ret1::Gʳᵉᵗ{T}, ret2::Gʳᵉᵗ{T})

Operation - for two Gʳᵉᵗ objects.

Base.:-(lmix1::Gˡᵐⁱˣ{T}, lmix2::Gˡᵐⁱˣ{T})

Operation - for two Gˡᵐⁱˣ objects.

Base.:-(less1::Gˡᵉˢˢ{T}, less2::Gˡᵉˢˢ{T})

Operation - for two Gˡᵉˢˢ objects.

Base.:-(mat1::gᵐᵃᵗ{S}, mat2::gᵐᵃᵗ{S})

Operation - for two gᵐᵃᵗ objects.

Base.:-(ret1::gʳᵉᵗ{S}, ret2::gʳᵉᵗ{S})

Operation - for two gʳᵉᵗ objects.

Base.:-(lmix1::gˡᵐⁱˣ{S}, lmix2::gˡᵐⁱˣ{S})

Operation - for two gˡᵐⁱˣ objects.

Base.:-(less1::gˡᵉˢˢ{S}, less2::gˡᵉˢˢ{S})

Operation - for two gˡᵉˢˢ objects.

Base.:*(cf::Cf{T}, x)

Operation * for a Cf object and a scalar value.

Base.:*(x, cf::Cf{T})

Operation * for a scalar value and a Cf object.

Base.:*(mat::Gᵐᵃᵗ{T}, x)

Operation * for a Gᵐᵃᵗ object and a scalar value.

Base.:*(x, mat::Gᵐᵃᵗ{T})

Operation * for a scalar value and a Gᵐᵃᵗ object.

Base.:*(ret::Gʳᵉᵗ{T}, x)

Operation * for a Gʳᵉᵗ object and a scalar value.

Base.:*(x, ret::Gʳᵉᵗ{T})

Operation * for a scalar value and a Gʳᵉᵗ object.

Base.:*(lmix::Gˡᵐⁱˣ{T}, x)

Operation * for a Gˡᵐⁱˣ object and a scalar value.

Base.:*(x, lmix::Gˡᵐⁱˣ{T})

Operation * for a scalar value and a Gˡᵐⁱˣ object.

Base.:*(less::Gˡᵉˢˢ{T}, x)

Operation * for a Gˡᵉˢˢ object and a scalar value.

Base.:*(x, less::Gˡᵉˢˢ{T})

Operation * for a scalar value and a Gˡᵉˢˢ object.

Base.:*(mat::gᵐᵃᵗ{S}, x)

Operation * for a gᵐᵃᵗ object and a scalar value.

Base.:*(x, mat::gᵐᵃᵗ{S})

Operation * for a scalar value and a gᵐᵃᵗ object.

Base.:*(ret::gʳᵉᵗ{S}, x)

Operation * for a gʳᵉᵗ object and a scalar value.

Base.:*(x, ret::gʳᵉᵗ{S})

Operation * for a scalar value and a gʳᵉᵗ object.

Base.:*(lmix::gˡᵐⁱˣ{S}, x)

Operation * for a gˡᵐⁱˣ object and a scalar value.

Base.:*(x, lmix::gˡᵐⁱˣ{S})

Operation * for a scalar value and a gˡᵐⁱˣ object.

Base.:*(less::gˡᵉˢˢ{S}, x)

Operation * for a gˡᵉˢˢ object and a scalar value.

Base.:*(x, less::gˡᵉˢˢ{S})

Operation * for a scalar value and a gˡᵉˢˢ object.