Apply JuliaFormatter to fix code formatting

- Applied JuliaFormatter with SciML style guide
- Formatted 11 files

🤖 Generated by OrgMaintenanceScripts.jl

Author: SciML Bot

docs/pages.jl

@@ -1,4 +1,4 @@
 pages = [
     "DelayDiffEq.jl: DDE solvers" => "index.md",
     "Solver API" => "solvers/api.md"
-]
+]

src/DelayDiffEq.jl

@@ -1,13 +1,16 @@
 module DelayDiffEq
 
 using Reexport: @reexport
-import OrdinaryDiffEqCore, OrdinaryDiffEqNonlinearSolve, OrdinaryDiffEqDifferentiation, OrdinaryDiffEqRosenbrock
+import OrdinaryDiffEqCore, OrdinaryDiffEqNonlinearSolve, OrdinaryDiffEqDifferentiation,
+       OrdinaryDiffEqRosenbrock
 @reexport using OrdinaryDiffEq
 
 using DataStructures: BinaryMinHeap
 using LinearAlgebra: opnorm, I
 using Logging: @logmsg
-using RecursiveArrayTools: copyat_or_push!, recursivecopy, recursivecopy!, recursive_bottom_eltype, recursive_unitless_bottom_eltype, recursive_unitless_eltype
+using RecursiveArrayTools: copyat_or_push!, recursivecopy, recursivecopy!,
+                           recursive_bottom_eltype, recursive_unitless_bottom_eltype,
+                           recursive_unitless_eltype
 using SimpleUnPack: @unpack
 using ForwardDiff: ForwardDiff
 
@@ -16,7 +19,7 @@ import SimpleNonlinearSolve
 import SymbolicIndexingInterface as SII
 
 using SciMLBase: AbstractDDEAlgorithm, AbstractDDEIntegrator, AbstractODEIntegrator,
-                  DEIntegrator
+                 DEIntegrator
 
 using Base: deleteat!
 import FastBroadcast: @..
@@ -32,10 +35,13 @@ using OrdinaryDiffEqFunctionMap: FunctionMap
 using OrdinaryDiffEqCore: AutoSwitch, CompositeAlgorithm
 using OrdinaryDiffEq: OrdinaryDiffEq
 using SciMLBase: CallbackSet, DAEProblem, DDEProblem, DESolution, ODEProblem, ReturnCode,
-                 VectorContinuousCallback, addat!, addat_non_user_cache!, deleteat_non_user_cache!,
-                 du_cache, full_cache, get_tmp_cache, isinplace, reeval_internals_due_to_modification!,
+                 VectorContinuousCallback, addat!, addat_non_user_cache!,
+                 deleteat_non_user_cache!,
+                 du_cache, full_cache, get_tmp_cache, isinplace,
+                 reeval_internals_due_to_modification!,
                  reinit!, resize_non_user_cache!, savevalues!, u_cache, user_cache,
-                 step!, terminate!, u_modified!, get_proposed_dt, set_proposed_dt!, auto_dt_reset!,
+                 step!, terminate!, u_modified!, get_proposed_dt, set_proposed_dt!,
+                 auto_dt_reset!,
                  add_tstop!, add_saveat!, get_du, get_du!, addsteps!,
                  change_t_via_interpolation!, isadaptive
 using DiffEqBase: initialize!

src/discontinuity_type.jl

@@ -38,8 +38,10 @@ Base.convert(::Type{T}, d::Discontinuity) where {T <: Number} = convert(T, d.t)
 Base.convert(::Type{T}, d::Discontinuity{T}) where {T <: Number} = d.t
 
 # Fix ForwardDiff ambiguities
-function Base.convert(::Type{ForwardDiff.Dual{T, V, N}}, ::Discontinuity{ForwardDiff.Dual{T, V, N}}) where {N, V, T}
-    throw(MethodError(convert, (ForwardDiff.Dual{T, V, N}, Discontinuity{ForwardDiff.Dual{T, V, N}})))
+function Base.convert(::Type{ForwardDiff.Dual{T, V, N}},
+        ::Discontinuity{ForwardDiff.Dual{T, V, N}}) where {N, V, T}
+    throw(MethodError(convert, (
+        ForwardDiff.Dual{T, V, N}, Discontinuity{ForwardDiff.Dual{T, V, N}})))
 end
 function Base.convert(::Type{ForwardDiff.Dual{T, V, N}}, ::Discontinuity) where {N, V, T}
     throw(MethodError(convert, (ForwardDiff.Dual{T, V, N}, Discontinuity)))

src/fpsolve/fpsolve.jl

@@ -1,4 +1,6 @@
-OrdinaryDiffEqNonlinearSolve.initial_η(fpsolver::FPSolver, integrator::DDEIntegrator) = fpsolver.ηold
+function OrdinaryDiffEqNonlinearSolve.initial_η(fpsolver::FPSolver, integrator::DDEIntegrator)
+    fpsolver.ηold
+end
 
 OrdinaryDiffEqCore.apply_step!(fpsolver::FPSolver, integrator::DDEIntegrator) = nothing
 

src/fpsolve/functional.jl

@@ -10,7 +10,8 @@ function OrdinaryDiffEqNonlinearSolve.compute_step!(fpsolver::FPSolver{<:NLFunct
     compute_step_fixedpoint!(fpsolver, integrator)
 end
 
-function OrdinaryDiffEqNonlinearSolve.compute_step!(fpsolver::FPSolver{<:NLAnderson, false},
+function OrdinaryDiffEqNonlinearSolve.compute_step!(
+        fpsolver::FPSolver{<:NLAnderson, false},
         integrator::DDEIntegrator)
     @unpack cache, iter = fpsolver
     @unpack aa_start = cache

src/integrators/interface.jl

@@ -375,7 +375,8 @@ function DiffEqBase.reinit!(integrator::DDEIntegrator, u0 = integrator.sol.prob.
     # update order of initial discontinuity and propagated discontinuities
     integrator.order_discontinuity_t0 = order_discontinuity_t0
     maximum_order = OrdinaryDiffEqCore.alg_maximum_order(integrator.alg)
-    tstops_propagated, d_discontinuities_propagated = initialize_tstops_d_discontinuities_propagated(
+    tstops_propagated,
+    d_discontinuities_propagated = initialize_tstops_d_discontinuities_propagated(
         tType,
         tstops,
         d_discontinuities,
@@ -507,11 +508,11 @@ function DiffEqBase.addsteps!(integrator::DDEIntegrator, args...)
 end
 
 function DiffEqBase.change_t_via_interpolation!(integrator::DDEIntegrator,
-        t, modify_save_endpoint::Type{Val{T}} = Val{false}, reinitialize_alg = nothing) where T
+        t, modify_save_endpoint::Type{Val{T}} = Val{false},
+        reinitialize_alg = nothing) where {T}
     OrdinaryDiffEqCore._change_t_via_interpolation!(integrator, t, modify_save_endpoint, reinitialize_alg)
 end
 
-
 # update integrator when u is modified by callbacks
 function OrdinaryDiffEqCore.handle_callback_modifiers!(integrator::DDEIntegrator)
     integrator.reeval_fsal = true # recalculate fsalfirst after applying step

src/integrators/utils.jl

@@ -35,10 +35,12 @@ function advance_ode_integrator!(integrator::DDEIntegrator, always_calc_begin =
     # has to be done before updates to ODE integrator, otherwise history function
     # is incorrect
     if iscomposite(alg)
-        OrdinaryDiffEqCore._ode_addsteps!(k, t, uprev, u, dt, f, p, cache.caches[cache.current],
+        OrdinaryDiffEqCore._ode_addsteps!(
+            k, t, uprev, u, dt, f, p, cache.caches[cache.current],
             always_calc_begin, true, true)
     else
-        OrdinaryDiffEqCore._ode_addsteps!(k, t, uprev, u, dt, f, p, cache, always_calc_begin,
+        OrdinaryDiffEqCore._ode_addsteps!(
+            k, t, uprev, u, dt, f, p, cache, always_calc_begin,
             true, true)
     end
     @inbounds for i in 1:length(k)
@@ -82,7 +84,8 @@ function update_ode_integrator!(integrator::DDEIntegrator, always_calc_begin = f
     ode_integrator.t != t + dt && error("cannot update ODE integrator")
 
     if iscomposite(alg)
-        OrdinaryDiffEqCore._ode_addsteps!(k, t, uprev, u, dt, f, p, cache.caches[cache.current],
+        OrdinaryDiffEqCore._ode_addsteps!(
+            k, t, uprev, u, dt, f, p, cache.caches[cache.current],
             always_calc_begin, true, true)
     else
         OrdinaryDiffEqCore._ode_addsteps!(k, t, uprev, u, dt, f, p, cache,

src/solve.jl

@@ -18,12 +18,12 @@ function SciMLBase.__init(prob::SciMLBase.AbstractDDEProblem,
         save_everystep = isempty(saveat),
         save_on = true,
         save_start = save_everystep || isempty(saveat) ||
-                         saveat isa Number || prob.tspan[1] in saveat,
+                     saveat isa Number || prob.tspan[1] in saveat,
         save_end = nothing,
         callback = nothing,
         dense = save_everystep && isempty(saveat),
         calck = (callback !== nothing && callback != CallbackSet()) || # Empty callback
-            dense, # and no dense output
+                dense, # and no dense output
         dt = zero(eltype(prob.tspan)),
         dtmin = DiffEqBase.prob2dtmin(prob; use_end_time = false),
         dtmax = eltype(prob.tspan)(prob.tspan[end] - prob.tspan[1]),
@@ -130,7 +130,8 @@ function SciMLBase.__init(prob::SciMLBase.AbstractDDEProblem,
     rate_prototype = rate_prototype_of(u0, tspan)
 
     # get states (possibly different from the ODE integrator!)
-    u, uprev, uprev2 = u_uprev_uprev2(u0, alg;
+    u, uprev,
+    uprev2 = u_uprev_uprev2(u0, alg;
         alias_u0 = alias_u0,
         adaptive = adaptive,
         allow_extrapolation = allow_extrapolation,
@@ -150,10 +151,12 @@ function SciMLBase.__init(prob::SciMLBase.AbstractDDEProblem,
     f_with_history = ODEFunctionWrapper(f, history)
 
     # initialize output arrays of the solution
-    save_idxs, saved_subsystem = SciMLBase.get_save_idxs_and_saved_subsystem(prob, save_idxs)
+    save_idxs,
+    saved_subsystem = SciMLBase.get_save_idxs_and_saved_subsystem(prob, save_idxs)
 
     k = typeof(rate_prototype)[]
-    ts, timeseries, ks = solution_arrays(u, tspan, rate_prototype;
+    ts, timeseries,
+    ks = solution_arrays(u, tspan, rate_prototype;
         timeseries_init = timeseries_init,
         ts_init = ts_init,
         ks_init = ks_init,
@@ -181,7 +184,8 @@ function SciMLBase.__init(prob::SciMLBase.AbstractDDEProblem,
         stats = stats)
 
     # retrieve time stops, time points at which solutions is saved, and discontinuities
-    tstops_internal = OrdinaryDiffEqCore.initialize_tstops(tType, tstops, d_discontinuities,
+    tstops_internal = OrdinaryDiffEqCore.initialize_tstops(
+        tType, tstops, d_discontinuities,
         tspan)
     saveat_internal = OrdinaryDiffEqCore.initialize_saveat(tType, saveat, tspan)
     d_discontinuities_internal = OrdinaryDiffEqCore.initialize_d_discontinuities(
@@ -193,7 +197,8 @@ function SciMLBase.__init(prob::SciMLBase.AbstractDDEProblem,
         tspan)
 
     maximum_order = OrdinaryDiffEqCore.alg_maximum_order(alg)
-    tstops_propagated, d_discontinuities_propagated = initialize_tstops_d_discontinuities_propagated(
+    tstops_propagated,
+    d_discontinuities_propagated = initialize_tstops_d_discontinuities_propagated(
         tType,
         tstops,
         d_discontinuities,

src/utils.jl

@@ -284,15 +284,17 @@ function build_history_function(prob, alg, rate_prototype, reltol, differential_
 
     # initialize output arrays
     ode_k = typeof(rate_prototype)[]
-    ode_ts, ode_timeseries, ode_ks = solution_arrays(ode_u, tspan, rate_prototype;
+    ode_ts, ode_timeseries,
+    ode_ks = solution_arrays(ode_u, tspan, rate_prototype;
         timeseries_init = (),
         ts_init = (),
         ks_init = (),
         save_idxs = nothing,
         save_start = true)
 
     # obtain cache (we alias uprev2 and uprev)
-    ode_cache = OrdinaryDiffEqCore.alg_cache(alg.alg, ode_u, rate_prototype, uEltypeNoUnits,
+    ode_cache = OrdinaryDiffEqCore.alg_cache(
+        alg.alg, ode_u, rate_prototype, uEltypeNoUnits,
         uBottomEltypeNoUnits, tTypeNoUnits, ode_uprev,
         ode_uprev, ode_f, t0, zero(tType), reltol, p,
         calck,

test/interface/history_function.jl

@@ -127,6 +127,7 @@ end
 
     # test integrator extrapolation
     @testset "integrator extrapolation" for deriv in (Val{0}, Val{1}), idxs in (0, [2])
+
         idxs == 0 && (idxs = nothing)
         # expected value
         trueval = OrdinaryDiffEq.current_interpolant(1, integrator, idxs, deriv)