Merge pull request #493 from ChrisRackauckas-Claude/runic-formatting

Switch from JuliaFormatter to Runic.jl for code formatting

Author: ChrisRackauckas

.JuliaFormatter.toml

@@ -1,13 +1,19 @@
-name: "Format Check"
+name: format-check
 
 on:
   push:
     branches:
       - 'master'
+      - 'main'
+      - 'release-'
     tags: '*'
   pull_request:
 
 jobs:
-  format-check:
-    name: "Format Check"
-    uses: "SciML/.github/.github/workflows/format-check.yml@v1"
+  runic:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: fredrikekre/runic-action@v1
+        with:
+          version: '1'

.github/workflows/FormatCheck.yml

@@ -5,13 +5,16 @@ cp("./docs/Project.toml", "./docs/src/assets/Project.toml", force = true)
 
 ENV["GKSwstype"] = "100"
 
-makedocs(modules = [DataInterpolations],
+makedocs(
+    modules = [DataInterpolations],
     sitename = "DataInterpolations.jl",
     clean = true,
     doctest = false,
     linkcheck = true,
-    format = Documenter.HTML(assets = ["assets/favicon.ico"],
-        canonical = "https://docs.sciml.ai/DataInterpolations/stable/"),
+    format = Documenter.HTML(
+        assets = ["assets/favicon.ico"],
+        canonical = "https://docs.sciml.ai/DataInterpolations/stable/"
+    ),
     linkcheck_ignore = [
         "https://www.mathworks.com/content/dam/mathworks/mathworks-dot-com/moler/interp.pdf",
     ],
@@ -23,7 +26,8 @@ makedocs(modules = [DataInterpolations],
         "Using with Symbolics/ModelingToolkit" => "symbolics.md",
         "Manual" => "manual.md",
         "Smooth arc length interpolation" => "arclength_interpolation.md",
-        "Inverting Integrals" => "inverting_integrals.md"
-    ])
+        "Inverting Integrals" => "inverting_integrals.md",
+    ]
+)
 
 deploydocs(repo = "github.com/SciML/DataInterpolations.jl"; push_preview = true)

docs/make.jl

@@ -1,10 +1,10 @@
 module DataInterpolationsChainRulesCoreExt
 
 using DataInterpolations: _interpolate, derivative, AbstractInterpolation,
-                          LinearInterpolation, QuadraticInterpolation,
-                          LagrangeInterpolation, AkimaInterpolation,
-                          BSplineInterpolation, BSplineApprox, get_idx, get_parameters,
-                          munge_data
+    LinearInterpolation, QuadraticInterpolation,
+    LagrangeInterpolation, AkimaInterpolation,
+    BSplineInterpolation, BSplineApprox, get_idx, get_parameters,
+    munge_data
 using ChainRulesCore
 
 function ChainRulesCore.rrule(::typeof(munge_data), u, t)
@@ -14,11 +14,12 @@ function ChainRulesCore.rrule(::typeof(munge_data), u, t)
     @assert (u == u_out && t == t_out)
 
     munge_data_pullback = Δ -> (NoTangent(), Δ[1], Δ[2])
-    (u_out, t_out), munge_data_pullback
+    return (u_out, t_out), munge_data_pullback
 end
 
 function ChainRulesCore.rrule(
-        ::Type{LinearInterpolation}, u, t, I, p, extrapolate, cache_parameters)
+        ::Type{LinearInterpolation}, u, t, I, p, extrapolate, cache_parameters
+    )
     A = LinearInterpolation(u, t, I, p, extrapolate, cache_parameters)
     function LinearInterpolation_pullback(ΔA)
         df = NoTangent()
@@ -28,14 +29,15 @@ function ChainRulesCore.rrule(
         dp = NoTangent()
         dextrapolate = NoTangent()
         dcache_parameters = NoTangent()
-        df, du, dt, dI, dp, dextrapolate, dcache_parameters
+        return df, du, dt, dI, dp, dextrapolate, dcache_parameters
     end
 
-    A, LinearInterpolation_pullback
+    return A, LinearInterpolation_pullback
 end
 
 function ChainRulesCore.rrule(
-        ::Type{QuadraticInterpolation}, u, t, I, p, mode, extrapolate, cache_parameters)
+        ::Type{QuadraticInterpolation}, u, t, I, p, mode, extrapolate, cache_parameters
+    )
     A = QuadraticInterpolation(u, t, I, p, mode, extrapolate, cache_parameters)
     function LinearInterpolation_pullback(ΔA)
         df = NoTangent()
@@ -46,10 +48,10 @@ function ChainRulesCore.rrule(
         dmode = NoTangent()
         dextrapolate = NoTangent()
         dcache_parameters = NoTangent()
-        df, du, dt, dI, dp, dmode, dextrapolate, dcache_parameters
+        return df, du, dt, dI, dp, dmode, dextrapolate, dcache_parameters
     end
 
-    A, LinearInterpolation_pullback
+    return A, LinearInterpolation_pullback
 end
 
 function u_tangent(A::LinearInterpolation, t, Δ)
@@ -66,12 +68,12 @@ function u_tangent(A::LinearInterpolation, t, Δ)
         @. out[idx] = Δ * (true - t_factor)
         @. out[idx + 1] = Δ * t_factor
     end
-    out
+    return out
 end
 
 function _quad_interp_indices(A::QuadraticInterpolation, t::Number, iguess)
     idx = get_idx(A, t, iguess; idx_shift = A.mode == :Backward ? -1 : 0, ub_shift = -2)
-    idx, idx + 1, idx + 2
+    return idx, idx + 1, idx + 2
 end
 
 function u_tangent(A::QuadraticInterpolation, t, Δ)
@@ -99,32 +101,36 @@ function u_tangent(A::QuadraticInterpolation, t, Δ)
         @. out[i₁] = -Δ * Δt_rel₀ * Δt_rel₂ / (Δt₀ * Δt₁)
         @. out[i₂] = Δ * Δt_rel₀ * Δt_rel₁ / (Δt₂ * Δt₁)
     end
-    out
+    return out
 end
 
 function u_tangent(A, t, Δ)
-    NoTangent()
+    return NoTangent()
 end
 
-function ChainRulesCore.rrule(::typeof(_interpolate),
+function ChainRulesCore.rrule(
+        ::typeof(_interpolate),
         A::Union{
             LinearInterpolation,
             QuadraticInterpolation,
             LagrangeInterpolation,
             AkimaInterpolation,
             BSplineInterpolation,
-            BSplineApprox
+            BSplineApprox,
         },
-        t::Number)
+        t::Number
+    )
     deriv = derivative(A, t)
     function interpolate_pullback(Δ)
-        (NoTangent(), Tangent{typeof(A)}(; u = u_tangent(A, t, Δ)), sum(deriv .* Δ))
+        return (NoTangent(), Tangent{typeof(A)}(; u = u_tangent(A, t, Δ)), sum(deriv .* Δ))
     end
     return _interpolate(A, t), interpolate_pullback
 end
 
-function ChainRulesCore.frule((_, _, Δt), ::typeof(_interpolate), A::AbstractInterpolation,
-        t::Number)
+function ChainRulesCore.frule(
+        (_, _, Δt), ::typeof(_interpolate), A::AbstractInterpolation,
+        t::Number
+    )
     return _interpolate(A, t), derivative(A, t) * Δt
 end
 

ext/DataInterpolationsChainRulesCoreExt.jl

@@ -9,10 +9,10 @@ Makie.plottype(::AbstractInterpolation) = Makie.ScatterLines
 
 # Define the attributes that you want to use
 function Makie.used_attributes(::Makie.PointBased, ::AbstractInterpolation)
-    (:plotdensity, :denseplot)
+    return (:plotdensity, :denseplot)
 end
 function Makie.used_attributes(::Type{<:Makie.ScatterLines}, ::AbstractInterpolation)
-    (:plotdensity, :denseplot)
+    return (:plotdensity, :denseplot)
 end
 
 # Define the conversion of the data to the plot
@@ -21,8 +21,8 @@ function Makie.convert_arguments(
         A::AbstractInterpolation;
         plotdensity = 10_000,
         denseplot = true
-)
-    DataInterpolations.to_plottable(A; plotdensity = plotdensity, denseplot = denseplot)
+    )
+    return DataInterpolations.to_plottable(A; plotdensity = plotdensity, denseplot = denseplot)
 end
 
 # Define the conversion of the data to the plot for the ScatterLines type
@@ -34,12 +34,12 @@ function Makie.convert_arguments(
         A::AbstractInterpolation;
         plotdensity = 10_000,
         denseplot = true
-)
+    )
     densex,
-    densey = convert_arguments(Makie.PointBased(), A; plotdensity = plotdensity, denseplot = denseplot)
+        densey = convert_arguments(Makie.PointBased(), A; plotdensity = plotdensity, denseplot = denseplot)
     return [
         Makie.SpecApi.Lines(densex, densey),
-        Makie.SpecApi.Scatter(A.t, A.u)
+        Makie.SpecApi.Scatter(A.t, A.u),
     ]
 end
 

ext/DataInterpolationsMakieExt.jl

@@ -2,22 +2,24 @@ module DataInterpolationsOptimExt
 
 using DataInterpolations
 import DataInterpolations: munge_data,
-                           Curvefit, CurvefitCache, _interpolate, get_show, derivative,
-                           ExtrapolationError,
-                           integral, IntegralNotFoundError, DerivativeNotFoundError
+    Curvefit, CurvefitCache, _interpolate, get_show, derivative,
+    ExtrapolationError,
+    integral, IntegralNotFoundError, DerivativeNotFoundError
 
 using Optim, ForwardDiff
 
 ### Curvefit
-function Curvefit(u,
+function Curvefit(
+        u,
         t,
         model,
         p0,
         alg,
         box = false,
         lb = nothing,
         ub = nothing;
-        extrapolate = false)
+        extrapolate = false
+    )
     u, t = munge_data(u, t)
     errfun(t, u, p) = sum(abs2.(u .- model(t, p)))
     if box == false
@@ -30,25 +32,31 @@ function Curvefit(u,
         mfit = optimize(od, lb, ub, p0, Fminbox(alg))
     end
     pmin = Optim.minimizer(mfit)
-    CurvefitCache(u, t, model, p0, ub, lb, alg, pmin, extrapolate)
+    return CurvefitCache(u, t, model, p0, ub, lb, alg, pmin, extrapolate)
 end
 
 # Curvefit
-function _interpolate(A::CurvefitCache{<:AbstractVector{<:Number}},
-        t::Union{AbstractVector{<:Number}, Number})
+function _interpolate(
+        A::CurvefitCache{<:AbstractVector{<:Number}},
+        t::Union{AbstractVector{<:Number}, Number}
+    )
     ((t < A.t[1] || t > A.t[end]) && !A.extrapolate) &&
         throw(ExtrapolationError())
-    A.m(t, A.pmin)
+    return A.m(t, A.pmin)
 end
 
-function _interpolate(A::CurvefitCache{<:AbstractVector{<:Number}},
+function _interpolate(
+        A::CurvefitCache{<:AbstractVector{<:Number}},
         t::Union{AbstractVector{<:Number}, Number},
-        i)
-    _interpolate(A, t), i
+        i
+    )
+    return _interpolate(A, t), i
 end
 
-function derivative(A::CurvefitCache{<:AbstractVector{<:Number}},
-        t::Union{AbstractVector{<:Number}, Number}, order = 1)
+function derivative(
+        A::CurvefitCache{<:AbstractVector{<:Number}},
+        t::Union{AbstractVector{<:Number}, Number}, order = 1
+    )
     ((t < A.t[1] || t > A.t[end]) && !A.extrapolate) && throw(ExtrapolationError())
     order > 2 && throw(DerivativeNotFoundError())
     order == 1 && return ForwardDiff.derivative(x -> A.m(x, A.pmin), t)
@@ -57,7 +65,7 @@ end
 
 function get_show(A::CurvefitCache)
     return "Curvefit" *
-           " with $(length(A.t)) points, using $(nameof(typeof(A.alg)))\n"
+        " with $(length(A.t)) points, using $(nameof(typeof(A.alg)))\n"
 end
 
 function integral(A::CurvefitCache{<:AbstractVector{<:Number}}, t::Number)