Vector spaces

BaseSpace <: SequenceSpace

Abstract type for all sequence spaces that are not a TensorSpace but can be interlaced to form one.

CartesianPower{T<:VectorSpace} <: CartesianSpace

Cartesian space resulting from the cartesian product of the same VectorSpace.

Fields:

• space :: T
• n :: Int

Constructors:

• CartesianPower(::VectorSpace, ::Int)
• ^(::VectorSpace, ::Int): equivalent to CartesianPower(::VectorSpace, ::Int)

See also: ^(::VectorSpace, ::Int), CartesianProduct and ×.

Examples

julia> s = CartesianPower(Taylor(1), 3)Taylor(1)³julia> space(s)Taylor(1)julia> nspaces(s)3

CartesianProduct{T<:Tuple{Vararg{VectorSpace}}} <: CartesianSpace

Cartesian space resulting from the cartesian product of some VectorSpace.

Field:

• spaces :: T

Constructors:

• CartesianProduct(::Tuple{Vararg{VectorSpace}})
• CartesianProduct(spaces::VectorSpace...): equivalent to CartesianProduct(spaces)
• ×(s₁::VectorSpace, s₂::VectorSpace): equivalent to CartesianProduct((s₁, s₂))
• ×(s₁::CartesianProduct, s₂::CartesianProduct): equivalent to CartesianProduct((s₁.spaces..., s₂.spaces...))
• ×(s₁::CartesianProduct, s₂::VectorSpace): equivalent to CartesianProduct((s₁.spaces..., s₂))
• ×(s₁::VectorSpace, s₂::CartesianProduct): equivalent to CartesianProduct((s₁, s₂.spaces...))

See also: ×, CartesianPower, ^(::VectorSpace, ::Int).

Examples

julia> s = CartesianProduct(Taylor(1), Fourier(2, 1.0), Chebyshev(3))Taylor(1) × Fourier(2, 1.0) × Chebyshev(3)julia> spaces(s)(Taylor(1), Fourier(2, 1.0), Chebyshev(3))julia> nspaces(s)3

CartesianSpace <: VectorSpace

Abstract type for all cartesian spaces.

Chebyshev <: BaseSpace

Sequence space whose elements are Chebyshev sequences of a prescribed order.

Field:

• order :: Int

Constructor:

• Chebyshev(order::Int)

See also: Taylor and Fourier.

Examples

julia> s = Chebyshev(2)Chebyshev(2)julia> order(s)2

Fourier{T<:Real} <: BaseSpace

Sequence space whose elements are Fourier sequences of a prescribed order and frequency.

Fields:

• order :: Int
• frequency :: T

Constructor:

• Fourier(order::Int, frequency::Real)

See also: Taylor and Chebyshev.

Examples

julia> s = Fourier(2, 1.0)Fourier(2, 1.0)julia> order(s)2julia> frequency(s)1.0

ScalarSpace <: VectorSpace

Parameter space corresponding to a commutative field.

Example

julia> ScalarSpace()𝕂

SequenceSpace <: VectorSpace

Abstract type for all sequence spaces.

Taylor <: BaseSpace

Sequence space whose elements are Taylor sequences of a prescribed order.

Field:

• order :: Int

Constructor:

• Taylor(order::Int)

See also: Fourier and Chebyshev.

Examples

julia> s = Taylor(2)Taylor(2)julia> order(s)2

TensorIndices{T<:Tuple{Vararg{AbstractRange}}}

Multidimentional rectangular range of indices for some TensorSpace.

Examples

julia> TensorIndices((0:2, -1:1))TensorIndices{Tuple{UnitRange{Int64}, UnitRange{Int64}}}((0:2, -1:1))julia> indices(Taylor(2) ⊗ Fourier(1, 1.0))TensorIndices{Tuple{UnitRange{Int64}, UnitRange{Int64}}}((0:2, -1:1))

TensorSpace{T<:Tuple{Vararg{BaseSpace}}} <: SequenceSpace

Sequence space resulting from the tensor product of some BaseSpace.

Field:

• spaces :: T

Constructors:

• TensorSpace(spaces::Tuple{Vararg{BaseSpace}})
• TensorSpace(spaces::BaseSpace...)
• ⊗(s₁::BaseSpace, s₂::BaseSpace): equivalent to TensorSpace((s₁, s₂))
• ⊗(s₁::TensorSpace, s₂::TensorSpace): equivalent to TensorSpace((s₁.spaces..., s₂.spaces...))
• ⊗(s₁::TensorSpace, s₂::BaseSpace): equivalent to TensorSpace((s₁.spaces..., s₂))
• ⊗(s₁::BaseSpace, s₂::TensorSpace): equivalent to TensorSpace((s₁, s₂.spaces...))

See also: ⊗.

Examples

julia> s = TensorSpace(Taylor(1), Fourier(2, 1.0), Chebyshev(3))Taylor(1) ⊗ Fourier(2, 1.0) ⊗ Chebyshev(3)julia> spaces(s)(Taylor(1), Fourier(2, 1.0), Chebyshev(3))

UndefSpace <: VectorSpace

Sentinel vector space flagging an undetermined space, e.g. as returned by domain when an operator has no domain on the given space.

Example

julia> UndefSpace()undefjulia> LinearOperator(UndefSpace(), UndefSpace(), [;;])LinearOperator : undef → undef with coefficients Matrix{Any}:

VectorSpace

Abstract type for all vector spaces.

×(::VectorSpace, ::VectorSpace)
×(::CartesianProduct, ::CartesianProduct)
×(::CartesianProduct, ::VectorSpace)
×(::VectorSpace, ::CartesianProduct)

Create a CartesianProduct from the cartesian product of some VectorSpace.

See also: CartesianProduct, CartesianPower and ^(::VectorSpace, ::Int).

Examples

julia> Taylor(1) × Fourier(2, 1.0)Taylor(1) × Fourier(2, 1.0)julia> Taylor(1) × Fourier(2, 1.0) × Chebyshev(3)Taylor(1) × Fourier(2, 1.0) × Chebyshev(3)julia> (Taylor(1) × Fourier(2, 1.0)) × Chebyshev(3)Taylor(1) × Fourier(2, 1.0) × Chebyshev(3)julia> Taylor(1) × (Fourier(2, 1.0) × Chebyshev(3))Taylor(1) × Fourier(2, 1.0) × Chebyshev(3)julia> ScalarSpace()^2 × ((Taylor(1) ⊗ Fourier(2, 1.0)) × Chebyshev(3))^3𝕂² × ((Taylor(1) ⊗ Fourier(2, 1.0)) × Chebyshev(3))³

⊗(s₁::BaseSpace, s₂::BaseSpace)
⊗(s₁::TensorSpace, s₂::TensorSpace)
⊗(s₁::TensorSpace, s₂::BaseSpace)
⊗(s₁::BaseSpace, s₂::TensorSpace)

Create a TensorSpace from the tensor product of some SequenceSpace.

See also: TensorSpace.

Examples

julia> Taylor(1) ⊗ Fourier(2, 1.0)Taylor(1) ⊗ Fourier(2, 1.0)julia> Taylor(1) ⊗ Fourier(2, 1.0) ⊗ Chebyshev(3)Taylor(1) ⊗ Fourier(2, 1.0) ⊗ Chebyshev(3)julia> Taylor(1) ⊗ (Fourier(2, 1.0) ⊗ Chebyshev(3))Taylor(1) ⊗ Fourier(2, 1.0) ⊗ Chebyshev(3)julia> (Taylor(1) ⊗ Fourier(2, 1.0)) ⊗ Chebyshev(3)Taylor(1) ⊗ Fourier(2, 1.0) ⊗ Chebyshev(3)

Cocycle(amplitude::Number, phase::AbstractVector{Rational{Int}})

The factor $\alpha_g(k) = \rho e^{i\pi\langle\varphi,k\rangle}$ given by an amplitude $\rho$ and a phase $\varphi$ (measured in units of $\pi$ and stored modulo 2).

Together with a LatticeAut $\beta_g$ it defines the right action

\[(g \cdot a)_k = \alpha_g(k) \, a_{\beta_g(k)},\]

under which $\alpha$ is not itself a group action but a 1-cocycle: $\alpha_{gh}(k) = \alpha_g(\beta_h(k))\,\alpha_h(k)$. Since a finite group forces $\alpha_g(k)^{|G|} = 1$, amplitude should be a root of unity.

Fields:

• amplitude :: T
• phase :: SVector{N,Rational{Int}}

See also: LatticeAut and GroupElement.

Group(g::GroupElement, h::GroupElement...)

The group generated by the given elements. It is closed under composition at construction, so elements returns every element and not only the generators.

See also: GroupElement and SymmetricSpace.

GroupElement(lattice_aut::LatticeAut, cocycle::Cocycle)

Combine a LatticeAut $\beta_g$ with the Cocycle $\alpha_g$ so that g defines the right action on a sequence

\[(g \cdot a)_k = \alpha_g(k) \, a_{\beta_g(k)}.\]

Elements compose with ∘.

Fields:

• lattice_aut :: LatticeAut{N}
• cocycle :: Cocycle{N,T}

See also: LatticeAut, Cocycle, Group and SymmetricSpace.

LatticeAut(a::AbstractMatrix{Int})

The automorphism of the index lattice induced by a symmetry, given by an integer matrix. Callable on an index or a tuple of indices.

See also: Cocycle and GroupElement.

SymmetricSpace(space::SequenceSpace, sym::Group)
SymmetricSpace(space::SequenceSpace)

Restriction of space to the subspace invariant under sym, storing one coefficient per orbit. With no group given, the trivial one is used.

indices returns the orbit representatives, so dimension shrinks accordingly, and norms account for the multiplicity of each orbit. Some symmetries are available through evensym, oddsym and d4sym; build a Group directly for anything else.

Fields:

• space :: S
• symmetry :: G

See also: desymmetrize, symmetry and Group.

d4sym(s::TensorSpace{<:Tuple{<:Fourier,<:Fourier}})

Restrict a two-dimensional Fourier space to the subspace invariant under the dihedral group $D_4$, i.e., the symmetries of the square, generated by a quarter turn and a diagonal reflection.

Examples

julia> s = Fourier(2, 1.0) ⊗ Fourier(2, 1.0)Fourier(2, 1.0) ⊗ Fourier(2, 1.0)julia> indices(d4sym(s))6-element Vector{Tuple{Int64, Int64}}: (0, 0) (1, 0) (2, 0) (1, 1) (2, 1) (2, 2)

See also: evensym, oddsym and SymmetricSpace.

desymmetrize(s::VectorSpace)

Return the underlying space of s without its symmetry. Acts as the identity on a space that carries no symmetry.

Examples

julia> desymmetrize(evensym(Fourier(3, 1.0)))Fourier(3, 1.0)julia> desymmetrize(Taylor(2))Taylor(2)

See also: SymmetricSpace and symmetry.

elements(g::Group)

Return the set of GroupElements of g. The group is closed under composition at construction, so this is the full group and not just the generators it was built from.

See also: Group and symmetry.

evensym(s::BaseSpace)

Restrict s to the subspace of sequences invariant under the natural involution of its basis:

• Fourier: identifies the modes k and -k, keeping k ≥ 0 (cosine series).
• Taylor and Chebyshev: keeps the even orders only.

Examples

julia> collect(indices(evensym(Fourier(3, 1.0))))4-element Vector{Int64}: 0 1 2 3julia> collect(indices(evensym(Taylor(4))))3-element Vector{Int64}: 0 2 4

See also: oddsym, d4sym and SymmetricSpace.

oddsym(s::BaseSpace)

Restrict s to the subspace of sequences anti-invariant under the natural involution of its basis:

• Fourier: identifies the modes k and -k together with a sign flip, keeping k > 0 (since series).
• Taylor and Chebyshev: keeps the odd orders only.

Examples

julia> collect(indices(oddsym(Fourier(3, 1.0))))3-element Vector{Int64}: 1 2 3julia> collect(indices(oddsym(Taylor(4))))2-element Vector{Int64}: 1 3

See also: evensym, d4sym and SymmetricSpace.

symmetry(s::VectorSpace)

Return the Group that s is invariant under. A space carrying no symmetry returns the trivial group.

See also: SymmetricSpace, desymmetrize and elements.

^(s::VectorSpace, n::Int)

Create a CartesianPower from n cartesian product(s) of s.

See also: CartesianPower, CartesianProduct, ×.

Examples

julia> Taylor(1)^3Taylor(1)³julia> (Taylor(1)^3)^2(Taylor(1)³)²