Refactor Interpolation to use typed Interpolant structs

- Added Interpolant{Linear} and Interpolant{Constant} types
- Implemented call methods for each type
- Added display.jl with custom show methods
- Updated docs to include types.jl and display.jl
- Added type stability tests for interpolant calls

Author: ocots

docs/api_reference.jl

@@ -39,12 +39,14 @@ function generate_api_reference(src_dir::String)
             primary_modules=[
                 CTBase.Interpolation => src(
                     joinpath("Interpolation", "Interpolation.jl"),
+                    joinpath("Interpolation", "types.jl"),
                     joinpath("Interpolation", "ctinterpolate.jl"),
+                    joinpath("Interpolation", "display.jl"),
                 ),
             ],
             exclude=EXCLUDE_SYMBOLS,
             public=true,
-            private=false,
+            private=true,
             title="Interpolation",
             title_in_menu="Interpolation",
             filename="interpolation",

src/Interpolation/Interpolation.jl

@@ -9,10 +9,13 @@ Interpolation utilities for the Control Toolbox (CT) ecosystem.
 """
 module Interpolation
 
-import DocStringExtensions: TYPEDSIGNATURES
+import DocStringExtensions: TYPEDEF, TYPEDSIGNATURES
 
+include(joinpath(@__DIR__, "types.jl"))
 include(joinpath(@__DIR__, "ctinterpolate.jl"))
+include(joinpath(@__DIR__, "display.jl"))
 
 export ctinterpolate, ctinterpolate_constant
+export Interpolant, LinearInterpolant, ConstantInterpolant
 
 end # module Interpolation

src/Interpolation/ctinterpolate.jl

@@ -1,17 +1,52 @@
+# =============================================================================
+# Call methods
+# =============================================================================
+
+# Linear interpolation with flat extrapolation outside [x[1], x[end]].
+function (interp::Interpolant{Linear})(t)
+    x, f = interp.x, interp.f
+    if t < x[1]
+        return f[1]
+    elseif t >= x[end]
+        return f[end]
+    else
+        i = searchsortedlast(x, t)
+        i == length(x) && return f[end]
+        α = (t - x[i]) / (x[i + 1] - x[i])
+        return f[i] + α * (f[i + 1] - f[i])
+    end
+end
+
+# Right-continuous piecewise-constant (steppost) interpolation.
+function (interp::Interpolant{Constant})(t)
+    x, f = interp.x, interp.f
+    if t < x[1]
+        return f[1]
+    elseif t >= x[end]
+        return f[end]
+    else
+        return f[searchsortedlast(x, t)]
+    end
+end
+
+# =============================================================================
+# Factories (public API)
+# =============================================================================
+
 """
 $(TYPEDSIGNATURES)
 
 Return a linear interpolation function for the data `f` defined at points `x`.
 
-This function creates a one-dimensional linear interpolant with flat extrapolation
-beyond the bounds of `x` (returns `f[1]` for `t < x[1]` and `f[end]` for `t >= x[end]`).
+This creates a one-dimensional linear [`Interpolant`](@ref) with flat extrapolation beyond
+the bounds of `x` (returns `f[1]` for `t < x[1]` and `f[end]` for `t >= x[end]`).
 
 # Arguments
 - `x`: A vector of points at which the values `f` are defined.
 - `f`: A vector of values to interpolate.
 
 # Returns
-A callable interpolation object that can be evaluated at new points.
+A callable [`LinearInterpolant`](@ref) that can be evaluated at new points.
 
 # Example
 ```julia-repl
@@ -23,31 +58,15 @@ julia> interp(-1.0)  # Returns 1.0 (flat extrapolation)
 julia> interp(3.0)  # Returns 3.0 (flat extrapolation)
 ```
 """
-function ctinterpolate(x, f)
-    function linear_interp(t)
-        if t < x[1]
-            return f[1]
-        elseif t >= x[end]
-            return f[end]
-        else
-            i = searchsortedlast(x, t)
-            if i == length(x)
-                return f[end]
-            end
-            α = (t - x[i]) / (x[i + 1] - x[i])
-            return f[i] + α * (f[i + 1] - f[i])
-        end
-    end
-    return linear_interp
-end
+ctinterpolate(x, f) = Interpolant{Linear}(x, f)
 
 """
 $(TYPEDSIGNATURES)
 
 Return a piecewise-constant interpolation function for the data `f` defined at points `x`.
 
-This function creates a right-continuous piecewise constant interpolant:
-the value at knot `x[i]` is held constant on the interval `[x[i], x[i+1})`.
+This creates a right-continuous piecewise-constant [`Interpolant`](@ref): the value at knot
+`x[i]` is held constant on the interval `[x[i], x[i+1})`.
 
 This implements the standard steppost behavior for optimal control:
 - `u(t_i) = u_i` (value at the knot)
@@ -59,7 +78,7 @@ This implements the standard steppost behavior for optimal control:
 - `f`: A vector of values to interpolate.
 
 # Returns
-A callable interpolation object that can be evaluated at new points.
+A callable [`ConstantInterpolant`](@ref) that can be evaluated at new points.
 
 # Example
 ```julia-repl
@@ -72,16 +91,4 @@ julia> interp(1.0)  # Returns 2.0 (value at x[2], right-continuous)
 julia> interp(1.5)  # Returns 2.0 (held from x[2] on [1.0, 2.0))
 ```
 """
-function ctinterpolate_constant(x, f)
-    function steppost_interp(t)
-        if t < x[1]
-            return f[1]
-        elseif t >= x[end]
-            return f[end]
-        else
-            i = searchsortedlast(x, t)
-            return f[i]
-        end
-    end
-    return steppost_interp
-end
+ctinterpolate_constant(x, f) = Interpolant{Constant}(x, f)

test/suite/interpolation/test_interpolation.jl

@@ -113,6 +113,26 @@ function test_interpolation()
             Test.@test interp(5.0) ≈ 7.0
         end
 
+        Test.@testset "Interpolant type & show" begin
+            interp = Interpolation.ctinterpolate([0.0, 1.0, 2.0], [0.0, 1.0, 0.0])
+            Test.@test interp isa Function
+            Test.@test interp isa Interpolation.Interpolant
+            Test.@test interp isa Interpolation.LinearInterpolant
+            Test.@test Interpolation.method(interp) === Interpolation.Linear
+            Test.@test occursin("linear", sprint(show, interp))
+            Test.@test occursin("3 nodes", sprint(show, interp))
+
+            c = Interpolation.ctinterpolate_constant([0.0, 1.0, 2.0], [1.0, 2.0, 3.0])
+            Test.@test c isa Function
+            Test.@test c isa Interpolation.ConstantInterpolant
+            Test.@test Interpolation.method(c) === Interpolation.Constant
+            Test.@test occursin("constant", sprint(show, c))
+
+            # type stability of the call (philosophy: @inferred on the call)
+            Test.@test_nowarn Test.@inferred interp(0.5)
+            Test.@test_nowarn Test.@inferred c(0.5)
+        end
+
     end
     return nothing
 end