Factory Functions

Factory functions provide a single entry point for configuring search policies, extrapolation modes, and side selection. They map concise symbols to concrete types, making the API more discoverable and ND configurations more ergonomic.

Overview

Each factory also supports a passthrough method — if you pass an already-constructed type, it's returned unchanged:

Search(:binary)        # → BinarySearch()
Search(BinarySearch())  # → BinarySearch()  (passthrough)

This is useful in generic code where inputs may be either symbols or pre-constructed types.

Search

Controls how interpolants find the correct grid interval for a query point.

Search(:auto)            # AutoSearch() — adapts per query type (default)
Search(:binary)          # BinarySearch() — O(log n), stateless
Search(:linear)          # LinearSearch() — O(1) amortized (monotonic queries only)
Search(:linear_binary)   # LinearBinarySearch{8}() — linear walk with binary fallback

# LinearBinarySearch supports a keyword argument
Search(:linear_binary; linear_window=4)   # LinearBinarySearch{4}()

Search(:binary; linear_window=8)  # ERROR: ArgumentError

See Search & Hints for detailed policy descriptions and benchmarks.

Extrap

Controls behavior when query points fall outside the data domain.

Extrap(:none)      # NoExtrap() — throw DomainError (default)
Extrap(:constant)  # ConstExtrap() — clamp to boundary values
Extrap(:extend)    # ExtendExtrap() — extend boundary polynomial
Extrap(:wrap)      # WrapExtrap() — periodic coordinate wrapping

See Extrapolation for visual comparisons and detailed behavior.

Side

Controls which neighbor value to use at non-grid-point locations in constant interpolation.

Side(:nearest)  # NearestSide() — nearest neighbor, left tie-break (default)
Side(:left)     # LeftSide() — always use left (floor) value
Side(:right)    # RightSide() — use right (ceiling) value

ND Multi-Arg Form

For N-dimensional interpolation, pass multiple symbols to create a per-axis tuple in a single call. This follows the same pattern as DerivOp(1, 0):

# Instead of writing:
extrap = (ExtendExtrap(), ConstExtrap(), NoExtrap())

# Write:
extrap = Extrap(:extend, :constant, :none)

# Both produce the same Tuple{ExtendExtrap, ConstExtrap, NoExtrap}

All three factories support this:

# 3D example — different policy per axis
itp = cubic_interp((x, y, z), data;
    search = Search(:binary, :linear_binary, :auto),
    extrap = Extrap(:extend, :constant, :none))

# 2D constant interpolation
itp = constant_interp((x, y), data;
    side = Side(:left, :nearest))

search = (Search(:binary), Search(:linear_binary; linear_window=4))

Two-Tier API

Factories are a convenience layer — direct type constructors remain fully supported:

Both levels produce identical results and have identical performance.

Error Messages

Invalid symbols produce helpful ArgumentError messages listing all valid options:

julia> Search(:bianry)
ERROR: ArgumentError: unknown search policy :bianry; valid options are :auto, :binary, :linear, :linear_binary

julia> Extrap(:const)
ERROR: ArgumentError: unknown extrapolation mode :const; valid options are :none, :constant, :extend, :wrap

API Reference

Search(policy::Symbol; kwargs...)
Search(s1::Symbol, s2::Symbol, rest::Symbol...)
Search(policy::AbstractSearchPolicy)

# 1D
itp = cubic_interp(x, y; search=Search(:binary))
itp = cubic_interp(x, y; search=Search(:linear_binary; linear_window=4))

# ND per-axis (multi-arg form)
itp = cubic_interp((x, y, z), data; search=Search(:binary, :linear_binary, :binary))

# Passthrough — accepts both symbols and policies
Search(:binary)         # → BinarySearch()
Search(BinarySearch())  # → BinarySearch()

Extrap(mode::Symbol)
Extrap(s1::Symbol, s2::Symbol, rest::Symbol...)
Extrap(mode::AbstractExtrap)

# 1D
itp = cubic_interp(x, y; extrap=Extrap(:extend))

# ND per-axis (multi-arg form)
itp = cubic_interp((x, y, z), data; extrap=Extrap(:extend, :none, :wrap))

# Passthrough
Extrap(:none)        # → NoExtrap()
Extrap(NoExtrap())   # → NoExtrap()

Side(mode::Symbol)
Side(s1::Symbol, s2::Symbol, rest::Symbol...)
Side(mode::AbstractSide)

# 1D
itp = constant_interp(x, y; side=Side(:left))

# ND per-axis (multi-arg form)
itp = constant_interp((x, y), data; side=Side(:left, :nearest))

# Passthrough
Side(:nearest)        # → NearestSide()
Side(NearestSide())   # → NearestSide()