[ci-skip] Revert "Apply JuliaFormatter to fix code formatting (#450)"

This reverts commit c6e842e.

Reverting JuliaFormatter changes due to formatting issues being addressed in JuliaFormatter.jl PR#933.

Author: ChrisRackauckas

ext/DataInterpolationsChainRulesCoreExt.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)

ext/DataInterpolationsMakieExt.jl

@@ -8,19 +8,15 @@ using Makie
 Makie.plottype(::AbstractInterpolation) = Makie.ScatterLines
 
 # Define the attributes that you want to use
-function Makie.used_attributes(::Makie.PointBased, ::AbstractInterpolation)
-    (:plotdensity, :denseplot)
-end
-function Makie.used_attributes(::Type{<:Makie.ScatterLines}, ::AbstractInterpolation)
-    (:plotdensity, :denseplot)
-end
+Makie.used_attributes(::Makie.PointBased, ::AbstractInterpolation) = (:plotdensity, :denseplot)
+Makie.used_attributes(::Type{<:Makie.ScatterLines}, ::AbstractInterpolation) = (:plotdensity, :denseplot)
 
 # Define the conversion of the data to the plot
 function Makie.convert_arguments(
-        ::Makie.PointBased,
-        A::AbstractInterpolation;
-        plotdensity = 10_000,
-        denseplot = true
+    ::Makie.PointBased,
+    A::AbstractInterpolation;
+    plotdensity = 10_000,
+    denseplot = true,
 )
     DataInterpolations.to_plottable(A; plotdensity = plotdensity, denseplot = denseplot)
 end
@@ -30,17 +26,16 @@ end
 # and should actually be handled by a plot! method,
 # except that doesn't work anymore or does it?
 function Makie.convert_arguments(
-        ::Type{<:Makie.ScatterLines},
-        A::AbstractInterpolation;
-        plotdensity = 10_000,
-        denseplot = true
+    ::Type{<:Makie.ScatterLines},
+    A::AbstractInterpolation;
+    plotdensity = 10_000,
+    denseplot = true,
 )
-    densex, densey = convert_arguments(
-        Makie.PointBased(), A; plotdensity = plotdensity, denseplot = denseplot)
+    densex, densey = convert_arguments(Makie.PointBased(), A; plotdensity = plotdensity, denseplot = denseplot)
     return [
         Makie.SpecApi.Lines(densex, densey),
         Makie.SpecApi.Scatter(A.t, A.u)
     ]
 end
 
-end # module
+end # module

ext/DataInterpolationsSparseConnectivityTracerExt.jl

@@ -5,20 +5,20 @@ using SparseConnectivityTracer: GradientTracer, gradient_tracer_1_to_1
 using SparseConnectivityTracer: HessianTracer, hessian_tracer_1_to_1
 using FillArrays: Fill # from FillArrays.jl
 using DataInterpolations:
-                          AbstractInterpolation,
-                          LinearInterpolation,
-                          QuadraticInterpolation,
-                          LagrangeInterpolation,
-                          AkimaInterpolation,
-                          ConstantInterpolation,
-                          QuadraticSpline,
-                          CubicSpline,
-                          BSplineInterpolation,
-                          BSplineApprox,
-                          CubicHermiteSpline,
-# PCHIPInterpolation,
-                          QuinticHermiteSpline,
-                          output_size
+    AbstractInterpolation,
+    LinearInterpolation,
+    QuadraticInterpolation,
+    LagrangeInterpolation,
+    AkimaInterpolation,
+    ConstantInterpolation,
+    QuadraticSpline,
+    CubicSpline,
+    BSplineInterpolation,
+    BSplineApprox,
+    CubicHermiteSpline,
+    # PCHIPInterpolation,
+    QuinticHermiteSpline,
+    output_size
 
 #===========#
 # Utilities #
@@ -33,26 +33,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,8 +62,8 @@ 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)
@@ -77,33 +77,33 @@ end
 # 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)
-)
+        (: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),
+    )
     @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_caches.jl

@@ -1220,8 +1220,8 @@ function BSplineApprox(
     end
     for k in 2:(n - 1)
         q[ax_u...,
-        k] = u[ax_u..., k] - sc[k, 1] * u[ax_u..., 1] -
-             sc[k, h] * u[ax_u..., end]
+            k] = u[ax_u..., k] - sc[k, 1] * u[ax_u..., 1] -
+                 sc[k, h] * u[ax_u..., end]
     end
     Q = Array{T, N}(undef, size(u)[1:(end - 1)]..., h - 2)
     for i in 2:(h - 1)

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,8 +35,7 @@ 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/interpolation_tests.jl

@@ -1027,6 +1027,7 @@ end
     ut1 = Float32[0.1, 0.2, 0.3, 0.4, 0.5]
     ut2 = Float64[0.1, 0.2, 0.3, 0.4, 0.5]
     for u in (ut1, ut2), t in (ut1, ut2)
+
         interp = @inferred(LinearInterpolation(ut1, ut2))
         for xs in (u, t)
             ys = @inferred(interp(xs))
@@ -1109,6 +1110,7 @@ f_cubic_spline = c -> square(CubicSpline, c)
     iszero_allocations(u, t) = iszero(@allocated(DataInterpolations.munge_data(u, t)))
 
     for T in (String, Union{String, Missing}), dims in 1:3
+
         _u0 = convert(Array{T}, reshape(u0, ntuple(i -> i == dims ? 3 : 1, dims)))
 
         u, t = @inferred(DataInterpolations.munge_data(_u0, t0))