FrameFun.FrameFunDomains.ComparisonDomainType

A ComparisonDomain is a domain that is implicitly defined by two Fourier series. Example: if binop is (x,y) -> x > y, then the Fourier domain is the domain where the first given Fourier series is greater than the second.

FrameFun.DiffEquations.BoundaryConditionType

A DiffEquation describes a differential equation, with or without boundary conditions. Parameters:

• Fun is the Expansion that will describe the result

When the equation is solved the equations: -Diff(Fun) = DRhs on the domain -diff(Fun) = dRhs on boundary will hold.

FrameFun.DiffEquations.FECollocationOperatorType

Spectral collocation Operators A spectral collocation operator is a DictionaryOperator from a Fourier Extension Frame to a GridBasis. It represents the linear differential operator: Lu = aX1samplerpD1 + ⋯ + aXrsamplerpDr where X is a grid multiplication operator for x -> x, and D is the derivative operator

FrameFun.AZSmoothStyleType
struct AZSmoothStyle <: SolverStyle end

Use the AZ algorithm to solve the discretized approximation problem, but tweak the coefficients such that a smooth extension is obtained.

FrameFun.AZSolverType

Fast implementation of the AZ Algorithm. Returns an operator that is approximately pinv(A), based on a suitable Zt so that (A*Zt-I)*A is low rank.

Steps when applying to right hand side b:

1. (I-AZt)Ax2=(I-AZt)*b, solve for x2

This is by default done using a low rank decomposition of (I-AZt)A (RandomizedSvdSolver).

1. x1 = Zt(b-Ax2)

Can be done fast if Zt and A are fast.

1. x = x1+x2

This is the solution.

FrameFun.AZStyleType
struct AZStyle <: SolverStyle end

Use the AZ algorithm to solve the discretized approximation problem.

FrameFun.AdaptiveApproximationType
struct AdaptiveApproximation <: ApproximationProblem

An AdaptiveApproximation only stores a platform, with which to compute adaptive approximations. It has no single platform parameter.

FrameFun.ApproximationProblemType
abstract type ApproximationProblem end

Approximation problem types group the arguments that a user supplies to the Fun constructor. This may be a dictionary or a platform, for example. By passing around approximation problem objects, functions can easily implement the same interface as Fun.

All functionality is eventually delegated back to the underlying dictionary or platform. Thus, an approximation problem is nothing but an empty intermediate layer that passes on the questions to the right object regardless of how the question was asked.

Some of the properties of an approximation problem may be cached in order to improve efficiency.

FrameFun.AugmentationPlatformType
struct AugmentationPlatform <: FramePlatform

An augmentation frame is the union of a basis, augmented with K extra functions.

This type of frame is used as an example in the paper "Frames and numerical approximation II: generalized sampling" by B. Adcock and D. Huybrechs.

FrameFun.DirectStyleType
struct DirectStyle <: SolverStyle end

Use a direct solver to solve the discretized approximation problem.

FrameFun.DiscreteGramStyleType
struct DiscreteGramStyle <: ProjectionStyle end

Use the inner product implied by the measure obtained by invoking discretemeasure on the dictionary or platform. This results in a discrete Gram matrix.

FrameFun.DiscreteStyleType
abstract type DiscreteStyle <: SamplingStyle end

The sampling operator corresponds to evaluation in a grid. This grid is specified by the listed styles here:

FrameFun.DiscreteTensorSubWeightType
const DiscreteTensorSubWeight{T,G,W} = DiscreteSubWeight{T,M,G} where {T,M<:DiscreteProductWeight,G<:ProductSubGrid}

A tensor product of discrete submeasures.

FrameFun.DualStyleType
struct DualStyle <: SolverStyle end

Use projection on the dual dictionary to solve the discretized approximation problem.

FrameFun.ExactSvdSolverType

A Truncated SVD solver storing a decomposition of an operator A. The cost is equal to the computation of the SVD of A.

For tensor product operators it returns a decomposition of the linearized system

FrameFun.ExtensionFrameType
struct ExtensionFrame{S,T} <: DerivedDict{S,T}

An ExtensionFrame is the restriction of a basis to a subset of its domain. This results in a frame that implicitly represents extensions of functions on the smaller set to the larger set.

Created by the function extensionframe.

See also extensionframe

julia> extensionframe(Fourier(10),0.0..0.5)
FrameFun.FE_TridiagonalSolverType

A fast FE solver based on a low-rank approximation of the plunge region. The plunge region is isolated using a projection operator. For more details, see the paper 'Fast algorithms for the computation of Fourier extensions of arbitrary length' http://arxiv.org/abs/1509.00206

FrameFun.FramePlatformType
abstract type FramePlatform <: Platform end

A FramePlatform represents a family of frames (or ill-conditioned bases which are in the limit a frame).

FrameFun.GenericSamplingStyleType
struct GenericSamplingStyle <: SamplingStyle end

Write your own sampling_operator. The sampling operator corresponds the one implemented by the user.

FrameFun.GramStyleType
struct GramStyle <: ProjectionStyle end

Use the inner product implied by the measure obtained by invoking measure on the dictionary or platform. This results in a Gram matrix.

FrameFun.GridStyleType

The sampling grid is determined by invoking platform_grid on the platform, or by providing a grid=... argument to the Fun constructor.

FrameFun.InverseStyleType
struct InverseStyle <: SolverStyle end

Use the inverse operator to solve the discretized approximation problem.

FrameFun.IterativeStyleType
struct IterativeStyle <: SolverStyle end

Use an iterative method to solve the discretized approximation problem.

FrameFun.ModelPlatformType
struct ModelPlatform <: Platform

A ModelPlatform is a platform based on a model dictionary. The platform is defined by resizing the dictionary, using its own implementation of resize. All other operations are the defaults for the model dictionary.

This platform is convenient to compute adaptive approximations based on an example of a dictionary from the desired family.

FrameFun.ParameterPathType
abstract type ParameterPath{OUT} end

An indexable type that returns something of type OUT. The index can have a lot of complexity, e.g.: A dictionary expansion and a function together determine a platform parameter that leads to a expansion with a smaller error, but more degrees of freedom.

FrameFun.PlatformType
abstract type Platform end

A platform represents a family of dictionaries.

A platform typically has a primal and a dual sequence. The platform maps an index to a set of parameter values, which is then used to generate a primal or dual dictionary (depending on the chosen measure).

See also BasisPlatform, FramePlatform](@ref)

FrameFun.ProductPlatformType
struct ProductPlatform{N} <: Platform

A ProductPlatform corresponds to the product of two or more platforms. It results in a product dictionary, product sampling operator, product solver, ... etcetera.

FrameFun.RandomizedSvdSolverType

A Randomized Truncated SVD solver storing a decomposition of an operator A. If A is MxN, and of rank R, the cost of constructing this solver is MR^2.

For tensor product operators it returns a decomposition of the linearized system

FrameFun.TridiagonalProlateStyleType
struct TridiagonalProlateStyle <: SolverStyle end

Use a tridiagonal solver to solve the discretized approximation problem (only for Fourier extension)

FrameFun.FunMethod

Fun is used to approximate functions in the same way as approximate with the same interface. It discards all outputs of approximate and only returns the function approximation.

FrameFun.approximationproblemMethod
approximationproblem(args...)

examples

Create an approximationproblem from a dictionary

julia> approximationproblem(Fourier(10))

Create an approximationproblem from a dictionary and a domain (extensionframe)

julia> approximationproblem(Fourier(10),0.0..0.5)

Create an approximationproblem from a platform

julia> approximationproblem(FourierPlatform())

Create an approximationproblem from a platform and a platform parameter

julia> approximationproblem(FourierPlatform(), 10)
FrameFun.dualdictionaryMethod
dualdictionary(platform::Platform, param, measure::Measure; options...)

Return the dual dictionary of the platform.

FrameFun.extensiondualMethod
extensiondual(dict::ExtensionFrame, measure::Measure; options...)

Return the extension frame of the dual of the dictionary on the boundingbox.

FrameFun.extensionframeMethod
extensionframe(basis::Dictionary, domain::Domain)

extensionframe(domain::Domain, basis::Dictionary)

Make an ExtensionFrame, but match tensor product domains with tensor product sets in a suitable way.

examples

For example: an interval ⊗ a disk (= a cylinder) combined with a 3D Fourier series, leads to a tensor product of a Fourier series on the interval ⊗ a 2D Fourier series on the disk.

julia> extensionframe(Fourier(10)^2,Disk(.4, SVector(0.5,0.5)))
Dictionary 𝔼(F ⊗ F)

𝔼   :   Extension frame, from A mapped domain based on the 2-dimensional unit ball to 0.0..1.0 (Unit) x 0.0..1.0 (Unit)
F   :   Fourier series
↳ length = 10
↳ Float64 -> Complex{Float64}
↳ support = 0.0..1.0 (Unit)

julia> extensionframe(Fourier(10)^2,(0.0..0.5)^2)
Dictionary 𝔼(F) ⊗ 𝔼(F)

𝔼   :   Extension frame, from 0.0..0.5 to 0.0..1.0 (Unit)
F   :   Fourier series
↳ length = 10
↳ Float64 -> Complex{Float64}
↳ support = 0.0..1.0 (Unit)

FrameFun.monotonic_bisectMethod

Find the root of a monotonically increasing function with a given starting value L_init and using bisection.

The value is increased or decreased first (using bisect_larger and bisect_smaller) until an interval is found for which the objective function switches sign. Next, the smallest value of L for which the objective function becomes positive is located using bisection (with bisect_average to average out two values of L).

The user can optionally supply an argument bt, which will be passed as the first argument to the bisect_X routines. Thus, the variable L can have any type as long as making it larger/smaller or computing averages can be meaningfully defined.

The bisection is run until convergence. This ensures that if L has a discrete nature, the optimal solution is always found exactly, in finite time.

FrameFun.platformMethod
platform(dict::Dictionary)

Return a platform that generates dictionaries of the type of dict.

FrameFun.platformparameterMethod
platformparameter(dict::Dictionary) = dimensions(dict)

Return the parameter that is given to a model-based platform to obtain this dictionary.

FrameFun.@ap_interfaceMacro
@ap_interface function

Generate an interface for the given function in terms of an approximation problem. The approximation problem is constructed from the arguments of the function.

FrameFun.@ap_sampling_property_to_platformMacro

Return the cached property of an approximation problem, where property is a function.

If the result is not cached yet, compute it by invoking: property(ap; options...) = property(SamplingStyle(ap), platform(ap), platformparameter(ap), samplingparameter(ap); options...)

Then cache the result.