format

Author: ChrisRackauckas

src/OrdinaryDiffEq.jl

@@ -261,7 +261,7 @@ PrecompileTools.@compile_workload begin
     ]
 
     default_ode = [
-        DefaultODEAlgorithm(autodiff=false),
+        DefaultODEAlgorithm(autodiff = false),
         DefaultODEAlgorithm()
     ]
 

src/alg_utils.jl

@@ -208,33 +208,33 @@ qmax_default(alg::Union{RadauIIA3, RadauIIA5}) = 8
 
 function has_chunksize(alg::OrdinaryDiffEqAlgorithm)
     return alg isa Union{OrdinaryDiffEqExponentialAlgorithm,
-                         OrdinaryDiffEqAdaptiveExponentialAlgorithm,
-                         OrdinaryDiffEqImplicitAlgorithm,
-                         OrdinaryDiffEqAdaptiveImplicitAlgorithm,
-                         DAEAlgorithm,
-                         CompositeAlgorithm}
+        OrdinaryDiffEqAdaptiveExponentialAlgorithm,
+        OrdinaryDiffEqImplicitAlgorithm,
+        OrdinaryDiffEqAdaptiveImplicitAlgorithm,
+        DAEAlgorithm,
+        CompositeAlgorithm}
 end
 function get_chunksize(alg::OrdinaryDiffEqAlgorithm)
     error("This algorithm does not have a chunk size defined.")
 end
 function get_chunksize(alg::Union{OrdinaryDiffEqExponentialAlgorithm{CS},
-                                  OrdinaryDiffEqAdaptiveExponentialAlgorithm{CS},
-                                  OrdinaryDiffEqImplicitAlgorithm{CS},
-                                  OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS},
-                                  DAEAlgorithm{CS},
-                                  CompositeAlgorithm{CS}}) where {CS}
+        OrdinaryDiffEqAdaptiveExponentialAlgorithm{CS},
+        OrdinaryDiffEqImplicitAlgorithm{CS},
+        OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS},
+        DAEAlgorithm{CS},
+        CompositeAlgorithm{CS}}) where {CS}
     Val(CS)
 end
 
 function get_chunksize_int(alg::OrdinaryDiffEqAlgorithm)
     error("This algorithm does not have a chunk size defined.")
 end
 function get_chunksize_int(alg::Union{OrdinaryDiffEqExponentialAlgorithm{CS},
-                                      OrdinaryDiffEqAdaptiveExponentialAlgorithm{CS},
-                                      OrdinaryDiffEqImplicitAlgorithm{CS},
-                                      OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS},
-                                      DAEAlgorithm{CS},
-                                      CompositeAlgorithm{CS}}) where {CS}
+        OrdinaryDiffEqAdaptiveExponentialAlgorithm{CS},
+        OrdinaryDiffEqImplicitAlgorithm{CS},
+        OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS},
+        DAEAlgorithm{CS},
+        CompositeAlgorithm{CS}}) where {CS}
     CS
 end
 # get_chunksize(alg::CompositeAlgorithm) = get_chunksize(alg.algs[alg.current_alg])
@@ -1082,4 +1082,7 @@ is_mass_matrix_alg(alg::CompositeAlgorithm) = all(is_mass_matrix_alg, alg.algs)
 is_mass_matrix_alg(alg::RosenbrockAlgorithm) = true
 is_mass_matrix_alg(alg::NewtonAlgorithm) = !isesdirk(alg)
 # hack for the default alg
-is_mass_matrix_alg(alg::CompositeAlgorithm{<:Any, <:Tuple{Tsit5, Vern7, Rosenbrock23, Rodas5P, FBDF, FBDF}}) = true
+function is_mass_matrix_alg(alg::CompositeAlgorithm{
+        <:Any, <:Tuple{Tsit5, Vern7, Rosenbrock23, Rodas5P, FBDF, FBDF}})
+    true
+end

src/algorithms.jl

@@ -3242,8 +3242,8 @@ end
 struct CompositeAlgorithm{CS, T, F} <: OrdinaryDiffEqCompositeAlgorithm
     algs::T
     choice_function::F
-    function CompositeAlgorithm(algs::T, choice_function::F) where {T,F}
-        CS = mapreduce(alg->has_chunksize(alg) ? get_chunksize_int(alg) : 0, max, algs)
+    function CompositeAlgorithm(algs::T, choice_function::F) where {T, F}
+        CS = mapreduce(alg -> has_chunksize(alg) ? get_chunksize_int(alg) : 0, max, algs)
         new{CS, T, F}(algs, choice_function)
     end
 end
@@ -3269,33 +3269,32 @@ mutable struct AutoSwitchCache{nAlg, sAlg, tolType, T}
     switch_max::Int
     current::Int
     function AutoSwitchCache(count::Int,
-                             successive_switches::Int,
-                             nonstiffalg::nAlg,
-                             stiffalg::sAlg,
-                             is_stiffalg::Bool,
-                             maxstiffstep::Int,
-                             maxnonstiffstep::Int,
-                             nonstifftol::tolType,
-                             stifftol::tolType,
-                             dtfac::T,
-                             stiffalgfirst::Bool,
-                             switch_max::Int,
-                             current::Int=0) where {nAlg, sAlg, tolType, T}
+            successive_switches::Int,
+            nonstiffalg::nAlg,
+            stiffalg::sAlg,
+            is_stiffalg::Bool,
+            maxstiffstep::Int,
+            maxnonstiffstep::Int,
+            nonstifftol::tolType,
+            stifftol::tolType,
+            dtfac::T,
+            stiffalgfirst::Bool,
+            switch_max::Int,
+            current::Int = 0) where {nAlg, sAlg, tolType, T}
         new{nAlg, sAlg, tolType, T}(count,
-                             successive_switches,
-                             nonstiffalg,
-                             stiffalg,
-                             is_stiffalg,
-                             maxstiffstep,
-                             maxnonstiffstep,
-                             nonstifftol,
-                             stifftol,
-                             dtfac,
-                             stiffalgfirst,
-                             switch_max,
-                             current)
+            successive_switches,
+            nonstiffalg,
+            stiffalg,
+            is_stiffalg,
+            maxstiffstep,
+            maxnonstiffstep,
+            nonstifftol,
+            stifftol,
+            dtfac,
+            stiffalgfirst,
+            switch_max,
+            current)
     end
-
 end
 
 struct AutoSwitch{nAlg, sAlg, tolType, T}

src/caches/basic_caches.jl

@@ -22,7 +22,8 @@ mutable struct DefaultCache{T1, T2, T3, T4, T5, T6, A, F} <: OrdinaryDiffEqCache
     cache4::T4
     cache5::T5
     cache6::T6
-    function DefaultCache{T1, T2, T3, T4, T5, T6, F}(args, choice_function, current) where {T1, T2, T3, T4, T5, T6, F}
+    function DefaultCache{T1, T2, T3, T4, T5, T6, F}(
+            args, choice_function, current) where {T1, T2, T3, T4, T5, T6, F}
         new{T1, T2, T3, T4, T5, T6, typeof(args), F}(args, choice_function, current)
     end
 end
@@ -44,21 +45,22 @@ function alg_cache(alg::CompositeAlgorithm, u, rate_prototype, ::Type{uEltypeNoU
 end
 
 function alg_cache(alg::CompositeAlgorithm{CS, Tuple{A1, A2, A3, A4, A5, A6}}, u,
-    rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits},
-    uprev, uprev2, f, t, dt, reltol, p, calck,
-    ::Val{V}) where {CS, V, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, A1, A2, A3, A4, A5, A6}
-
+        rate_prototype, ::Type{uEltypeNoUnits}, ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits},
+        uprev, uprev2, f, t, dt, reltol, p, calck,
+        ::Val{V}) where {
+        CS, V, uEltypeNoUnits, uBottomEltypeNoUnits, tTypeNoUnits, A1, A2, A3, A4, A5, A6}
     args = (u, rate_prototype, uEltypeNoUnits,
-            uBottomEltypeNoUnits, tTypeNoUnits, uprev, uprev2, f, t, dt,
-            reltol, p, calck, Val(V))
+        uBottomEltypeNoUnits, tTypeNoUnits, uprev, uprev2, f, t, dt,
+        reltol, p, calck, Val(V))
     argT = map(typeof, args)
     T1 = Base.promote_op(alg_cache, A1, argT...)
     T2 = Base.promote_op(alg_cache, A2, argT...)
     T3 = Base.promote_op(alg_cache, A3, argT...)
     T4 = Base.promote_op(alg_cache, A4, argT...)
     T5 = Base.promote_op(alg_cache, A5, argT...)
     T6 = Base.promote_op(alg_cache, A6, argT...)
-    DefaultCache{T1, T2, T3, T4, T5, T6, typeof(alg.choice_function)}(args, alg.choice_function, 1)
+    DefaultCache{T1, T2, T3, T4, T5, T6, typeof(alg.choice_function)}(
+        args, alg.choice_function, 1)
 end
 
 # map + closure approach doesn't infer

src/composite_algs.jl

@@ -31,7 +31,8 @@ end
 
 function (AS::AutoSwitchCache)(integrator)
     #horrible awful hack
-    isdefault = integrator.alg isa CompositeAlgorithm{<:Any, <:Tuple{Tsit5, Vern7, Rosenbrock23, Rodas5P, FBDF, FBDF}}
+    isdefault = integrator.alg isa CompositeAlgorithm{
+        <:Any, <:Tuple{Tsit5, Vern7, Rosenbrock23, Rodas5P, FBDF, FBDF}}
     if isdefault
         return default_autoswitch(AS, integrator)
     end
@@ -58,7 +59,8 @@ function (AS::AutoSwitchCache)(integrator)
     return AS.current
 end
 
-function AutoAlgSwitch(nonstiffalg::OrdinaryDiffEqAlgorithm, stiffalg::OrdinaryDiffEqAlgorithm; kwargs...)
+function AutoAlgSwitch(
+        nonstiffalg::OrdinaryDiffEqAlgorithm, stiffalg::OrdinaryDiffEqAlgorithm; kwargs...)
     AS = AutoSwitch(nonstiffalg, stiffalg; kwargs...)
     CompositeAlgorithm((nonstiffalg, stiffalg), AS)
 end
@@ -94,23 +96,29 @@ const EXTREME_TOL = 1e-9
 const SMALLSIZE = 50
 const MEDIUMSIZE = 500
 const STABILITY_SIZES = (alg_stability_size(Tsit5()), alg_stability_size(Vern7()))
-const DEFAULTBETA2S = (beta2_default(Tsit5()), beta2_default(Vern7()), beta2_default(Rosenbrock23()), beta2_default(Rodas5P()), beta2_default(FBDF()), beta2_default(FBDF()))
-const DEFAULTBETA1S = (beta1_default(Tsit5(),DEFAULTBETA2S[1]), beta1_default(Vern7(),DEFAULTBETA2S[2]),
-                      beta1_default(Rosenbrock23(), DEFAULTBETA2S[3]), beta1_default(Rodas5P(), DEFAULTBETA2S[4]),
-                      beta1_default(FBDF(), DEFAULTBETA2S[5]), beta1_default(FBDF(), DEFAULTBETA2S[6]))
+const DEFAULTBETA2S = (
+    beta2_default(Tsit5()), beta2_default(Vern7()), beta2_default(Rosenbrock23()),
+    beta2_default(Rodas5P()), beta2_default(FBDF()), beta2_default(FBDF()))
+const DEFAULTBETA1S = (
+    beta1_default(Tsit5(), DEFAULTBETA2S[1]), beta1_default(Vern7(), DEFAULTBETA2S[2]),
+    beta1_default(Rosenbrock23(), DEFAULTBETA2S[3]), beta1_default(
+        Rodas5P(), DEFAULTBETA2S[4]),
+    beta1_default(FBDF(), DEFAULTBETA2S[5]), beta1_default(FBDF(), DEFAULTBETA2S[6]))
 
 callbacks_exists(integrator) = !isempty(integrator.opts.callbacks)
-current_nonstiff(current) = ifelse(current <= NUM_NONSTIFF,current,current-NUM_STIFF)
+current_nonstiff(current) = ifelse(current <= NUM_NONSTIFF, current, current - NUM_STIFF)
 
 function DefaultODEAlgorithm(; lazy = true, stiffalgfirst = false, kwargs...)
     nonstiff = (Tsit5(), Vern7(lazy = lazy))
-    stiff = (Rosenbrock23(;kwargs...), Rodas5P(;kwargs...), FBDF(;kwargs...), FBDF(;linsolve = LinearSolve.KrylovJL_GMRES()))
+    stiff = (Rosenbrock23(; kwargs...), Rodas5P(; kwargs...), FBDF(; kwargs...),
+        FBDF(; linsolve = LinearSolve.KrylovJL_GMRES()))
     AutoAlgSwitch(nonstiff, stiff; stiffalgfirst)
 end
 
 function is_stiff(integrator, alg, ntol, stol, is_stiffalg, current)
     eigen_est, dt = integrator.eigen_est, integrator.dt
-    stiffness = abs(eigen_est * dt / STABILITY_SIZES[nonstiffchoice(integrator.opts.reltol)]) # `abs` here is just for safety
+    stiffness = abs(eigen_est * dt /
+                    STABILITY_SIZES[nonstiffchoice(integrator.opts.reltol)]) # `abs` here is just for safety
     tol = is_stiffalg ? stol : ntol
     os = oneunit(stiffness)
     bool = stiffness > os * tol

src/solve.jl

@@ -415,7 +415,8 @@ function DiffEqBase.__init(
     differential_vars = prob isa DAEProblem ? prob.differential_vars :
                         get_differential_vars(f, u)
 
-    id = InterpolationData(f, timeseries, ts, ks, alg_choice, dense, cache, differential_vars, false)
+    id = InterpolationData(
+        f, timeseries, ts, ks, alg_choice, dense, cache, differential_vars, false)
     sol = DiffEqBase.build_solution(prob, _alg, ts, timeseries,
         dense = dense, k = ks, interp = id, alg_choice = alg_choice,
         calculate_error = false, stats = stats)
@@ -533,10 +534,10 @@ function DiffEqBase.__init(
 end
 
 function DiffEqBase.__init(prob::ODEProblem, ::Nothing, args...; kwargs...)
-    DiffEqBase.init(prob, DefaultODEAlgorithm(autodiff=false), args...; kwargs...)
+    DiffEqBase.init(prob, DefaultODEAlgorithm(autodiff = false), args...; kwargs...)
 end
 function DiffEqBase.__solve(prob::ODEProblem, ::Nothing, args...; kwargs...)
-    DiffEqBase.solve(prob, DefaultODEAlgorithm(autodiff=false), args...; kwargs...)
+    DiffEqBase.solve(prob, DefaultODEAlgorithm(autodiff = false), args...; kwargs...)
 end
 
 function DiffEqBase.solve!(integrator::ODEIntegrator)

test/interface/default_solver_tests.jl

@@ -11,14 +11,15 @@ tsitsol = solve(prob_ode_2Dlinear, Tsit5())
 @test sol.stats.nf == tsitsol.stats.nf
 @test all(isequal(1), sol.alg_choice)
 
-sol = solve(prob_ode_2Dlinear, reltol=1e-10)
-vernsol = solve(prob_ode_2Dlinear, Vern7(), reltol=1e-10)
+sol = solve(prob_ode_2Dlinear, reltol = 1e-10)
+vernsol = solve(prob_ode_2Dlinear, Vern7(), reltol = 1e-10)
 # test that default isn't much worse than Tsit5 (we expect it to use Tsit5 for this).
 @test sol.stats.naccept == vernsol.stats.naccept
 @test sol.stats.nf == vernsol.stats.nf
 @test all(isequal(2), sol.alg_choice)
 
-prob_ode_linear_fast = ODEProblem(ODEFunction(f_2dlinear, mass_matrix=2*I(2)), rand(2), (0.0, 1.0), 1.01)
+prob_ode_linear_fast = ODEProblem(
+    ODEFunction(f_2dlinear, mass_matrix = 2 * I(2)), rand(2), (0.0, 1.0), 1.01)
 sol = solve(prob_ode_linear_fast)
 @test all(isequal(3), sol.alg_choice)
 # for some reason the timestepping here is different from regular Rosenbrock23 (including the initial timestep)
@@ -27,56 +28,59 @@ function rober(u, p, t)
     y₁, y₂, y₃ = u
     k₁, k₂, k₃ = p
     [-k₁ * y₁ + k₃ * y₂ * y₃,
-      k₁ * y₁ - k₃ * y₂ * y₃ - k₂ * y₂^2,
-      k₂ * y₂^2]
+        k₁ * y₁ - k₃ * y₂ * y₃ - k₂ * y₂^2,
+        k₂ * y₂^2]
 end
-prob_rober = ODEProblem(rober, [1.0,0.0,0.0],(0.0,1e3),(0.04,3e7,1e4))
+prob_rober = ODEProblem(rober, [1.0, 0.0, 0.0], (0.0, 1e3), (0.04, 3e7, 1e4))
 sol = solve(prob_rober)
-rosensol = solve(prob_rober, AutoTsit5(Rosenbrock23(autodiff=false)))
+rosensol = solve(prob_rober, AutoTsit5(Rosenbrock23(autodiff = false)))
 # test that default has the same performance as AutoTsit5(Rosenbrock23()) (which we expect it to use for this).
 @test sol.stats.naccept == rosensol.stats.naccept
 @test sol.stats.nf == rosensol.stats.nf
-@test unique(sol.alg_choice) == [1,3]
+@test unique(sol.alg_choice) == [1, 3]
 @test sol.alg_choice[1] == 1
 @test sol.alg_choice[end] == 3
 
-sol = solve(prob_rober, reltol=1e-7, abstol=1e-7)
-rosensol = solve(prob_rober, AutoVern7(Rodas5P(autodiff=false)), reltol=1e-7, abstol=1e-7)
+sol = solve(prob_rober, reltol = 1e-7, abstol = 1e-7)
+rosensol = solve(
+    prob_rober, AutoVern7(Rodas5P(autodiff = false)), reltol = 1e-7, abstol = 1e-7)
 # test that default has the same performance as AutoTsit5(Rosenbrock23()) (which we expect it to use for this).
 @test sol.stats.naccept == rosensol.stats.naccept
 @test sol.stats.nf == rosensol.stats.nf
-@test unique(sol.alg_choice) == [2,4]
+@test unique(sol.alg_choice) == [2, 4]
 @test sol.alg_choice[1] == 2
 @test sol.alg_choice[end] == 4
 
 function exrober(du, u, p, t)
     y₁, y₂, y₃ = u
     k₁, k₂, k₃ = p
-    du .= vcat([-k₁ * y₁ + k₃ * y₂ * y₃,
-      k₁ * y₁ - k₃ * y₂ * y₃ - k₂ * y₂^2,
-      k₂ * y₂^2, ], u[4:end])
+    du .= vcat(
+        [-k₁ * y₁ + k₃ * y₂ * y₃,
+            k₁ * y₁ - k₃ * y₂ * y₃ - k₂ * y₂^2,
+            k₂ * y₂^2], u[4:end])
 end
 
-for n in (100, ) # 600 should be added but currently is broken for unknown reasons
+for n in (100,) # 600 should be added but currently is broken for unknown reasons
     stiffalg = n < 50 ? 4 : n < 500 ? 5 : 6
     linsolve = n < 500 ? nothing : KrylovJL_GMRES()
-    jac_prototype = sparse(I(n+3))
+    jac_prototype = sparse(I(n + 3))
     jac_prototype[1:3, 1:3] .= 1.0
 
-    prob_ex_rober = ODEProblem(ODEFunction(exrober; jac_prototype), vcat([1.0,0.0,0.0], ones(n)),(0.0,100.0),(0.04,3e7,1e4))
+    prob_ex_rober = ODEProblem(ODEFunction(exrober; jac_prototype),
+        vcat([1.0, 0.0, 0.0], ones(n)), (0.0, 100.0), (0.04, 3e7, 1e4))
     sol = solve(prob_ex_rober)
-    fsol = solve(prob_ex_rober, AutoTsit5(FBDF(;autodiff=false, linsolve)))
+    fsol = solve(prob_ex_rober, AutoTsit5(FBDF(; autodiff = false, linsolve)))
     # test that default has the same performance as AutoTsit5(Rosenbrock23()) (which we expect it to use for this).
     @test sol.stats.naccept == fsol.stats.naccept
     @test sol.stats.nf == fsol.stats.nf
-    @test unique(sol.alg_choice) == [1,stiffalg]
+    @test unique(sol.alg_choice) == [1, stiffalg]
 end
 
 function swaplinear(u, p, t)
-    [u[2], u[1]].*p
+    [u[2], u[1]] .* p
 end
-swaplinearf = ODEFunction(swaplinear, mass_matrix=ones(2,2)-I(2))
-prob_swaplinear = ODEProblem(swaplinearf, rand(2), (0., 1.), 1.01)
-sol = solve(prob_swaplinear, reltol=1e-7) # reltol must be set to avoid running into a bug with Rosenbrock23
+swaplinearf = ODEFunction(swaplinear, mass_matrix = ones(2, 2) - I(2))
+prob_swaplinear = ODEProblem(swaplinearf, rand(2), (0.0, 1.0), 1.01)
+sol = solve(prob_swaplinear, reltol = 1e-7) # reltol must be set to avoid running into a bug with Rosenbrock23
 @test all(isequal(4), sol.alg_choice)
 # for some reason the timestepping here is different from regular Rodas5P (including the initial timestep)