Fix parsing error and apply JuliaFormatter code formatting

- Fix malformed DiffEqBase.@.. macro syntax in interface.jl:238
- Apply JuliaFormatter to standardize code formatting across the codebase
- Updated formatting in integrators, solve logic, and test files
- Resolves parsing error that prevented JuliaFormatter from processing the repository

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: claude

src/functionwrapper.jl

@@ -8,8 +8,9 @@ end
 (g::SDEDiffusionTermWrapper{true})(du, u, p, t) = g.g(du, u, g.h, p, t)
 (g::SDEDiffusionTermWrapper{false})(u, p, t) = g.g(u, g.h, p, t)
 
-struct SDEFunctionWrapper{iip, F, G, H, TMM, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TWt, TPJ, GG,
-                          TCV, ID, S} <: DiffEqBase.AbstractRODEFunction{iip}
+struct SDEFunctionWrapper{
+    iip, F, G, H, TMM, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TWt, TPJ, GG,
+    TCV, ID, S} <: DiffEqBase.AbstractRODEFunction{iip}
     f::F
     g::G
     h::H
@@ -51,13 +52,13 @@ function wrap_functions_and_history(f::SDDEFunction, g, h)
     end
 
     SDEFunctionWrapper{isinplace(f), typeof(f.f), typeof(gwh), typeof(h),
-                       typeof(f.mass_matrix),
-                       typeof(f.analytic), typeof(f.tgrad), typeof(jac), typeof(f.jvp),
-                       typeof(f.vjp), typeof(f.jac_prototype), typeof(f.sparsity),
-                       typeof(f.Wfact), typeof(f.Wfact_t), typeof(f.paramjac),
-                       typeof(f.ggprime), typeof(f.colorvec), typeof(f.initialization_data),
-                       typeof(f.sys)}(f.f, gwh, h, f.mass_matrix, f.analytic, f.tgrad, jac,
-                       f.jvp, f.vjp, f.jac_prototype, f.sparsity, f.Wfact, f.Wfact_t, f.paramjac,
-                       f.ggprime, f.colorvec, f.initialization_data, f.sys),
+        typeof(f.mass_matrix),
+        typeof(f.analytic), typeof(f.tgrad), typeof(jac), typeof(f.jvp),
+        typeof(f.vjp), typeof(f.jac_prototype), typeof(f.sparsity),
+        typeof(f.Wfact), typeof(f.Wfact_t), typeof(f.paramjac),
+        typeof(f.ggprime), typeof(f.colorvec), typeof(f.initialization_data),
+        typeof(f.sys)}(f.f, gwh, h, f.mass_matrix, f.analytic, f.tgrad, jac,
+        f.jvp, f.vjp, f.jac_prototype, f.sparsity, f.Wfact, f.Wfact_t, f.paramjac,
+        f.ggprime, f.colorvec, f.initialization_data, f.sys),
     gwh
 end

src/integrators/interface.jl

@@ -18,15 +18,15 @@ function (integrator::HistorySDEIntegrator)(t, deriv::Type = Val{0}; idxs = noth
 end
 
 function (integrator::HistorySDEIntegrator)(val::AbstractArray,
-                                            t::Union{Number, AbstractArray},
-                                            deriv::Type = Val{0}; idxs = nothing)
+        t::Union{Number, AbstractArray},
+        deriv::Type = Val{0}; idxs = nothing)
     StochasticDiffEq.current_interpolant!(val, t, integrator, idxs, deriv)
 end
 
 mutable struct SDDEIntegrator{algType, IIP, uType, uEltype, tType, P, eigenType,
-                              tTypeNoUnits, uEltypeNoUnits, randType, randType2, rateType,
-                              solType, cacheType, F, G, F6, OType, noiseType,
-                              EventErrorType, CallbackCacheType, H, IType, IA} <:
+    tTypeNoUnits, uEltypeNoUnits, randType, randType2, rateType,
+    solType, cacheType, F, G, F6, OType, noiseType,
+    EventErrorType, CallbackCacheType, H, IType, IA} <:
                AbstractSDDEIntegrator{algType, IIP, uType, tType}
     f::F
     g::G
@@ -89,6 +89,6 @@ function (integrator::SDDEIntegrator)(t, deriv::Type = Val{0}; idxs = nothing)
 end
 
 function (integrator::SDDEIntegrator)(val::AbstractArray, t::Union{Number, AbstractArray},
-                                      deriv::Type = Val{0}; idxs = nothing)
+        deriv::Type = Val{0}; idxs = nothing)
     StochasticDiffEq.current_interpolant!(val, t, integrator, idxs, deriv)
 end

src/integrators/type.jl

@@ -9,7 +9,7 @@
         elseif tdir_t > tdir_ts_top
             if !integrator.dtchangeable
                 change_t_via_interpolation!(integrator, integrator.tdir * pop!(tstops),
-                                            Val{true})
+                    Val{true})
                 integrator.just_hit_tstop = true
             else
                 error("Something went wrong. Integrator stepped past tstops but the algorithm was dtchangeable. Please report this error.")
@@ -55,7 +55,8 @@ function handle_discontinuities!(integrator::SDDEIntegrator)
         maxΔt = 10eps(integrator.t)
 
         while !isempty(integrator.opts.d_discontinuities) &&
-            abs(first(integrator.opts.d_discontinuities).t - integrator.tdir * integrator.t) <
+            abs(first(integrator.opts.d_discontinuities).t -
+                integrator.tdir * integrator.t) <
             maxΔt
             d2 = pop!(integrator.opts.d_discontinuities)
             order = min(order, d2.order)

src/integrators/utils.jl

@@ -4,8 +4,8 @@ function stepsize_controller!(integrator::SDDEIntegrator, controller::PIControll
     integrator.q = DiffEqBase.value(integrator.q11 /
                                     FastPower.fastpower(integrator.qold, controller.beta2))
     @fastmath integrator.q = DiffEqBase.value(max(inv(integrator.opts.qmax),
-                                                  min(inv(integrator.opts.qmin),
-                                                      integrator.q / integrator.opts.gamma)))
+        min(inv(integrator.opts.qmin),
+            integrator.q / integrator.opts.gamma)))
 end
 
 @inline function step_accept_controller!(integrator::SDDEIntegrator, alg)
@@ -19,5 +19,5 @@ end
 
 function step_reject_controller!(integrator::SDDEIntegrator, controller::PIController, alg)
     integrator.dtnew = integrator.dt / min(inv(integrator.opts.qmin),
-                           integrator.q11 / integrator.opts.gamma)
+        integrator.q11 / integrator.opts.gamma)
 end

src/solve.jl

@@ -54,10 +54,10 @@ Return arrays of saved time points, states, and rates, initialized with the solu
 first time point if `save_start = true` (the default).
 """
 function solution_arrays(u::uType, tspan, rate_prototype;
-                         timeseries_init = typeof(u)[],
-                         ts_init = eltype(tspan)[],
-                         save_idxs = nothing,
-                         save_start = true) where {uType}
+        timeseries_init = typeof(u)[],
+        ts_init = eltype(tspan)[],
+        save_idxs = nothing,
+        save_start = true) where {uType}
     # determine types of time and state
     # uType = typeof(u)
     tType = eltype(tspan)
@@ -108,10 +108,10 @@ Suggest that solution `sol` reserves capacity for a number of elements that
 depends on the parameter settings of the numerical solver.
 """
 function Base.sizehint!(sol::RODESolution, alg, tspan, tstops, saveat;
-                        save_everystep = isempty(saveat),
-                        adaptive = StochasticDiffEq.isadaptive(getalg(alg)),
-                        internalnorm = DiffEqBase.ODE_DEFAULT_NORM,
-                        dt = zero(eltype(tspan)))
+        save_everystep = isempty(saveat),
+        adaptive = StochasticDiffEq.isadaptive(getalg(alg)),
+        internalnorm = DiffEqBase.ODE_DEFAULT_NORM,
+        dt = zero(eltype(tspan)))
     # obtain integration time
     t0 = first(tspan)
     integrationtime = last(tspan) - t0
@@ -137,11 +137,11 @@ function Base.sizehint!(sol::RODESolution, alg, tspan, tstops, saveat;
 end
 
 function build_history_function(prob, alg, reltol, rate_prototype, noise_rate_prototype,
-                                jump_prototype, W, _seed, dense;
-                                dt = zero(eltype(prob.tspan)),
-                                adaptive = StochasticDiffEq.isadaptive(getalg(alg)),
-                                calck = false,
-                                internalnorm = DiffEqBase.ODE_DEFAULT_NORM)
+        jump_prototype, W, _seed, dense;
+        dt = zero(eltype(prob.tspan)),
+        adaptive = StochasticDiffEq.isadaptive(getalg(alg)),
+        calck = false,
+        internalnorm = DiffEqBase.ODE_DEFAULT_NORM)
     @unpack f, g, h, u0, tspan, p = prob
 
     t0 = first(tspan)
@@ -170,52 +170,53 @@ function build_history_function(prob, alg, reltol, rate_prototype, noise_rate_pr
     sde_u, sde_uprev = u_uprev(u0; alias_u0 = false)
 
     # # initialize output arrays
-    sde_ts, sde_timeseries, sde_saveiter = solution_arrays(sde_u, tspan, rate_prototype,
-                                                           save_idxs = nothing,
-                                                           save_start = true)
+    sde_ts, sde_timeseries,
+    sde_saveiter = solution_arrays(sde_u, tspan, rate_prototype,
+        save_idxs = nothing,
+        save_start = true)
 
     # # obtain cache (we alias uprev2 and uprev)
     sde_cache = StochasticDiffEq.alg_cache(getalg(alg), prob, sde_u, W.dW, W.dZ, p,
-                                           rate_prototype, noise_rate_prototype,
-                                           jump_prototype, uEltypeNoUnits,
-                                           uBottomEltypeNoUnits, tTypeNoUnits, sde_uprev, f,
-                                           t0, dt, Val{isinplace(prob)})
+        rate_prototype, noise_rate_prototype,
+        jump_prototype, uEltypeNoUnits,
+        uBottomEltypeNoUnits, tTypeNoUnits, sde_uprev, f,
+        t0, dt, Val{isinplace(prob)})
 
     # build dense interpolation of history
     id = StochasticDiffEq.LinearInterpolationData(sde_timeseries, sde_ts)
     if typeof(getalg(alg)) <: StochasticDiffEq.StochasticDiffEqCompositeAlgorithm
         alg_choice = Int[]
         sde_sol = DiffEqBase.build_solution(prob, alg, sde_ts, sde_timeseries, W = W,
-                                            stats = DiffEqBase.Stats(0),
-                                            calculate_error = false,
-                                            alg_choice = alg_choice,
-                                            interp = id, dense = dense, seed = _seed)
+            stats = DiffEqBase.Stats(0),
+            calculate_error = false,
+            alg_choice = alg_choice,
+            interp = id, dense = dense, seed = _seed)
     else
         sde_sol = DiffEqBase.build_solution(prob, alg, sde_ts, sde_timeseries, W = W,
-                                            stats = DiffEqBase.Stats(0),
-                                            calculate_error = false,
-                                            interp = id, dense = dense, seed = _seed)
+            stats = DiffEqBase.Stats(0),
+            calculate_error = false,
+            interp = id, dense = dense, seed = _seed)
     end
 
     # # reserve capacity
     sizehint!(sde_sol, getalg(alg), tspan, (), ();
-              save_everystep = true, adaptive = adaptive, internalnorm = internalnorm,
-              dt = tType(dt))
+        save_everystep = true, adaptive = adaptive, internalnorm = internalnorm,
+        dt = tType(dt))
 
     # # create simple integrator
     sde_integrator = HistorySDEIntegrator{typeof(getalg(alg)), isinplace(prob),
-                                          typeof(prob.u0),
-                                          tType, typeof(sde_sol), typeof(sde_cache)}(sde_sol,
-                                                                                     sde_u,
-                                                                                     t0,
-                                                                                     zero(tType),
-                                                                                     sde_uprev,
-                                                                                     t0,
-                                                                                     getalg(alg),
-                                                                                     zero(tType),
-                                                                                     tdir,
-                                                                                     1,
-                                                                                     sde_cache)
+        typeof(prob.u0),
+        tType, typeof(sde_sol), typeof(sde_cache)}(sde_sol,
+        sde_u,
+        t0,
+        zero(tType),
+        sde_uprev,
+        t0,
+        getalg(alg),
+        zero(tType),
+        tdir,
+        1,
+        sde_cache)
 
     # # combine the user-provided history function and the ODE integrator with dense solution
     # # to a joint dense history of the DDE