AverageZero{B<:Basis}

Yield a basis of the space of average zero vectors

Replacement of DualComposedWithDynamic.

aux_normalized_projection_error(B::Basis)

Return a constant Eh (typically scales as h ~ 1/n) such that

$|||P_h f|||\leq |||f|||+ Eh * ||f||_s$

Must be rounded up correctly!

aux_weak_bound(B::Basis)

Return a constant $M₂$ such that for a vector $v ∈ Uₕ$

$|||v|||\leq M_2||v||$

Must be rounded up correctly!

bound_linalg_norm_L1_from_weak(B::Basis)

Return a constant $A$ such that for a vector $v ∈ Uₕ$

$||v||_1\leq A||v||$

Must be rounded up correctly!

bound_linalg_norm_L∞_from_weak(B::Basis)

Return a constant $A$ such that for a vector $v ∈ Uₕ$ ||v||_\infty \leq A||v|| Must be rounded up correctly!

bound_weak_norm_abstract(B::Basis, D=nothing; dfly_coefficients=nothing)

Returns an a priori bound on the weak norm of the abstract operator $L$

bound_weak_norm_from_linalg_norm(B::Basis)

Return constants W₁, W₂ such that for a vector $v ∈ Uₕ$

$||v||\leq W_1||v||_1+W_2||v||_{\infty}$

Must be rounded up correctly!

evaluate(B::Basis, i, x)

Evaluate the i-th basis element at x

evaluate_integral(B::Basis, i; T = Float64)

Value of the integral on [0,1] of the i-th basis element

integral(B::Basis, v; T = Float64)

Return the integral of the function with coefficients v in the basis B

integral_covector(B::Basis)

Return a covector that represents the integral in the basis B

invariant_measure_strong_norm_bound(B::Basis, D::Dynamic)

Bounds $||u||_s$, where $u$ is the invariant measure normalized with $i(u)=1$.

is_integral_preserving(B::Basis)

Integral-preserving discretizations may specialize this to "true"

is_refinement(Bfine::Basis, Bcoarse::Basis)

Check if Bfine is a refinement of Bcoarse

Example

julia> using RigorousInvariantMeasures

julia> B = Ulam(1024)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 1025))

julia> Bfine = Ulam(2048)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 2049))

julia> is_refinement(Bfine, B)
true

julia> Bfine = Ulam(2049)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 2050))

julia> is_refinement(Bfine, B)
false

one_vector(B::Basis)

Vector that represents the function 1 in the basis B

strong_norm(B::Basis)

Return the type of the strong norm of the basis

Example

julia> using RigorousInvariantMeasures

julia> B = Ulam(1024)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 1025))

julia> strong_norm(B)
TotalVariation

strong_weak_bound(B::Basis)

Return a constant $M₁n$ such that for a vector $v ∈ Uₕ$

$||v||_s\leq M1n*||v||$

Must be rounded up correctly!

Return constants $S₁, S₂$ such that for a vector $v ∈ Uₕ$

$||v||\leq S_1||v||_s+S_2|||v|||$

Must be rounded up correctly!

weak_norm(B::Basis)

Return the type of the weak norm of the basis

Example

julia> using RigorousInvariantMeasures

julia> B = Ulam(1024)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 1025))

julia> weak_norm(B)
L1

weak_projection_error(B::Basis)

Return a constant Kh (typically scales as h ~ 1/n) such that

$||P_h f-f||\leq Kh ||f||_s$

Must be rounded up correctly! This function is not exported explictly but is used in all the estimates.

Example

julia> using RigorousInvariantMeasures;

julia> B = Ulam(1024)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 1025))

julia> RigorousInvariantMeasures.weak_projection_error(B)
0.00048828125

Ulam

Ulam basis on [0,1] associated to the partition $p = \{x_0 = 0, x_1, \ldots, x_n=1\}$

Ulam(n::Integer)

Equispaced Ulam basis on [0,1] of size n

Base.getindex(B::Ulam, i::Int)

Returns the i-th element of the Ulam basis as a function.

Example

julia> using RigorousInvariantMeasures

julia> B = Ulam(16)
Ulam{LinRange{Float64, Int64}}(LinRange{Float64}(0.0, 1.0, 17))

julia> B[1](1/32)
1

julia> B[2](1/32)
0

iterate(S::AverageZero{Ulam{T}}, state = 1) where{T}

Return the elements of the basis of average $0$ functions in the Ulam Basis

Given a preimage of an interval I_i, this iterator returns its relative intersection with all the elements of the Ulam basis that have nonzero intersection with it

Base.length(B::Ulam)

Returns the size of the Ulam basis (the size of the underlying vector -1)

Base.length(S::AverageZero{Ulam})

Return the size of the Average Zero space

nonzero_on(B::Ulam, (a, b))

Returns the indices of the elements of the Ulam basis that intersect with the interval y We do not assume an order of a and b; this should not matter unless the preimages are computed with very low accuracy. We assume, though, that y comes from the (possibly inexact) numerical approximation of an interval in $[0,1]$, i.e., we restrict to $y \cap [0,1]$

relative_measure((a,b)::Tuple{<:Interval,<:Interval}, (c,d)::Tuple{<:Interval,<:Interval})

Relative measure of the intersection of (a,b) wrt the whole interval (c,d) Assumes that a,b and c,d are sorted correctly

Hat

This type represents a Hat basis on $S^1$. It contains a vector with the midpoints of the hats.

Hat(n::Integer)

This constructs a Hat basis on $S^1$ on equispaced points

HatFunctionOnTorus

Hat function (on the torus)

This is a piecewise linear function such that: f(x) = 0 if x <= lo f(mi) = 1 f(x) = 0 if x >= ho

Evaluate a HatFunctionOnTorus correctly on an IntervalOnTorus

Assumption: this is only called on functions defined on our partition, so either mi==0, hi==0, or the three values are in increasing order

IntervalOnTorus

A separate type for intervals on the torus (mod 1) to "remind" us of the quotient

The interval is normalized in the constructor: the caller may assume that

• 0 <= i.lo < 1
• i.hi < i.lo + 1 OR i==Interval(0,1)

Base.getindex(B::Hat, i::Int)

Make so that B[j] returns a HatFunctionOnTorus with the j-th basis element

Given a preimage $y$ of a point $x$, this iterator returns $\phi_j(y)/T'(y)$

Base.length(B::Hat{T})

Return the size of the Hat basis

nonzero_on(B::Hat, dual_element)

Return the range of indices of the elements of the basis whose support intersects with the given dual element (i.e., a pair (y, absT')). The range may end with length(B)+1; this must be interpreted "mod length(B)": it means that it intersects with the hat function peaked in 0 as well (think for instance y = 0.9999).

Hat function (on the reals)

This is a piecewise linear function such that: f(x) = 0 if x <= lo f(mi) = 1 f(hi)

Evaluate a HatFunction (on the real line).

Must work correctly when S is an interval.

Base.getindex(B::HatNP, i::Int)

makes so that B[j] returns a HatFunction with the j-th basis element

Given a preimage y of a point x, this iterator returns \phi_j(y)/T'(y)

Base.length(B::HatNP)

Return the size of the HatNP basis

Return the range of indices of the elements of the basis whose support intersects with the given dual element (i.e., a pair (y, absT')). The range may end with length(B)+1; this must be interpreted "mod length(B)": it means that it intersects with the hat function peaked in 0 as well (think for instance y = 0.9999).

Equispaced partition of size n of [0,1]

Return (in an iterator) the pairs (i, (x, |T'(x)|)) where x is a preimage of p[i], which describe the "dual" L* evaluation(p[i])

Given a preimage y of a point x, this iterator returns $\phi_j(y)/T'(y)$

Return the size of the C2 basisBase.length(S::AverageZero) = length(S.basis)-1

Return the range of indices of the elements of the basis whose support intersects with the given dual element (i.e., a pair (y, absT', derder)).

Base.getindex(B::Chebyshev, i::Int)

Make so that B[j] returns a HatFunctionOnTorus with the j-th basis element

Return the size of the Chebyshev basis

_eval_T

Eval the Chebyshev polynomial up to degree n on an array of points in [-1, 1].

Not satisfactory, the intervals explode

eval_Clenshaw_BackwardFirst

Eval a polynomial in Chebyshev basis, ClenshawBackward, using ball arithmetic Following Viviane Ledoux, Guillaume Moroz "Evaluation of Chebyshev polynomials on intervals andapplication to root finding"

Return the norm of the matrix the NormCacher is working on.

Make so that B[j] returns the basis function of coordinate j

Return the size of the Fourier basis

Return the weak-strong norm bound when restricted on the finite dimensional subspace We use here $\sum_{i=-K}^K (|g_i|\exp^{2\pi \eta |i|})^2 \leq \sum_{-K}^K |g_i|^2 \sum_{-K}^K \exp^{2(2\pi \eta |i|)} \leq ||g||_2 2\frac{1-\exp^{2K+2(2\pi \eta |i|)}}{1-\exp^{2(2\pi \eta |i|)}}$