Use SCT extension

Author: SouthEndMusic

ext/DataInterpolationsSparseConnectivityTracerExt.jl

@@ -3,26 +3,24 @@ module DataInterpolationsSparseConnectivityTracerExt
 using SparseConnectivityTracer: AbstractTracer, Dual, primal, tracer
 using SparseConnectivityTracer: GradientTracer, gradient_tracer_1_to_1
 using SparseConnectivityTracer: HessianTracer, hessian_tracer_1_to_1
-using FillArrays: Fill # from FillArrays.jl
+using FillArrays: Fill
 using DataInterpolations:
-    AbstractInterpolation,
-    LinearInterpolation,
-    QuadraticInterpolation,
-    LagrangeInterpolation,
-    AkimaInterpolation,
-    ConstantInterpolation,
-    QuadraticSpline,
-    CubicSpline,
-    BSplineInterpolation,
-    BSplineApprox,
-    CubicHermiteSpline,
-    # PCHIPInterpolation,
-    QuinticHermiteSpline,
-    output_size
+                          AbstractInterpolation,
+                          AkimaInterpolation,
+                          BSplineApprox,
+                          BSplineInterpolation,
+                          ConstantInterpolation,
+                          CubicHermiteSpline,
+                          CubicSpline,
+                          LagrangeInterpolation,
+                          LinearInterpolation,
+                          QuadraticInterpolation,
+                          QuadraticSpline,
+                          QuinticHermiteSpline,
+                          SmoothedLinearInterpolation,
+                          output_size
 
-#===========#
 # Utilities #
-#===========#
 
 # Limit support to `u` begin an AbstractVector{<:Number} or AbstractMatrix{<:Number},
 # to avoid any cases where the output size is dependent on the input value.
@@ -33,26 +31,26 @@ function _sct_interpolate(
         uType::Type{<:AbstractVector{<:Number}},
         t::GradientTracer,
         is_der_1_zero,
-        is_der_2_zero,
-    )
+        is_der_2_zero
+)
     return gradient_tracer_1_to_1(t, is_der_1_zero)
 end
 function _sct_interpolate(
         ::AbstractInterpolation,
         uType::Type{<:AbstractVector{<:Number}},
         t::HessianTracer,
         is_der_1_zero,
-        is_der_2_zero,
-    )
+        is_der_2_zero
+)
     return hessian_tracer_1_to_1(t, is_der_1_zero, is_der_2_zero)
 end
 function _sct_interpolate(
         interp::AbstractInterpolation,
         uType::Type{<:AbstractMatrix{<:Number}},
         t::GradientTracer,
         is_der_1_zero,
-        is_der_2_zero,
-    )
+        is_der_2_zero
+)
     t = gradient_tracer_1_to_1(t, is_der_1_zero)
     N = only(output_size(interp))
     return Fill(t, N)
@@ -62,48 +60,47 @@ function _sct_interpolate(
         uType::Type{<:AbstractMatrix{<:Number}},
         t::HessianTracer,
         is_der_1_zero,
-        is_der_2_zero,
-    )
+        is_der_2_zero
+)
     t = hessian_tracer_1_to_1(t, is_der_1_zero, is_der_2_zero)
     N = only(output_size(interp))
     return Fill(t, N)
-end
+end #===========#
 
-#===========#
 # Overloads #
-#===========#
 
 # We assume that with the exception of ConstantInterpolation and LinearInterpolation,
 # all interpolations have a non-zero second derivative at some point in the input domain.
 
 for (I, is_der1_zero, is_der2_zero) in (
-        (:ConstantInterpolation, true, true),
-        (:LinearInterpolation, false, true),
-        (:QuadraticInterpolation, false, false),
-        (:LagrangeInterpolation, false, false),
-        (:AkimaInterpolation, false, false),
-        (:QuadraticSpline, false, false),
-        (:CubicSpline, false, false),
-        (:BSplineInterpolation, false, false),
-        (:BSplineApprox, false, false),
-        (:CubicHermiteSpline, false, false),
-        (:QuinticHermiteSpline, false, false),
-    )
+    (:AkimaInterpolation, false, false),
+    (:BSplineApprox, false, false),
+    (:BSplineInterpolation, false, false),
+    (:ConstantInterpolation, true, true),
+    (:CubicHermiteSpline, false, false),
+    (:CubicSpline, false, false),
+    (:LagrangeInterpolation, false, false),
+    (:LinearInterpolation, false, true),
+    (:QuadraticInterpolation, false, false),
+    (:QuadraticSpline, false, false),
+    (:QuinticHermiteSpline, false, false),
+    (:SmoothedLinearInterpolation, false, false)
+)
     @eval function (interp::$(I){uType})(
             t::AbstractTracer
-        ) where {uType <: AbstractArray{<:Number}}
+    ) where {uType <: AbstractArray{<:Number}}
         return _sct_interpolate(interp, uType, t, $is_der1_zero, $is_der2_zero)
     end
 end
 
 # Some Interpolations require custom overloads on `Dual` due to mutation of caches.
 for I in (
-        :LagrangeInterpolation,
-        :BSplineInterpolation,
-        :BSplineApprox,
-        :CubicHermiteSpline,
-        :QuinticHermiteSpline,
-    )
+    :LagrangeInterpolation,
+    :BSplineInterpolation,
+    :BSplineApprox,
+    :CubicHermiteSpline,
+    :QuinticHermiteSpline
+)
     @eval function (interp::$(I){uType})(d::Dual) where {uType <: AbstractVector}
         p = interp(primal(d))
         t = interp(tracer(d))

src/interpolation_utils.jl

@@ -191,7 +191,8 @@ function cumulative_integral(A::AbstractInterpolation{<:Number}, cache_parameter
     Base.require_one_based_indexing(A.u)
     idxs = cache_parameters ? (1:(length(A.t) - 1)) : (1:0)
     return cumsum(_integral(A, idx, t1, t2)
-    for (idx, t1, t2) in zip(idxs, @view(A.t[begin:(end - 1)]), @view(A.t[(begin + 1):end])))
+    for (idx, t1, t2) in
+        zip(idxs, @view(A.t[begin:(end - 1)]), @view(A.t[(begin + 1):end])))
 end
 
 function get_parameters(A::LinearInterpolation, idx)

test/derivative_tests.jl

@@ -35,7 +35,8 @@ function test_derivatives(method; args = [], kwargs = [], name::String)
 
         # Interpolation transition points
         for _t in t[2:(end - 1)]
-            if func isa Union{SmoothedConstantInterpolation, BSplineInterpolation, BSplineApprox}
+            if func isa
+               Union{SmoothedConstantInterpolation, BSplineInterpolation, BSplineApprox}
                 # TODO fix interpolations
                 continue
             else

test/sparseconnectivitytracer_tests.jl

@@ -232,20 +232,22 @@ end
 
 @testset "1D Interpolations" begin
     @testset "$(testname(t))" for t in (
+
+            InterpolationTest(AkimaInterpolation(u, t)),
+            InterpolationTest(BSplineApprox(u, t, 3, 4, :ArcLen, :Average)),
+            InterpolationTest(BSplineInterpolation(u, t, 3, :ArcLen, :Average)),
             InterpolationTest(
                 ConstantInterpolation(u, t); is_der1_zero = true, is_der2_zero = true
             ),
+            InterpolationTest(CubicHermiteSpline(du, u, t)),
+            InterpolationTest(CubicSpline(u, t)),
+            InterpolationTest(LagrangeInterpolation(u, t)),
             InterpolationTest(LinearInterpolation(u, t); is_der2_zero = true),
+            InterpolationTest(PCHIPInterpolation(u, t)),
             InterpolationTest(QuadraticInterpolation(u, t)),
-            InterpolationTest(LagrangeInterpolation(u, t)),
-            InterpolationTest(AkimaInterpolation(u, t)),
             InterpolationTest(QuadraticSpline(u, t)),
-            InterpolationTest(CubicSpline(u, t)),
-            InterpolationTest(BSplineInterpolation(u, t, 3, :ArcLen, :Average)),
-            InterpolationTest(BSplineApprox(u, t, 3, 4, :ArcLen, :Average)),
-            InterpolationTest(PCHIPInterpolation(u, t)),
-            InterpolationTest(CubicHermiteSpline(du, u, t)),
             InterpolationTest(QuinticHermiteSpline(ddu, du, u, t)),
+            InterpolationTest(SmoothedLinearInterpolation(u, t))
         )
         test_jacobian(t)
         test_hessian(t)