GitHub

Vector spaces

RadiiPolynomial defines a variety of vector spaces to represent the Banach space on which one applies the Radii Polynomial Theorem.

All spaces mentioned below are a subtype of the abstract type VectorSpace.

VectorSpace
├─ CartesianSpace
│  ├─ CartesianPower
│  └─ CartesianProduct
├─ ParameterSpace
└─ SequenceSpace
   ├─ BaseSpace
   │  ├─ Chebyshev
   │  ├─ Fourier
   │  └─ Taylor
   └─ TensorSpace

Parameter space

A ParameterSpace represents the commutative field of a parameter. This is the standard space to use for an unfolding parameter.

julia> 𝒫 = ParameterSpace()𝕂
julia> dimension(𝒫)1
julia> indices(𝒫)Base.OneTo(1)

Sequence space

SequenceSpace is the abstract type for all sequence spaces.

SequenceSpace
├─ BaseSpace
│  ├─ Chebyshev
│  ├─ Fourier
│  └─ Taylor
└─ TensorSpace

BaseSpace

BaseSpace is the abstract type for all sequence spaces that are not a TensorSpace but can be interlaced to form one.

BaseSpace
├─ Chebyshev
├─ Fourier
└─ Taylor

Taylor

For a given order $n$, a Taylor sequence space is the span of $\{\phi_0, \dots, \phi_n\}$ where $\phi_k(t) \bydef t^k$ for $k = 0, \dots, n$ and $t \in [-\nu, \nu]$ for some appropriate $\nu > 0$.

julia> 𝒯 = Taylor(1)Taylor(1)
julia> order(𝒯)1
julia> dimension(𝒯)2
julia> indices(𝒯)0:1

Fourier

For a given order $n$ and frequency $\omega$, a Fourier sequence space is the span of $\{\phi_{-n}, \dots, \phi_n\}$ where $\phi_k(t) \bydef e^{i \omega k t}$ for $k = -n, \dots, n$ and $t \in \mathbb{R}/2\pi\omega^{-1}\mathbb{Z}$.

julia> ℱ = Fourier(1, 1.0)Fourier(1, 1.0)
julia> order(ℱ)1
julia> frequency(ℱ)1.0
julia> dimension(ℱ)3
julia> indices(ℱ)-1:1

Chebyshev

For a given order $n$, a Chebyshev sequence space is the span of $\{\phi_0, \phi_1, \dots, \phi_n\}$ where $\phi_0(t) \bydef 1$, $\phi_1(t) \bydef t$ and $\phi_k(t) \bydef 2 t \phi_{k-1}(t) - \phi_{k-2}(t)$ for $k = 2, \dots, n$ and $t \in [-1, 1]$.

It is important to note that the coefficients $\{a_0, a_1, \dots, a_n\}$ associated with a Chebyshev space are normalized such that $\{a_0, 2a_1, \dots, 2a_n\}$ are the actual Chebyshev coefficients.

julia> 𝒞 = Chebyshev(1)Chebyshev(1)
julia> order(𝒞)1
julia> dimension(𝒞)2
julia> indices(𝒞)0:1

Tensor space

A TensorSpace is the tensor product of some BaseSpace. The standard constructor for TensorSpace is the ⊗ (\otimes<tab>) operator.

julia> 𝒯_otimes_ℱ_otimes_𝒞 = Taylor(1) ⊗ Fourier(1, 1.0) ⊗ Chebyshev(1) # TensorSpace((Taylor(1), Fourier(1, 1.0), Chebyshev(1)))Taylor(1) ⊗ Fourier(1, 1.0) ⊗ Chebyshev(1)
julia> nspaces(𝒯_otimes_ℱ_otimes_𝒞)3
julia> order(𝒯_otimes_ℱ_otimes_𝒞)(1, 1, 1)
julia> frequency(𝒯_otimes_ℱ_otimes_𝒞, 2)1.0
julia> dimension(𝒯_otimes_ℱ_otimes_𝒞)12
julia> dimensions(𝒯_otimes_ℱ_otimes_𝒞)(2, 3, 2)
julia> indices(𝒯_otimes_ℱ_otimes_𝒞)TensorIndices{Tuple{UnitRange{Int64}, UnitRange{Int64}, UnitRange{Int64}}}((0:1, -1:1, 0:1))

Cartesian space

CartesianSpace is the abstract type for all cartesian spaces.

CartesianSpace
├─ CartesianPower
└─ CartesianProduct

Cartesian power

A CartesianPower is the cartesian product of an identical VectorSpace. The standard constructor for CartesianPower is the ^ operator.

julia> 𝒯² = Taylor(1) ^ 2 # CartesianPower(Taylor(1), 2)Taylor(1)²
julia> nspaces(𝒯²)2
julia> dimension(𝒯²)4
julia> indices(𝒯²)Base.OneTo(4)

Cartesian product

A CartesianProduct is the cartesian product of some VectorSpace. The standard constructor for CartesianProduct is the × (\times<tab>) operator.

julia> 𝒫_times_𝒯 = ParameterSpace() × Taylor(1) # CartesianProduct((ParameterSpace(), Taylor(1)))𝕂 × Taylor(1)
julia> nspaces(𝒫_times_𝒯)2
julia> dimension(𝒫_times_𝒯)3
julia> indices(𝒫_times_𝒯)Base.OneTo(3)

API

RadiiPolynomial.CartesianPower — Type
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
source
RadiiPolynomial.CartesianProduct — Type
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
source
RadiiPolynomial.Chebyshev — Type
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
source
RadiiPolynomial.CosFourier — Type
CosFourier{T<:Real} <: SymBaseSpace

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

Field:

  • space :: Fourier{T}

Constructors:

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

Example

julia> s = CosFourier(2, 1.0)
CosFourier(2, 1.0)

julia> order(s)
2

julia> frequency(s)
1.0
source
RadiiPolynomial.EmptySpace — Type
EmptySpace <: VectorSpace

Empty vector space.

Example

julia> EmptySpace()
∅

julia> LinearOperator(EmptySpace(), EmptySpace(), [;;])
LinearOperator : ∅ → ∅ with coefficients Matrix{Any}:
source
RadiiPolynomial.Fourier — Type
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)
2

julia> frequency(s)
1.0
source
RadiiPolynomial.SinFourier — Type
SinFourier{T<:Real} <: SymBaseSpace

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

Field:

  • space :: Fourier{T}

Constructors:

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

Example

julia> s = SinFourier(2, 1.0)
SinFourier(2, 1.0)

julia> order(s)
2

julia> frequency(s)
1.0
source
RadiiPolynomial.Taylor — Type
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
source
RadiiPolynomial.TensorIndices — Type
TensorIndices{<:Tuple}

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))
source
RadiiPolynomial.TensorSpace — Type
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))
source
LinearAlgebra.:× — Method
×(::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> ParameterSpace()^2 × ((Taylor(1) ⊗ Fourier(2, 1.0)) × Chebyshev(3))^3
𝕂² × ((Taylor(1) ⊗ Fourier(2, 1.0)) × Chebyshev(3))³
source
RadiiPolynomial.:⊗ — Method
⊗(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)
source