Public API

AbstractAxisFamily

Abstract supertype for one-dimensional refinement families.

AbstractLineOp

Abstract supertype for one-dimensional fiber operators used by unidirectional sweeps.

AbstractMeasure

Abstract supertype for reference measures associated with univariate nodes and bases.

AbstractNestedAxisFamily

Alias for AbstractNestedNodes.

AbstractNestedNodes <: AbstractUnivariateNodes

Abstract supertype for nested one-dimensional node families.

AbstractNodeOrder

Abstract supertype for one-dimensional storage orders.

AbstractNonNestedAxisFamily

Alias for AbstractNonNestedNodes.

AbstractNonNestedNodes <: AbstractUnivariateNodes

Abstract supertype for non-nested one-dimensional node families.

AbstractTensorOp{D}

Abstract supertype for operators applied by cyclic unidirectional sweeps over D dimensions.

Abstract supertype for all 1D bases.

AbstractUnivariateNodes <: AbstractAxisFamily

Abstract supertype for one-dimensional node families.

struct ChebyshevGaussLobattoNodes{O,EM} <: AbstractNestedNodes

Nested Chebyshev-Gauss-Lobatto node family with storage order O and endpoint mask EM.

struct ChebyshevTMeasure <: AbstractMeasure

Chebyshev first-kind measure on [-1, 1].

struct ChebyshevUMeasure <: AbstractMeasure

Chebyshev second-kind measure on [-1, 1].

ClenshawCurtisNodes

Alias for ChebyshevGaussLobattoNodes.

A single full-grid subproblem in the sparse grid combination technique.

Fields:

• cap: full-tensor refinement-cap vector L (0-based), meaning the tensor grid includes all subspaces W_ℓ with ℓ ≤ L componentwise.
• weight: integer combination weight.

struct CompositeLineOp{Ops<:Tuple} <: AbstractLineOp

Sequential composition of several line operators.

struct CompositeTensorOp{D,Ops} <: AbstractTensorOp{D}

Sequential composition of tensor sweeps.

Plan for applying a (possibly) cross-grid tensor-product operator.

The plan chooses an intermediate covering grid gridW that provides a stable storage layout for unidirectional sweeps.

• If gridX === gridW, input embedding is skipped.
• If gridY === gridW, output restriction is skipped.

Otherwise, x_to_w and/or y_to_w hold index maps into gridW.

struct CyclicLayoutPlan{D,Ti<:Integer,T<:Number}

Reusable cyclic-layout plan with shared metadata and mutable worker scratch.

CyclicLayoutPlan(grid, ::Type{T}; Ti=Int)

Build a reusable cyclic-layout plan for grid and coefficient element type T. The plan captures the current :default thread-pool size and precomputes one layout-only fiber queue per cyclic orientation.

struct DyadicNodes{O,EM} <: AbstractNestedNodes

Nested dyadic node family on [0, 1] with storage order O and endpoint mask EM. With both endpoints present, the total number of points is 2^level + 1 at refinement level level.

EquispacedNodes

Alias for FourierEquispacedNodes.

A reusable evaluation plan for a fixed grid, bases, and point set.

struct FourierEquispacedNodes{O} <: AbstractNestedNodes

Nested equispaced node family on [0, 1) with storage order O.

struct FourierMeasure <: AbstractMeasure

Periodic measure on [0, 1) used by Fourier-based node families.

struct GaussLobattoNodes{M,O} <: AbstractNonNestedNodes

Gauss-Lobatto node family with measure M and storage order O.

struct GaussNodes{M,O} <: AbstractNonNestedNodes

Gaussian node family with measure M and storage order O.

Piecewise-linear hierarchical hat basis on dyadic grids.

The basis adapts to the node rule: if the dyadic nodes include endpoints at level 0, the basis includes the corresponding boundary functions; otherwise, level 0 is empty.

1D stiffness diagonal in the hierarchical hat basis (Balder–Zenger Eq. (9)-(10)).

struct HermiteMeasure <: AbstractMeasure

Hermite measure on (-Inf, Inf).

struct IdentityLineOp <: AbstractLineOp

Identity line operator.

struct InPlaceOp <: LineOpStyle

Trait indicating that a line operator mutates its input buffer in place.

struct JacobiMeasure{T<:Real} <: AbstractMeasure

Jacobi measure with parameters alpha = α and beta = β, both greater than -1.

struct LaguerreMeasure{T<:Real} <: AbstractMeasure

Laguerre measure with parameter alpha = α > -1 on [0, Inf).

struct LegendreMeasure <: AbstractMeasure

Uniform measure on [-1, 1] associated with Legendre polynomials.

struct LejaNodes{M,O} <: AbstractNestedNodes

Weighted Leja node family with measure M and storage order O.

struct LevelOrder <: AbstractNodeOrder

Hierarchical one-dimensional order obtained by recursively splitting even indices before odd indices. On radix-2 grids this agrees with bit reversal.

struct LineBandedOp{Part,F} <: AbstractLineOp

Size-parameterized banded family acting on one fiber.

The family function f(n, T) must return a square BandedMatrices.AbstractBandedMatrix of size n × n; the recommended concrete return type is BandedMatrix. Smaller refinement levels reuse leading principal banded views, so the family must be prefix-compatible across n.

When a banded family is algebraically lower- or upper-triangular, prefer LineBandedOp(Val(:lower), f) or LineBandedOp(Val(:upper), f) so UpDownTensorOp can avoid splitting that dimension.

struct LineChebyshevLegendre{Dir} <: AbstractLineOp

Per-fiber Chebyshev-Legendre coefficient conversion.

struct LineDehierarchize <: AbstractLineOp

In-place dehierarchization on one fiber.

struct LineDehierarchizeTranspose <: AbstractLineOp

Transpose dehierarchization on one fiber.

struct LineDiagonalOp{F} <: AbstractLineOp

Size-parameterized diagonal family acting on one fiber.

The family function f(n, T) must return a vector-like container of diagonal entries of length n. Smaller refinement levels reuse prefix views d[1:m], so the family must be prefix-compatible across n.

struct LineHierarchize <: AbstractLineOp

In-place hierarchization on one fiber.

struct LineHierarchizeTranspose <: AbstractLineOp

Transpose hierarchization on one fiber.

struct LineMatrixOp{MatVecT<:AbstractVector} <: AbstractLineOp

Level-dependent dense or structured square matrix family acting on one fiber.

LineOpStyle

Trait base type describing whether a line operator is in-place or out-of-place.

struct LineTransform{Dir} <: AbstractLineOp

Per-fiber modal transform such as an FFT or DCT.

struct NaturalOrder <: AbstractNodeOrder

Natural one-dimensional order, typically increasing coordinate order.

struct OrientedCoeffs{D,T}

Coefficient buffer paired with a storage-to-physical dimension permutation.

struct OutOfPlaceOp <: LineOpStyle

Trait indicating that a line operator writes to a separate output buffer.

struct PattersonNodes{M,O} <: AbstractNestedNodes

Gauss-Patterson node family with measure M and storage order O.

Piecewise-polynomial hierarchical basis on dyadic grids.

At level ℓ, the (local) polynomial degree defaults to p = min(ℓ+1, pmax).

struct PseudoGaussNodes{M,O} <: AbstractNestedNodes

Pseudo-Gaussian nested node family with measure M and storage order O.

A concrete 1D quadrature rule.

Recursive (pseudorecursive) coefficient order.

This is the coefficient ordering induced by the package's dimension-recursive traversal.

Scattered (unstructured) points.

Points are stored as a D×M matrix where each column is one point.

Linear operator wrapper for an evaluation plan.

Sparse grid container.

A SparseGrid stores only its specification (SparseGridSpec). Layouts are views over the same coefficient set and are selected explicitly when iterating.

Build a SparseGridSpec using the same 1D axis family in every dimension.

Build a SparseGridSpec with potentially different 1D axis families per dimension.

Subspace (block) coefficient order.

Coefficients are grouped by hierarchical increment blocks indexed by refinement vectors r = (r_1,\ldots,r_D). Each block is stored contiguously as a tensor-product block, and the blocks are concatenated in a deterministic (sum, colex) order.

struct TensorOp{D,Ops<:Tuple} <: AbstractTensorOp{D}

One full sweep storing one line operator per physical dimension.

Tensor-product structured points, represented as a tuple of 1D grids.

Plan for transferring vectors between a small grid and a big grid.

The plan stores a map from indices in the small grid traversal into indices in the big grid traversal.

This is intended for cheap gather/scatter operations when traverse(grid_small) is an ordered subsequence of traverse(grid_big) up to a coordinate mapping.

struct UnitIntervalMeasure <: AbstractMeasure

Uniform measure on [0, 1].

struct UpDownTensorOp{D,OpsT,LOpsT,UOpsT} <: AbstractTensorOp{D}

Tensor operator evaluated as a sum of triangular tensor terms from per-dimension L + U splits.

UpDownTensorOp(ops; omit_dim=1)

Construct an UpDownTensorOp by pre-splitting each dimension into lower and upper factors.

omit_dim == 0 keeps all split dimensions in the term expansion. 1 <= omit_dim <= D omits that physical dimension from the split and instead applies the unsplit line operator in that dimension.

A weighted tensor-product term in a tensor-sum operator.

struct ZeroLineOp <: AbstractLineOp

Zero line operator that maps every input fiber to zeros.

ForwardTransform(::Val{D})
ForwardTransform(D)

Return the forward sparse-grid modal transform on D dimensions.

InverseTransform(::Val{D})
InverseTransform(D)

Return the inverse sparse-grid modal transform on D dimensions.

Return the (0-based) local indices in level ℓ with nonzero basis value at x.

For most local bases (hat / piecewise polynomial) this is either empty or a singleton tuple.

Convenience overload: build a temporary CyclicLayoutPlan and apply.

apply_lastdim_cycled!(dest, src, grid, op, plan)
apply_lastdim_cycled!(dest, src, grid, op)

Apply op along the last storage dimension and write the result in the next cyclic orientation.

Apply an in-place line operator on a single fiber.

In-place line ops may still take an optional per-refinement plan (see lineplan).

The work argument is a caller-provided scratch buffer (same length as buf). Thread-safe planned operators must not mutate internal scratch; use work instead.

apply_line!(outbuf, op, inp, work, nodes, level, plan)
apply_line!(op, buf, work, nodes, level, plan)

Apply one line operator to a single fiber, using work as caller-owned scratch.

apply_unidirectional!(u, grid, op, plan)
apply_unidirectional!(u, grid, op)

Apply a line, tensor, composite, or UpDown operator to u using cyclic unidirectional sweeps.

For UpDownTensorOp, the backend is chosen automatically from the number of effective split terms: if Threads.threadpoolsize(:default) > 1 and 2*nterms >= pool, term-level parallelism is used; otherwise fiber-level parallelism is used.

Wrap a TensorSumMatVec as a LinearOperators.LinearOperator.

The returned operator uses the 5-argument mul! protocol:

y ← α*A*x + β*y.

bitrev(j, m) -> Int

Reverse the lowest m bits of the nonnegative integer j.

bitrevperm(N) -> Vector{Int}

Return the radix-2 bit-reversal permutation of length N.

blocksize(axis::AbstractAxisFamily, r::Integer)

Return the number of entries in the increment block added at refinement level r.

compose(a, b)

Compose two line or tensor operators sequentially.

cycle_last_to_front(perm, k)

Return the k-step last-to-front cyclic rotation of perm.

cycle_last_to_front(perm)

Return the one-step cyclic rotation (p₁, …, p_D) -> (p_D, p₁, …, p_{D-1}).

Tensor-difference quadrature contribution and work stats for Δ_r.

Returns (acc, nevals, work).

delta_count(axis::AbstractUnivariateNodes, r::Integer)

Return the number of new points added at refinement level r.

Spatial dimension of the index set.

Enumerate full-grid subproblems for the sparse grid combination technique.

For dimension d and level parameter n, this returns the collection of full-tensor refinement-cap vectors L and their integer weights.

The combination layers are grouped by |L|₁:

• |L|₁ = n + d - 1 has weight +binomial(d-1, 0)
• |L|₁ = n + d - 2 has weight -binomial(d-1, 1)
• …
• |L|₁ = n has weight (-1)^(d-1) * binomial(d-1, d-1)

Keyword arguments:

• cap: optional per-dimension upper bound on L (isotropic Integer or NTuple{d} / SVector{d} cap).

Notes:

This function uses the package's 0-based level convention.

each_lastdim_fiber(grid, perm)

Iterate the last-dimension fibers of grid in the cyclic orientation perm.

each_lastdim_fiber(spec)
each_lastdim_fiber(grid, perm)
each_lastdim_fiber(grid)

Iterate the contiguous last-dimension fibers of a sparse-grid specification or grid.

each_lastdim_fiber(grid)

Iterate the last-dimension fibers of grid in the identity orientation.

Embed a subgrid vector into a covering grid vector (missing entries set to zero).

This is a convenience wrapper around the internal scatter kernel.

plan must be a TransferPlan from the small grid to the big grid.

Evaluate a local basis function (identified by ℓ and 0-based local) at x.

Evaluate into a preallocated output vector.

In-place version of evaluate(grid, f).

Allocate-and-return evaluation.

Sample a function f on the sparse grid points.

The returned vector is ordered consistently with traverse(grid). f is called with an SVector{D,T}.

Dimension-adaptive sparse quadrature over a static admissibility envelope.

Returns (integral, state) where state follows the Gerstner–Griebel active/old semantics:

• integral already includes contributions from both active and old indices,
• eta is the additive estimate over the active set only,
• accepted records activation order, and
• frontier_pops records the order in which active indices are moved to old.

is_nested(axis::AbstractUnivariateNodes) -> Bool

Return true when axis is nested across refinement levels.

Construct a Jacobi (diagonal) preconditioner from a diagonal vector.

Zero diagonal entries are treated as fixed-0 dofs: their inverse is set to zero.

Map Legendre coefficients c to Dirichlet-basis coefficients u.

This assumes c represents a function in the span of {L_k - L_{k+2}}.

The output u has length length(c) - 2.

lineop(op, d)

Return the line operator applied in physical dimension d.

lineop_style(::Type{<:AbstractLineOp})

Return the storage style trait of a line operator type.

lineops(op)

Return the tuple of constituent line operators of op.

lineplan(op, axis, rmax, ::Type{T})

Build the cached per-refinement plan vector for op on axis up to level rmax.

lineplan(op::LineBandedOp, axis::AbstractUnivariateNodes, rmax::Integer, ::Type{T}) where {T<:Number}

Build a cached vector of banded principal-prefix views for LineBandedOp. The family function f(n, T) must return a square BandedMatrices.AbstractBandedMatrix of size n × n, and smaller levels reuse leading principal banded views.

lineplan(op::LineDiagonalOp, axis::AbstractUnivariateNodes, rmax::Integer, ::Type{T}) where {T<:Number}

Build a cached vector of diagonal-data prefixes for LineDiagonalOp. The family function f(n, T) must return a vector-like container of length n, and smaller levels reuse prefix views d[1:m].

measure(axis::AbstractUnivariateNodes)

Return the reference measure associated with axis.

Number of coefficients for basis at axis family axis and refinement index r.

Default: matches the axis size, i.e. totalsize(axis, r).

needs_plan(::Type{<:AbstractLineOp})

Return Val(true) when a line operator family requires cached per-refinement plans.

newpoints(axis::AbstractAxisFamily, r::Integer)

Return the points first introduced at refinement level r.

nodeorder(axis::AbstractUnivariateNodes)

Return the one-dimensional storage order associated with axis.

npoints(axis::AbstractAxisFamily, r::Integer)

Alias for totalsize on node-based axis families.

Create an evaluation plan.

bases may be a single univariate basis (used for all dimensions) or an explicit NTuple{D}.

backend=:auto selects:

• :unidirectional for TensorProductPoints,
• :pseudorecursive for ScatteredPoints with all LocalSupport() bases,
• :naive otherwise.

Plot the combination-technique block structure (requires using Plots).

Plot the sparse grid point set (requires using Plots to activate the extension).

Plot the sparse grid index set in integer coordinates (requires using Plots).

Plot the 2D subspace layout (requires using Plots to activate the extension).

points(axis::AbstractAxisFamily, r::Integer)

Return all points in the refinement family X_r.

Degree/exactness metadata of a 1D quadrature family at refinement index r.

Incremental 1D difference rule Δ_r.

For non-nested families the default is the full rule qrule(Q, r); nested families should specialize this to return the true incremental difference rule.

Optional measure/weight associated with a quadrature family.

Full 1D quadrature rule at refinement index r.

Number of points in the 1D quadrature rule at refinement index r.

Return the per-dimension refinement caps of an index set.

Per-index-set refinement-cap vector used to bound iteration.

refinement_index(axis::AbstractAxisFamily, n::Integer)

Return the refinement index r such that totalsize(axis, r) == n.

Restrict values from a covering grid vector into a subgrid vector.

This is a convenience wrapper around the internal gather kernel.

plan must be a TransferPlan from the small grid to the big grid.

Return an index map from a subgrid to a covering grid.

map[i] is the index in grid_big corresponding to index i in grid_small.

This is valid when traverse(grid_small) produces an ordered subsequence of traverse(grid_big).

The returned indices refer to the recursive-layout ordering of each grid.

Return a trait describing whether the basis functions have global or local support.

tensorize(op, ::Val{D})

Broadcast a line operator to all D physical dimensions.

totalsize(axis::AbstractAxisFamily, r::Integer)

Return the total number of entries in the refinement family X_r.

Apply f to every sparse grid coordinate produced by traverse.

Iterate sparse grid coordinates in a chosen layout.

This iterator emits pseudo-recursive coordinates coords::SVector{D,Int}: for each physical dimension d, the coordinate is the 1-based position in the hierarchical concatenation of refinement blocks.

Use layout=RecursiveLayout() for the package's native recursive order, and layout=SubspaceLayout() for contiguous subspace blocks.

Construct a basis evaluation (Vandermonde) matrix.

V has size (length(x), ncoeff) with entries

V[i,k] = ϕ_{k-1}(x[i]),    k = 1..ncoeff.