Add Interpolation types and display files

Author: ocots

src/Interpolation/display.jl

@@ -0,0 +1,24 @@
+"""
+$(TYPEDSIGNATURES)
+
+Display a compact representation of an [`Interpolant`](@ref).
+
+# Example
+```julia-repl
+julia> ctinterpolate([0.0, 1.0, 2.0], [0.0, 1.0, 0.0])
+Interpolant (linear): 3 nodes
+```
+"""
+function Base.show(io::IO, interp::Interpolant{M}) where {M}
+    label = M === Linear ? "linear" : "piecewise-constant"
+    print(io, "Interpolant ($label): $(length(interp.x)) nodes")
+end
+
+"""
+$(TYPEDSIGNATURES)
+
+Display an [`Interpolant`](@ref) in the REPL with the same format as `Base.show(io, interp)`.
+"""
+function Base.show(io::IO, ::MIME"text/plain", interp::Interpolant)
+    return show(io, interp)
+end

src/Interpolation/types.jl

@@ -0,0 +1,68 @@
+"""
+$(TYPEDEF)
+
+Abstract interpolation method (trait).
+
+Concrete subtypes (`Linear`, `Constant`) are singleton trait values carried as a type
+parameter of [`Interpolant`](@ref), so the call method is resolved statically.
+"""
+abstract type AbstractInterpolation end
+
+"""
+$(TYPEDEF)
+
+Linear interpolation method (with flat extrapolation outside the node range).
+"""
+struct Linear <: AbstractInterpolation end
+
+"""
+$(TYPEDEF)
+
+Piecewise-constant (right-continuous steppost) interpolation method.
+"""
+struct Constant <: AbstractInterpolation end
+
+"""
+$(TYPEDEF)
+
+Callable interpolant of method `M` over nodes `x` with values `f`.
+
+`Interpolant` subtypes `Function`: an instance `interp` is evaluated as `interp(t)`. The
+method `M` (a subtype of [`AbstractInterpolation`](@ref)) is a compile-time trait parameter
+that selects the evaluation rule, so the call is type-stable.
+
+# Fields
+- `x::TX`: nodes at which the values are defined.
+- `f::TF`: values to interpolate.
+
+# Construction
+Build instances through the factories [`ctinterpolate`](@ref) (linear) and
+[`ctinterpolate_constant`](@ref) (piecewise-constant), or directly via the aliases
+[`LinearInterpolant`](@ref) / [`ConstantInterpolant`](@ref).
+"""
+struct Interpolant{M<:AbstractInterpolation,TX,TF} <: Function
+    x::TX
+    f::TF
+end
+
+# Outer constructor: infer TX, TF from the arguments.
+function Interpolant{M}(x::TX, f::TF) where {M<:AbstractInterpolation,TX,TF}
+    return Interpolant{M,TX,TF}(x, f)
+end
+
+"""
+Alias for a linear [`Interpolant`](@ref).
+"""
+const LinearInterpolant = Interpolant{Linear}
+
+"""
+Alias for a piecewise-constant [`Interpolant`](@ref).
+"""
+const ConstantInterpolant = Interpolant{Constant}
+
+"""
+$(TYPEDSIGNATURES)
+
+Return the interpolation method (a subtype of [`AbstractInterpolation`](@ref)) of `interp`.
+"""
+method(::Interpolant{M}) where {M} = M