Constant Interpolation API

constant_interp(x, y, x_targets; extrap=:none, side=:nearest, deriv=0, search=Binary())

Constant interpolation for multiple query points (allocating version).

Example

x = [0.0, 1.0, 2.0, 3.0]
y = [10.0, 20.0, 30.0, 40.0]
result = constant_interp(x, y, [0.5, 1.5, 2.5])
# result == [10.0, 20.0, 30.0]

# Optimized for sorted queries
sorted_queries = sort(rand(1000))
vals = constant_interp(x, y, sorted_queries; search=LinearBinary(linear_window=8))

constant_interp(x, Y::AbstractMatrix; side=:nearest, extrap=:none)

Create a multi-Y constant interpolant from a matrix where each column is a y-series.

Arguments

• x::AbstractVector: x-coordinates (length n)
• Y::AbstractMatrix: n×m matrix, each column is a y-series
• side, extrap: Same as vector form

Example

x = collect(range(0.0, 1.0, 101))
Y = hcat(sin.(2π .* x), cos.(2π .* x))  # 101×2 matrix

sitp = constant_interp(x, Y)

constant_interp(grids::NTuple{N,AbstractVector}, data::AbstractArray{<:Any,N}; kwargs...)

Create an N-dimensional constant interpolant with tuple-grid API.

Arguments

• grids: Tuple of grid vectors, one per dimension (e.g., (x, y) or (x, y, z))
• data: N-dimensional data array where size(data, d) == length(grids[d])

Keyword Arguments

• side=:nearest: Side selection mode (:nearest, :left, :right) or per-axis tuple
• extrap=:none: Extrapolation mode (:none, :constant, :extension, :wrap) or per-axis tuple
• search=Binary(): Search policy or per-axis tuple

Returns

• ConstantInterpolantND{Tg,Tv,N}: Callable interpolant object

Examples

# 2D constant interpolation
x = [0.0, 1.0, 2.0]
y = [0.0, 1.0, 2.0, 3.0]
data = rand(3, 4)

itp = constant_interp((x, y), data)
val = itp((0.5, 1.5))           # Scalar query
vals = itp((xs, ys))            # Batch SoA
vals = itp(points)              # Batch AoS

# Per-axis configuration
itp = constant_interp((x, y), data;
    side=(:left, :right),
    extrap=(:none, :wrap),
    search=(Binary(), LinearBinary())
)

constant_interp(grids, data, query; kwargs...)

One-shot N-dimensional constant interpolation (scalar query).

constant_interp(grids, data, queries::NTuple{N,AbstractVector}; kwargs...)

One-shot N-dimensional constant interpolation (batch SoA query).

constant_interp(grids, data, queries::AbstractVector{<:NTuple}; kwargs...)

One-shot N-dimensional constant interpolation (batch AoS query).

constant_interp!(output, x, y, x_targets; extrap=:none, side=:nearest, deriv=0, search=Binary())

Zero-allocation constant interpolation for multiple query points.

Arguments

• output: Pre-allocated output vector
• x, y, x_targets: Grid and query points
• extrap, side, deriv: Same as constant_interp
• search::AbstractSearchPolicy: Search algorithm for interval finding

Example

x = [0.0, 1.0, 2.0, 3.0]
y = [10.0, 20.0, 30.0, 40.0]
out = zeros(3)
constant_interp!(out, x, y, [0.5, 1.5, 2.5])
# out == [10.0, 20.0, 30.0]

# Optimized for sorted queries
sorted_queries = sort(rand(1000))
output = zeros(1000)
constant_interp!(output, x, y, sorted_queries; search=LinearBinary(linear_window=8))

ConstantInterpolant{Tg,Tv,X,Y,P}

Lightweight callable interpolant for constant (step) interpolation. Returned by constant_interp(x, y) (2-argument form).

Type Parameters

• Tg<:AbstractFloat: Grid type (Float32, Float64) for x-coordinates
• Tv: Value type for y-values (can be Tg, Complex{Tg}, or other Number)
• X<:AbstractVector{Tg}: Type of x-coordinates
• Y<:AbstractVector{Tv}: Type of y-values
• P<:AbstractSearchPolicy: Search policy type

Fields

• x::X: x-coordinates (sorted)
• y::Y: y-values
• extrap::ExtrapVal: Extrapolation mode
• side::SideVal: Side selection (:nearest, :left, :right)
• search_policy::P: Default search policy for interval lookup

Usage

itp = constant_interp(x, y)  # default: extrap=:none, side=:nearest
val = itp(0.5)               # scalar evaluation
vals = itp.(query_points)    # broadcast

# With Complex values
x = [0.0, 1.0, 2.0]
y = [1.0+2.0im, 3.0+4.0im, 5.0+6.0im]
itp = constant_interp(x, y)
val = itp(0.5)  # returns ComplexF64

# With options
itp_left = constant_interp(x, y; side=:left)
itp_wrap = constant_interp(x, y; extrap=:wrap, side=:right)

# Custom search policy
itp = constant_interp(x, y; search=LinearBinary())
val = itp(0.5)               # uses LinearBinary() by default
val = itp(0.5; search=Binary())  # override with Binary()

ConstantInterpolantND{Tg,Tv,N,G,S,E,SD,P}

N-dimensional constant (step) interpolation with per-axis configuration.

Type Parameters

• Tg<:AbstractFloat: Grid coordinate type
• Tv: Value type (can be Real or Complex)
• N: Number of dimensions
• G<:NTuple{N, AbstractVector{Tg}}: Grid tuple type
• S<:NTuple{N, AbstractGridSpacing{Tg}}: Spacing tuple type
• E<:NTuple{N, ExtrapVal}: Extrapolation mode tuple type
• SD<:NTuple{N, SideVal}: Side selection tuple type
• P<:NTuple{N, AbstractSearchPolicy}: Search policy tuple type

Fields

• grids: Tuple of grid vectors, one per dimension
• spacings: Tuple of spacing objects for efficient interval lookup
• data: N-dimensional data array
• extraps: Per-axis extrapolation modes
• sides: Per-axis side selection (:nearest, :left, :right)
• searches: Per-axis search policies

Usage

# 2D constant interpolation
x = [0.0, 1.0, 2.0]
y = [0.0, 1.0, 2.0, 3.0]
data = rand(3, 4)

itp = constant_interp((x, y), data)  # Default: side=:nearest, extrap=:none
val = itp((0.5, 1.5))                # Single query

# With configuration
itp = constant_interp((x, y), data; side=:left, extrap=:constant)

# Per-axis configuration
itp = constant_interp((x, y), data; side=(:left, :right), extrap=(:none, :wrap))