ApproxFun.jl

In ApproxFun, functions are represented by the Fun type. A Fun consists of two primary components:

1. space: Dictates the basis used for the approximation (e.g., Taylor, Fourier, or Chebyshev series).
2. coefficients: A finite vector of coefficients $c_k$ used in the expansion $f(x) \approx \sum_{k=1}^n c_k \psi_k(x)$.

Because each Fun can have a different number of coefficients, they can represent different functions to varying levels of accuracy.

In ApproxFun.jl, UnsetSpace is a special type used to indicate that an operator (such as a derivative or integral) does not have explicitly defined spaces for its domain or range.

When an operator's domain space is an UnsetSpace, the range space should also be treated as an UnsetSpace. This is typically encountered in internal computations or when spaces have not yet been determined by the approximation process.

In ApproxFun.jl, a Domain is an abstract type representing the oriented space on which a function is approximated. Choosing the correct domain type is essential for selecting the appropriate approximation method (e.g., Chebyshev vs. Fourier).

Common domain subtypes include:

• Interval: A standard finite interval.
• Ray: A semi-infinite interval.
• Line: An infinite line.
• Arc: A segment of a curve.
• PeriodicSegment, PeriodicLine, Circle: Domains used for periodic functions.

For functions of two variables, ApproxFun.jl provides specialized structures:

• LowRankFun: Represents a bivariate function using a low-rank approximation.
• ProductFun: Represents a function as a product of univariate functions.

To create a function approximation, use the Fun constructor. You provide a function and an interval (e.g., 0..10). Once created, you can perform algebraic operations (addition, multiplication, powers) on these Fun objects. Most Julia built-in functions and SpecialFunctions.jl functions are overridden to accept Fun objects, allowing for complex functional compositions.

using ApproxFun

x = Fun(identity, 0..10)
f = sin(x^2)
g = cos(x)

# Evaluating the approximation
f(0.1) 

When you call A \ b where A is an Operator, ApproxFun performs an adaptive QR factorization. This is equivalent to qr(A) \ b.

Key behaviors:

• Space Inference: A \ b can use both the operator A and the function b to determine the domain space. In contrast, qr(A) only sees the operator A and must infer the space from it.
• Efficiency: The qr function adaptively caches a partial QR factorization. If you apply the same operator to different right-hand sides, subsequent inversions will be significantly more efficient.

Every domain d is associated with a default Space via the Space(d) constructor. The space determines the basis functions used for approximation.

Examples of default space mappings:

• ChebyshevInterval() defaults to Chebyshev(ChebyshevInterval()), which is optimized for smooth functions on an interval.
• PeriodicSegment() defaults to Fourier(PeriodicSegment()), which uses trigonometric polynomials for periodic functions.

While TensorSpace is common for rectangular domains, AbstractProductSpace allows for more complex multivariate bases where the basis functions in one dimension depend on the index of another dimension (e.g., spherical harmonics).

To determine the basis used in a specific dimension of an AbstractProductSpace, use the columnspace(space, dimension) function. This is useful when the basis is interlaced but not a simple Cartesian product of identical 1D bases.

# Example concept: retrieving the basis for a specific dimension
columnspace(myproductspace, 1)
columnspace(myproductspace, 2)

The Chebyshev space is the default in ApproxFun.jl and represents expansions in Chebyshev polynomials $T_k(x)$ on the interval $[-1, 1]$. There is an intrinsic link between Chebyshev and CosSpace: a function $f(x)$ in Chebyshev space can be viewed as a function $g(\theta) = f(\cos(\theta))$ in CosSpace (cosine series). You can convert between them by passing the coefficients of one to the other.

using ApproxFun, LinearAlgebra

f = Fun(exp, Chebyshev());

# Convert Chebyshev expansion to CosSpace by specifying coefficients directly
g = Fun(CosSpace(), coefficients(f));

f(cos(0.1)) ≈ exp(cos(0.1))
true

g(0.1) ≈ exp(cos(0.1))
true