format

lib/OrdinaryDiffEqDefault/src/OrdinaryDiffEqDefault.jl

@@ -1,8 +1,10 @@
 module OrdinaryDiffEqDefault
 
 using OrdinaryDiffEq: Vern7, Vern8, Vern9, Vern6, Tsit5, Rosenbrock23, Rodas5P, FBDF,
-    alg_stability_size, beta2_default, beta1_default, AutoSwitchCache, ODEIntegrator,
-    CompositeAlgorithm, OrdinaryDiffEqAlgorithm, OrdinaryDiffEqMutableCache, AutoAlgSwitch
+                      alg_stability_size, beta2_default, beta1_default, AutoSwitchCache,
+                      ODEIntegrator,
+                      CompositeAlgorithm, OrdinaryDiffEqAlgorithm,
+                      OrdinaryDiffEqMutableCache, AutoAlgSwitch
 import OrdinaryDiffEq: is_mass_matrix_alg, default_autoswitch
 import LinearSolve
 using LinearAlgebra: I, isdiag

lib/OrdinaryDiffEqDefault/src/default_alg.jl

@@ -116,6 +116,6 @@ end
 
 # hack for the default alg
 function is_mass_matrix_alg(alg::CompositeAlgorithm{
-    <:Any, <:Tuple{Tsit5, Vern7, Rosenbrock23, Rodas5P, FBDF, FBDF}})
+        <:Any, <:Tuple{Tsit5, Vern7, Rosenbrock23, Rodas5P, FBDF, FBDF}})
     true
-end
+end

lib/OrdinaryDiffEqVerner/src/alg_utils.jl

@@ -10,4 +10,4 @@ alg_order(alg::Vern9) = 9
 alg_stability_size(alg::Vern6) = 4.8553
 alg_stability_size(alg::Vern7) = 4.6400
 alg_stability_size(alg::Vern8) = 5.8641
-alg_stability_size(alg::Vern9) = 4.4762
+alg_stability_size(alg::Vern9) = 4.4762

lib/OrdinaryDiffEqVerner/src/algorithms.jl

@@ -116,4 +116,4 @@ end
 AutoVern6(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern6(lazy = lazy), alg; kwargs...)
 AutoVern7(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern7(lazy = lazy), alg; kwargs...)
 AutoVern8(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern8(lazy = lazy), alg; kwargs...)
-AutoVern9(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern9(lazy = lazy), alg; kwargs...)
+AutoVern9(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern9(lazy = lazy), alg; kwargs...)

lib/OrdinaryDiffEqVerner/src/controllers.jl

@@ -5,4 +5,4 @@ end
 
 @inline function accept_step_controller(integrator, controller::PIDController)
     return integrator.qold >= controller.accept_safety
-end
+end

lib/OrdinaryDiffEqVerner/src/interp_func.jl

@@ -28,4 +28,4 @@ function DiffEqBase.interp_summary(::Type{cacheType},
         Union{Vern9Cache, Vern9ConstantCache
 }}
     dense ? "specialized 9th order lazy interpolation" : "1st order linear"
-end
+end

lib/OrdinaryDiffEqVerner/src/interpolants.jl

@@ -6,15 +6,15 @@ RK_WITH_SPECIAL_INTERPOLATIONS = Union{
 }
 
 function _ode_interpolant(Θ, dt, y₀, y₁, k,
-    cache::RK_WITH_SPECIAL_INTERPOLATIONS,
-    idxs, T::Type{Val{D}}, differential_vars) where {D}
-throw(DerivativeOrderNotPossibleError())
+        cache::RK_WITH_SPECIAL_INTERPOLATIONS,
+        idxs, T::Type{Val{D}}, differential_vars) where {D}
+    throw(DerivativeOrderNotPossibleError())
 end
 
 function _ode_interpolant!(out, Θ, dt, y₀, y₁, k,
-    cache::RK_WITH_SPECIAL_INTERPOLATIONS,
-    idxs, T::Type{Val{D}}, differential_vars) where {D}
-throw(DerivativeOrderNotPossibleError())
+        cache::RK_WITH_SPECIAL_INTERPOLATIONS,
+        idxs, T::Type{Val{D}}, differential_vars) where {D}
+    throw(DerivativeOrderNotPossibleError())
 end
 
 ## Vern6
@@ -1040,4 +1040,4 @@ end
                                     k[18][idxs] * b24Θdiff + k[19][idxs] * b25Θdiff +
                                     k[20][idxs] * b26Θdiff) * invdt3
     out
-end
+end

src/algorithms.jl

@@ -1011,7 +1011,7 @@ RadauIIA7: Fully-Implicit Runge-Kutta Method
 An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.
 """
 struct RadauIIA7{CS, AD, F, P, FDT, ST, CJ, Tol, C1, C2, StepLimiter} <:
-    OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ}
+       OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ}
     linsolve::F
     precs::P
     smooth_est::Bool
@@ -1025,30 +1025,29 @@ struct RadauIIA7{CS, AD, F, P, FDT, ST, CJ, Tol, C1, C2, StepLimiter} <:
 end
 
 function RadauIIA7(; chunk_size = Val{0}(), autodiff = Val{true}(),
-    standardtag = Val{true}(), concrete_jac = nothing,
-    diff_type = Val{:forward},
-    linsolve = nothing, precs = DEFAULT_PRECS,
-    extrapolant = :dense, fast_convergence_cutoff = 1 // 5,
-    new_W_γdt_cutoff = 1 // 5,
-    controller = :Predictive, κ = nothing, maxiters = 10, smooth_est = true,
-    step_limiter! = trivial_limiter!)
-RadauIIA7{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
-    typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
-    typeof(κ), typeof(fast_convergence_cutoff),
-    typeof(new_W_γdt_cutoff), typeof(step_limiter!)}(linsolve,
-    precs,
-    smooth_est,
-    extrapolant,
-    κ,
-    maxiters,
-    fast_convergence_cutoff,
-    new_W_γdt_cutoff,
-    controller,
-    step_limiter!)
+        standardtag = Val{true}(), concrete_jac = nothing,
+        diff_type = Val{:forward},
+        linsolve = nothing, precs = DEFAULT_PRECS,
+        extrapolant = :dense, fast_convergence_cutoff = 1 // 5,
+        new_W_γdt_cutoff = 1 // 5,
+        controller = :Predictive, κ = nothing, maxiters = 10, smooth_est = true,
+        step_limiter! = trivial_limiter!)
+    RadauIIA7{_unwrap_val(chunk_size), _unwrap_val(autodiff), typeof(linsolve),
+        typeof(precs), diff_type, _unwrap_val(standardtag), _unwrap_val(concrete_jac),
+        typeof(κ), typeof(fast_convergence_cutoff),
+        typeof(new_W_γdt_cutoff), typeof(step_limiter!)}(linsolve,
+        precs,
+        smooth_est,
+        extrapolant,
+        κ,
+        maxiters,
+        fast_convergence_cutoff,
+        new_W_γdt_cutoff,
+        controller,
+        step_limiter!)
 end
 TruncatedStacktraces.@truncate_stacktrace RadauIIA7
 
-
 ################################################################################
 
 # SDIRK Methods

src/cache_utils.jl

@@ -1,7 +1,9 @@
 is_constant_cache(::OrdinaryDiffEqConstantCache) = true
 is_constant_cache(::OrdinaryDiffEqCache) = false
 is_constant_cache(cache::CompositeCache) = is_constant_cache(cache.caches[1])
-is_constant_cache(::DefaultCache{Cache1}) where {Cache1} = Cache1 <: OrdinaryDiffEqConstantCache
+function is_constant_cache(::DefaultCache{Cache1}) where {Cache1}
+    Cache1 <: OrdinaryDiffEqConstantCache
+end
 
 function DiffEqBase.unwrap_cache(integrator::ODEIntegrator, is_stiff)
     alg = integrator.alg