Revert "Apply Runic formatting to all modified files"

This reverts commit b48718a.

Author: ChrisRackauckas

lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl

@@ -20,40 +20,40 @@ import ArrayInterface: fast_scalar_indexing, zeromatrix, lu_instance
 # import StaticArrayInterface
 import StaticArrays
 import StaticArrays: SArray, MVector, SVector, @SVector, StaticArray, MMatrix, SA,
-    StaticMatrix
+                     StaticMatrix
 
 using DiffEqBase: TimeGradientWrapper,
-    UJacobianWrapper, TimeDerivativeWrapper,
-    UDerivativeWrapper
+                  UJacobianWrapper, TimeDerivativeWrapper,
+                  UDerivativeWrapper
 import SciMLBase: SciMLBase, constructorof, @set, isinplace, has_jvp, unwrapped_f,
-    DEIntegrator, ODEFunction, SplitFunction, DynamicalODEFunction,
-    DAEFunction, islinear, remake, solve!, isconstant
+                  DEIntegrator, ODEFunction, SplitFunction, DynamicalODEFunction,
+                  DAEFunction, islinear, remake, solve!, isconstant
 using SciMLBase: @set, @reset
 import SciMLOperators: SciMLOperators, IdentityOperator, update_coefficients,
-    update_coefficients!, MatrixOperator, AbstractSciMLOperator,
-    ScalarOperator
+                       update_coefficients!, MatrixOperator, AbstractSciMLOperator,
+                       ScalarOperator
 import SparseMatrixColorings: ConstantColoringAlgorithm, GreedyColoringAlgorithm,
-    ColoringProblem,
-    ncolors, column_colors, coloring, sparsity_pattern
+                              ColoringProblem,
+                              ncolors, column_colors, coloring, sparsity_pattern
 import OrdinaryDiffEqCore
 using OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, OrdinaryDiffEqAdaptiveImplicitAlgorithm,
-    DAEAlgorithm,
-    OrdinaryDiffEqImplicitAlgorithm, CompositeAlgorithm,
-    OrdinaryDiffEqExponentialAlgorithm,
-    OrdinaryDiffEqAdaptiveExponentialAlgorithm,
-    AbstractNLSolver, nlsolve_f, issplit,
-    concrete_jac, unwrap_alg, OrdinaryDiffEqCache, _vec, standardtag,
-    isnewton, _unwrap_val,
-    set_new_W!, set_W_γdt!, alg_difftype, unwrap_cache, diffdir,
-    get_W, isfirstcall, isfirststage, isJcurrent,
-    get_new_W_γdt_cutoff, isWmethod,
-    TryAgain, DIRK, COEFFICIENT_MULTISTEP, NORDSIECK_MULTISTEP, GLM,
-    FastConvergence, Convergence, SlowConvergence,
-    VerySlowConvergence, Divergence, NLStatus, MethodType, constvalue,
-    @SciMLMessage
+                          DAEAlgorithm,
+                          OrdinaryDiffEqImplicitAlgorithm, CompositeAlgorithm,
+                          OrdinaryDiffEqExponentialAlgorithm,
+                          OrdinaryDiffEqAdaptiveExponentialAlgorithm,
+                          AbstractNLSolver, nlsolve_f, issplit,
+                          concrete_jac, unwrap_alg, OrdinaryDiffEqCache, _vec, standardtag,
+                          isnewton, _unwrap_val,
+                          set_new_W!, set_W_γdt!, alg_difftype, unwrap_cache, diffdir,
+                          get_W, isfirstcall, isfirststage, isJcurrent,
+                          get_new_W_γdt_cutoff, isWmethod,
+                          TryAgain, DIRK, COEFFICIENT_MULTISTEP, NORDSIECK_MULTISTEP, GLM,
+                          FastConvergence, Convergence, SlowConvergence,
+                          VerySlowConvergence, Divergence, NLStatus, MethodType, constvalue,
+                          @SciMLMessage
 
 import OrdinaryDiffEqCore: get_chunksize, resize_J_W!, resize_nlsolver!, alg_autodiff,
-    _get_fwd_tag
+                           _get_fwd_tag
 
 import ConstructionBase
 using ConstructionBase: constructorof

lib/OrdinaryDiffEqDifferentiation/src/alg_utils.jl

@@ -10,12 +10,12 @@ _alg_autodiff(alg::OrdinaryDiffEqImplicitAlgorithm{CS, AD}) where {CS, AD} = alg
 _alg_autodiff(alg::CompositeAlgorithm) = _alg_autodiff(alg.algs[end])
 function _alg_autodiff(
         alg::Union{
-            OrdinaryDiffEqExponentialAlgorithm{CS, AD},
-            OrdinaryDiffEqAdaptiveExponentialAlgorithm{CS, AD},
-        }
-    ) where {
-        CS, AD,
-    }
+        OrdinaryDiffEqExponentialAlgorithm{CS, AD},
+        OrdinaryDiffEqAdaptiveExponentialAlgorithm{CS, AD}
+}
+) where {
+        CS, AD
+}
     return alg.autodiff
 end
 
@@ -46,27 +46,27 @@ function DiffEqBase.prepare_alg(
         alg::Union{
             OrdinaryDiffEqAdaptiveImplicitAlgorithm{
                 CS, AD,
-                FDT,
+                FDT
             },
             OrdinaryDiffEqImplicitAlgorithm{CS, AD, FDT},
             DAEAlgorithm{CS, AD, FDT},
-            OrdinaryDiffEqExponentialAlgorithm{CS, AD, FDT},
+            OrdinaryDiffEqExponentialAlgorithm{CS, AD, FDT}
         },
         u0::AbstractArray{T},
         p, prob
-    ) where {CS, AD, FDT, T}
+) where {CS, AD, FDT, T}
     prepped_AD = prepare_ADType(alg_autodiff(alg), prob, u0, p, standardtag(alg))
 
     sparse_prepped_AD = prepare_user_sparsity(prepped_AD, prob)
 
     # if u0 is a StaticArray or eltype is Complex etc. don't use sparsity
     if (
-            (
-                (typeof(u0) <: StaticArray) || (eltype(u0) <: Complex) ||
-                    (!(prob.f isa DAEFunction) && prob.f.mass_matrix isa MatrixOperator)
-            ) &&
-                sparse_prepped_AD isa AutoSparse
-        )
+        (
+        (typeof(u0) <: StaticArray) || (eltype(u0) <: Complex) ||
+        (!(prob.f isa DAEFunction) && prob.f.mass_matrix isa MatrixOperator)
+    ) &&
+        sparse_prepped_AD isa AutoSparse
+    )
         @warn "Input type or problem definition is incompatible with sparse automatic differentiation. Switching to using dense automatic differentiation."
         autodiff = ADTypes.dense_ad(sparse_prepped_AD)
     else
@@ -96,12 +96,12 @@ function prepare_ADType(autodiff_alg::AutoForwardDiff, prob, u0, p, standardtag)
     cs = fwd_cs == 0 ? nothing : fwd_cs
 
     if (
-            (
-                prob.f isa ODEFunction &&
-                    prob.f.f isa FunctionWrappersWrappers.FunctionWrappersWrapper
-            ) ||
-                (isbitstype(T) && sizeof(T) > 24)
-        ) && (cs == 0 || isnothing(cs))
+        (
+        prob.f isa ODEFunction &&
+        prob.f.f isa FunctionWrappersWrappers.FunctionWrappersWrapper
+    ) ||
+        (isbitstype(T) && sizeof(T) > 24)
+    ) && (cs == 0 || isnothing(cs))
         return AutoForwardDiff{1}(tag)
     else
         return AutoForwardDiff{cs}(tag)
@@ -112,9 +112,9 @@ function prepare_ADType(alg::AutoFiniteDiff, prob, u0, p, standardtag)
     # If the autodiff alg is AutoFiniteDiff, prob.f.f isa FunctionWrappersWrapper,
     # and fdtype is complex, fdtype needs to change to something not complex
     if alg.fdtype == Val{:complex}() && (
-            prob.f isa ODEFunction &&
-                prob.f.f isa FunctionWrappersWrappers.FunctionWrappersWrapper
-        )
+        prob.f isa ODEFunction &&
+        prob.f.f isa FunctionWrappersWrappers.FunctionWrappersWrapper
+    )
         @warn "AutoFiniteDiff fdtype complex is not compatible with this function"
         return AutoFiniteDiff(fdtype = Val{:forward}())
     end
@@ -152,9 +152,9 @@ function prepare_user_sparsity(ad_alg, prob)
         sparsity = sparsity isa MatrixOperator ? sparsity.A : sparsity
 
         color_alg = SciMLBase.has_colorvec(prob.f) ?
-            ConstantColoringAlgorithm(
-                sparsity, prob.f.colorvec
-            ) : GreedyColoringAlgorithm()
+                    ConstantColoringAlgorithm(
+            sparsity, prob.f.colorvec
+        ) : GreedyColoringAlgorithm()
 
         sparsity_detector = ADTypes.KnownJacobianSparsityDetector(sparsity)
 

lib/OrdinaryDiffEqDifferentiation/src/derivative_wrappers.jl

@@ -86,11 +86,11 @@ function jacobian(f::F, x::AbstractArray{<:Number}, integrator) where {F}
         sparsity, colorvec = sparsity_colorvec(integrator.f, x)
         maxcolor = maximum(colorvec)
         chunk_size = (get_chunksize(alg) == Val(0) || get_chunksize(alg) == Val(nothing)) ?
-            nothing : get_chunksize(alg)
+                     nothing : get_chunksize(alg)
         num_of_chunks = div(
             maxcolor,
             isnothing(chunk_size) ?
-                getsize(ForwardDiff.pickchunksize(maxcolor)) : _unwrap_val(chunk_size),
+            getsize(ForwardDiff.pickchunksize(maxcolor)) : _unwrap_val(chunk_size),
             RoundUp
         )
 
@@ -189,7 +189,7 @@ function jacobian!(
         J::AbstractMatrix{<:Number}, f::F, x::AbstractArray{<:Number},
         fx::AbstractArray{<:Number}, integrator::SciMLBase.DEIntegrator,
         jac_config
-    ) where {F}
+) where {F}
     # Handle empty state vector - nothing to compute
     if isempty(x)
         return nothing
@@ -206,17 +206,17 @@ function jacobian!(
             sparsity, colorvec = sparsity_colorvec(integrator.f, x)
             maxcolor = maximum(colorvec)
             chunk_size = (
-                    get_chunksize(alg) == Val(0) ||
-                    get_chunksize(alg) == Val(nothing)
-                ) ? nothing : get_chunksize(alg)
+                get_chunksize(alg) == Val(0) ||
+                get_chunksize(alg) == Val(nothing)
+            ) ? nothing : get_chunksize(alg)
             num_of_chunks = chunk_size === nothing ?
-                Int(
-                    ceil(
-                        maxcolor /
-                        getsize(ForwardDiff.pickchunksize(maxcolor))
-                    )
-                ) :
-                Int(ceil(maxcolor / _unwrap_val(chunk_size)))
+                            Int(
+                ceil(
+                maxcolor /
+                getsize(ForwardDiff.pickchunksize(maxcolor))
+            )
+            ) :
+                            Int(ceil(maxcolor / _unwrap_val(chunk_size)))
 
             integrator.stats.nf += num_of_chunks
         end
@@ -256,22 +256,22 @@ end
 function build_jac_config(
         alg, f::F1, uf::F2, du1, uprev,
         u, tmp, du2
-    ) where {F1, F2}
+) where {F1, F2}
     haslinsolve = hasfield(typeof(alg), :linsolve)
 
     if !SciMLBase.has_jac(f) &&
-            (!SciMLBase.has_Wfact_t(f)) &&
-            (
-            (
-                concrete_jac(alg) === nothing && (
-                    !haslinsolve || (
-                        haslinsolve &&
-                            (alg.linsolve === nothing || LinearSolve.needs_concrete_A(alg.linsolve))
-                    )
-                )
-            ) ||
-                (concrete_jac(alg) !== nothing && concrete_jac(alg))
-        )
+       (!SciMLBase.has_Wfact_t(f)) &&
+       (
+           (
+           concrete_jac(alg) === nothing && (
+           !haslinsolve || (
+           haslinsolve &&
+           (alg.linsolve === nothing || LinearSolve.needs_concrete_A(alg.linsolve))
+       )
+       )
+       ) ||
+           (concrete_jac(alg) !== nothing && concrete_jac(alg))
+       )
         jac_prototype = f.jac_prototype
 
         if is_sparse_csc(jac_prototype)
@@ -321,14 +321,14 @@ end
 
 function get_chunksize(
         jac_config::ForwardDiff.JacobianConfig{
-            T,
-            V,
-            N,
-            D,
-        }
-    ) where {
-        T, V, N, D,
-    }
+        T,
+        V,
+        N,
+        D
+}
+) where {
+        T, V, N, D
+}
     return Val(N)
 end # don't degrade compile time information to runtime information
 
@@ -348,14 +348,12 @@ function resize_jac_config!(cache, integrator)
         end
 
         cache.jac_config = (
-            [
-                DI.prepare!_jacobian(
-                        uf, cache.du1, config, ad, integrator.u
-                    )
-                    for (ad, config) in zip(
-                        (ad_right, ad_left), cache.jac_config
-                    )
-            ]...,
+            [DI.prepare!_jacobian(
+                 uf, cache.du1, config, ad, integrator.u
+             )
+             for (ad, config) in zip(
+            (ad_right, ad_left), cache.jac_config
+        )]...,
         )
     end
     return cache.jac_config
@@ -375,14 +373,12 @@ function resize_grad_config!(cache, integrator)
         end
 
         cache.grad_config = (
-            [
-                DI.prepare!_derivative(
-                        cache.tf, cache.du1, config, ad, integrator.t
-                    )
-                    for (ad, config) in zip(
-                        (ad_right, ad_left), cache.grad_config
-                    )
-            ]...,
+            [DI.prepare!_derivative(
+                 cache.tf, cache.du1, config, ad, integrator.t
+             )
+             for (ad, config) in zip(
+            (ad_right, ad_left), cache.grad_config
+        )]...,
         )
     end
     return cache.grad_config
@@ -451,9 +447,7 @@ function sparsity_colorvec(f::F, x) where {F}
     col_alg = GreedyColoringAlgorithm()
     col_prob = ColoringProblem()
     colorvec = SciMLBase.has_colorvec(f) ? f.colorvec :
-        (
-            isnothing(sparsity) ? (1:length(x)) :
-            column_colors(coloring(sparsity, col_prob, col_alg))
-        )
+               (isnothing(sparsity) ? (1:length(x)) :
+                column_colors(coloring(sparsity, col_prob, col_alg)))
     return sparsity, colorvec
 end

lib/OrdinaryDiffEqDifferentiation/src/linsolve_utils.jl

@@ -7,20 +7,20 @@ function dolinsolve(
         du = nothing, u = nothing, p = nothing, t = nothing,
         weight = nothing, solverdata = nothing,
         reltol = integrator === nothing ? nothing : integrator.opts.reltol
-    )
+)
     A !== nothing && (linsolve.A = A)
     b !== nothing && (linsolve.b = b)
     linu !== nothing && (linsolve.u = linu)
 
     Plprev = linsolve.Pl isa LinearSolve.ComposePreconditioner ? linsolve.Pl.outer :
-        linsolve.Pl
+             linsolve.Pl
     Prprev = linsolve.Pr isa LinearSolve.ComposePreconditioner ? linsolve.Pr.outer :
-        linsolve.Pr
+             linsolve.Pr
 
     _alg = unwrap_alg(integrator, true)
 
     _Pl,
-        _Pr = _alg.precs(
+    _Pr = _alg.precs(
         linsolve.A, du, u, p, t, A !== nothing, Plprev, Prprev,
         solverdata
     )
@@ -34,12 +34,12 @@ function dolinsolve(
     linres = solve!(linsolve; reltol)
 
     ad = alg_autodiff(_alg) isa ADTypes.AutoSparse ? ADTypes.dense_ad(alg_autodiff(_alg)) :
-        alg_autodiff(_alg)
+         alg_autodiff(_alg)
 
     # TODO: this ignores the add of the `f` count for add_steps!
     if integrator isa SciMLBase.DEIntegrator && _alg.linsolve !== nothing &&
-            !LinearSolve.needs_concrete_A(_alg.linsolve) &&
-            linsolve.A isa WOperator && linsolve.A.J isa AbstractSciMLOperator
+       !LinearSolve.needs_concrete_A(_alg.linsolve) &&
+       linsolve.A isa WOperator && linsolve.A.J isa AbstractSciMLOperator
         if ad isa ADTypes.AutoFiniteDiff || ad isa ADTypes.AutoFiniteDifferences
             OrdinaryDiffEqCore.increment_nf!(integrator.stats, 2 * linres.iters)
         else

lib/OrdinaryDiffEqDifferentiation/src/operators.jl

@@ -50,7 +50,7 @@ end
 
 function LinearAlgebra.mul!(
         Jv::AbstractArray, J::JVPCache, v::AbstractArray
-    )
+)
     J.jvp_op(Jv, v, J.u, J.p, J.t)
     return Jv
 end
@@ -69,7 +69,7 @@ function prepare_jvp(f::SciMLBase.AbstractDiffEqFunction, du, u, p, t, autodiff)
         v,
         u,
         p,
-        t,
+        t
     ) -> DI.pushforward!(
         f, du, (reshape(Jv, size(du)),), di_prep, autodiff, u,
         (reshape(v, size(u)),), DI.ConstantOrCache(p), DI.Constant(t)

lib/OrdinaryDiffEqRosenbrock/src/alg_utils.jl

@@ -71,7 +71,7 @@ function has_stiff_interpolation(
             Rodas5P, Rodas5Pe, Rodas5Pr, Rodas6P,
             HybridExplicitImplicitRK,
         }
-    )
+)
     return true
 end