format

Author: ChrisRackauckas

lib/OrdinaryDiffEqAdamsBashforthMoulton/src/adams_bashforth_moulton_caches.jl

@@ -1,7 +1,9 @@
 abstract type ABMMutableCache <: OrdinaryDiffEqMutableCache end
 abstract type ABMVariableCoefficientMutableCache <: OrdinaryDiffEqMutableCache end
-get_fsalfirstlast(cache::ABMMutableCache,u) = (cache.fsalfirst, cache.k)
-get_fsalfirstlast(cache::ABMVariableCoefficientMutableCache,u) = (cache.fsalfirst, cache.k4)
+get_fsalfirstlast(cache::ABMMutableCache, u) = (cache.fsalfirst, cache.k)
+function get_fsalfirstlast(cache::ABMVariableCoefficientMutableCache, u)
+    (cache.fsalfirst, cache.k4)
+end
 @cache mutable struct AB3Cache{uType, rateType} <: ABMMutableCache
     u::uType
     uprev::uType

lib/OrdinaryDiffEqBDF/src/algorithms.jl

@@ -150,7 +150,7 @@ end
 function QNDF1(; chunk_size = Val{0}(), autodiff = Val{true}(), standardtag = Val{true}(),
         concrete_jac = nothing, diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(),
-        extrapolant = :linear, kappa = -37//200,
+        extrapolant = :linear, kappa = -37 // 200,
         controller = :Standard, step_limiter! = trivial_limiter!)
     QNDF1{
         _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve), typeof(nlsolve),
@@ -233,7 +233,8 @@ function QNDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
         diff_type = Val{:forward},
         linsolve = nothing, precs = DEFAULT_PRECS, nlsolve = NLNewton(), κ = nothing,
         tol = nothing,
-        extrapolant = :linear, kappa = (-37//200, -1//9, -823//10000, -83//2000, 0//1),
+        extrapolant = :linear, kappa = (
+            -37 // 200, -1 // 9, -823 // 10000, -83 // 2000, 0 // 1),
         controller = :Standard, step_limiter! = trivial_limiter!) where {MO}
     QNDF{MO, _unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
         typeof(nlsolve), typeof(precs), diff_type, _unwrap_val(standardtag),

lib/OrdinaryDiffEqBDF/src/bdf_caches.jl

@@ -1,5 +1,7 @@
 abstract type BDFMutableCache <: OrdinaryDiffEqMutableCache end
-get_fsalfirstlast(cache::BDFMutableCache,u) = (cache.fsalfirst, du_alias_or_new(cache.nlsolver, cache.fsalfirst))
+function get_fsalfirstlast(cache::BDFMutableCache, u)
+    (cache.fsalfirst, du_alias_or_new(cache.nlsolver, cache.fsalfirst))
+end
 
 @cache mutable struct ABDF2ConstantCache{N, dtType, rate_prototype} <:
                       OrdinaryDiffEqConstantCache

lib/OrdinaryDiffEqBDF/src/controllers.jl

@@ -206,7 +206,7 @@ function choose_order!(alg::FBDF, integrator,
                 Val(max_order))
             local terk_tmp
             if u isa Number
-                terk_tmp = fd_weights[k - 2, 1]*u
+                terk_tmp = fd_weights[k - 2, 1] * u
                 for i in 2:(k - 2)
                     terk_tmp += fd_weights[i, k - 2] * u_history[i - 1]
                 end
@@ -215,7 +215,7 @@ function choose_order!(alg::FBDF, integrator,
                 # we need terk_tmp to be mutable.
                 # so it can be updated
                 terk_tmp = similar(u)
-                @.. terk_tmp = fd_weights[k - 2, 1]*_vec(u)
+                @.. terk_tmp = fd_weights[k - 2, 1] * _vec(u)
                 for i in 2:(k - 2)
                     @.. @views terk_tmp += fd_weights[i, k - 2] * u_history[:, i - 1]
                 end

lib/OrdinaryDiffEqBDF/src/dae_caches.jl

@@ -1,5 +1,7 @@
 abstract type DAEBDFMutableCache <: OrdinaryDiffEqMutableCache end
-get_fsalfirstlast(cache::DAEBDFMutableCache,u) = (cache.fsalfirst, du_alias_or_new(cache.nlsolver, cache.fsalfirst))
+function get_fsalfirstlast(cache::DAEBDFMutableCache, u)
+    (cache.fsalfirst, du_alias_or_new(cache.nlsolver, cache.fsalfirst))
+end
 
 @cache mutable struct DImplicitEulerCache{uType, rateType, uNoUnitsType, N} <:
                       DAEBDFMutableCache
@@ -13,7 +15,7 @@ get_fsalfirstlast(cache::DAEBDFMutableCache,u) = (cache.fsalfirst, du_alias_or_n
 end
 
 # Not FSAL
-get_fsalfirstlast(cache::DImplicitEulerCache,u) = (u,u)
+get_fsalfirstlast(cache::DImplicitEulerCache, u) = (u, u)
 
 mutable struct DImplicitEulerConstantCache{N} <: OrdinaryDiffEqConstantCache
     nlsolver::N

lib/OrdinaryDiffEqBDF/src/dae_perform_step.jl

@@ -160,8 +160,6 @@ end
 end
 
 function initialize!(integrator, cache::DABDF2Cache)
-
-
     integrator.kshortsize = 2
     @unpack k₁, k₂ = cache.eulercache
     resize!(integrator.k, integrator.kshortsize)

lib/OrdinaryDiffEqCore/ext/OrdinaryDiffEqCoreEnzymeCoreExt.jl

@@ -2,10 +2,22 @@ module OrdinaryDiffEqCoreEnzymeCoreExt
 import OrdinaryDiffEqCore, EnzymeCore
 
 EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.increment_nf!), args...) = true
-EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.fixed_t_for_floatingpoint_error!), args...) = true
-EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.increment_accept!), args...) = true
-EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.increment_reject!), args...) = true
-EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.increment_nf_perform_step!), args...) = true
+function EnzymeCore.EnzymeRules.inactive(
+        ::typeof(OrdinaryDiffEqCore.fixed_t_for_floatingpoint_error!), args...)
+    true
+end
+function EnzymeCore.EnzymeRules.inactive(
+        ::typeof(OrdinaryDiffEqCore.increment_accept!), args...)
+    true
+end
+function EnzymeCore.EnzymeRules.inactive(
+        ::typeof(OrdinaryDiffEqCore.increment_reject!), args...)
+    true
+end
+function EnzymeCore.EnzymeRules.inactive(
+        ::typeof(OrdinaryDiffEqCore.increment_nf_perform_step!), args...)
+    true
+end
 EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.check_error!), args...) = true
 EnzymeCore.EnzymeRules.inactive(::typeof(OrdinaryDiffEqCore.log_step!), args...) = true
 

lib/OrdinaryDiffEqCore/src/OrdinaryDiffEqCore.jl

@@ -41,7 +41,7 @@ using SimpleUnPack, RecursiveArrayTools, DataStructures, ArrayInterface
 import TruncatedStacktraces
 
 import StaticArraysCore: SArray, MVector, SVector, StaticArray, MMatrix,
-                     StaticMatrix
+                         StaticMatrix
 
 # Integrator Interface
 import DiffEqBase: resize!, deleteat!, addat!, full_cache, user_cache, u_cache, du_cache,
@@ -54,7 +54,6 @@ import DiffEqBase: resize!, deleteat!, addat!, full_cache, user_cache, u_cache,
                    isautodifferentiable,
                    get_tstops, get_tstops_array, get_tstops_max
 
-
 using DiffEqBase: check_error!, @def, _vec, _reshape
 
 using FastBroadcast: @.., True, False

lib/OrdinaryDiffEqCore/src/caches/basic_caches.jl

@@ -5,15 +5,15 @@ struct ODEEmptyCache <: OrdinaryDiffEqConstantCache end
 struct ODEChunkCache{CS} <: OrdinaryDiffEqConstantCache end
 
 # Don't worry about the potential alloc on a constant cache
-get_fsalfirstlast(cache::OrdinaryDiffEqConstantCache,u) = (zero(u), zero(u))
+get_fsalfirstlast(cache::OrdinaryDiffEqConstantCache, u) = (zero(u), zero(u))
 
 mutable struct CompositeCache{T, F} <: OrdinaryDiffEqCache
     caches::T
     choice_function::F
     current::Int
 end
 
-get_fsalfirstlast(cache::CompositeCache,u) = get_fsalfirstlast(cache.caches[1],u)
+get_fsalfirstlast(cache::CompositeCache, u) = get_fsalfirstlast(cache.caches[1], u)
 
 mutable struct DefaultCache{T1, T2, T3, T4, T5, T6, A, F, uType} <: OrdinaryDiffEqCache
     args::A
@@ -28,12 +28,13 @@ mutable struct DefaultCache{T1, T2, T3, T4, T5, T6, A, F, uType} <: OrdinaryDiff
     cache6::T6
     function DefaultCache{T1, T2, T3, T4, T5, T6, F, uType}(
             args, choice_function, current, u) where {T1, T2, T3, T4, T5, T6, F, uType}
-        new{T1, T2, T3, T4, T5, T6, typeof(args), F, uType}(args, choice_function, current, u)
+        new{T1, T2, T3, T4, T5, T6, typeof(args), F, uType}(
+            args, choice_function, current, u)
     end
 end
 
-function get_fsalfirstlast(cache::DefaultCache,u) 
-    (cache.u,cache.u) # will be overwritten by the cache choice
+function get_fsalfirstlast(cache::DefaultCache, u)
+    (cache.u, cache.u) # will be overwritten by the cache choice
 end
 
 function alg_cache(alg::CompositeAlgorithm, u, rate_prototype, ::Type{uEltypeNoUnits},

lib/OrdinaryDiffEqCore/src/integrators/integrator_utils.jl

@@ -255,8 +255,8 @@ function _loopfooter!(integrator)
     end
     if integrator.opts.progress && integrator.iter % integrator.opts.progress_steps == 0
         log_step!(integrator.opts.progress_name, integrator.opts.progress_id,
-                  integrator.opts.progress_message, integrator.dt, integrator.u,
-                  integrator.p, integrator.t, integrator.sol.prob.tspan)
+            integrator.opts.progress_message, integrator.dt, integrator.u,
+            integrator.p, integrator.t, integrator.sol.prob.tspan)
     end
 
     # Take value because if t is dual then maxeig can be dual
@@ -280,18 +280,18 @@ end
 
 function log_step!(progress_name, progress_id, progress_message, dt, u, p, t, tspan)
     t1, t2 = tspan
-    @logmsg(LogLevel(-1),progress_name,
-    _id=progress_id,
-    message=progress_message(dt, u, p, t),
-    progress=(t - t1) / (t2 - t1))
+    @logmsg(LogLevel(-1), progress_name,
+        _id=progress_id,
+        message=progress_message(dt, u, p, t),
+        progress=(t - t1) / (t2 - t1))
 end
 
 function fixed_t_for_floatingpoint_error!(integrator, ttmp)
     if has_tstop(integrator)
         tstop = integrator.tdir * first_tstop(integrator)
         if abs(ttmp - tstop) <
-        100eps(float(max(integrator.t, tstop) / oneunit(integrator.t))) *
-        oneunit(integrator.t)
+           100eps(float(max(integrator.t, tstop) / oneunit(integrator.t))) *
+           oneunit(integrator.t)
             tstop
         else
             ttmp