Fix Runic formatting and typos across codebase

ChrisRackauckas · claude · Harsh Singh · commit f08e858e6db5 · 2026-03-30T18:06:43.000+05:30
- Run Runic formatter on all files to fix formatting issues
- Fix typos: reinitiailize -&gt; reinitialize, attactor -&gt; attractor,
  neccessary -&gt; necessary, becase -&gt; because
- Add false positives to .typos.toml: SME (algorithm name), yhat,
  accpt, gam, clos (variable names), Comput (journal abbreviation),
  occurence/occured/occuring (API function names), inferrable (Julia convention)

Co-Authored-By: Chris Rackauckas &lt;accounts@chrisrackauckas.com&gt;
Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/.typos.toml b/.typos.toml
@@ -87,5 +87,23 @@ IIF = "IIF"  # Integrating Factor method (IIF1M, IIF2M, IIF1Mil)
 iif = "iif"
 currate = "currate"  # current rate variable in tau-leaping
 SIE = "SIE"  # SIEA/SIEB algorithm name prefix
+SME = "SME"  # SME algorithm name (Stochastic Modified Euler)
 resetted = "resetted"  # variable name in stepsize control
 strat = "strat"  # Stratonovich abbreviation
+
+# Variable names used in codebase
+yhat = "yhat"  # estimated y value
+accpt = "accpt"  # accepted step flag variable
+gam = "gam"  # gamma abbreviation in tableaux
+clos = "clos"  # closure abbreviation
+
+# Journal abbreviations in BibTeX citations
+Comput = "Comput"  # J. Comput. Phys. (Journal of Computational Physics)
+
+# Function names with historical spelling (API-stable)
+occurence = "occurence"  # in check_event_occurence, is_event_occurence
+occured = "occured"  # in comments near occurence functions
+occuring = "occuring"  # in comments near occurence functions
+
+# Julia spelling convention
+inferrable = "inferrable"  # Julia uses "inferrable" not "inferable"
diff --git a/lib/DiffEqBase/ext/DiffEqBaseReverseDiffExt.jl b/lib/DiffEqBase/ext/DiffEqBaseReverseDiffExt.jl
@@ -175,7 +175,7 @@ function DiffEqBase.solve_up(
     )
 end
 
-# Required becase ReverseDiff.@grad function DiffEqBase.solve_up is not supported!
+# Required because ReverseDiff.@grad function DiffEqBase.solve_up is not supported!
 import DiffEqBase: solve_up
 ReverseDiff.@grad function solve_up(prob, sensealg, u0, p, args...; kwargs...)
     out = DiffEqBase._solve_adjoint(
diff --git a/lib/DiffEqBase/src/callbacks.jl b/lib/DiffEqBase/src/callbacks.jl
@@ -319,7 +319,7 @@ end
 end
 
 """
-Return a nudged (if neccessary) value of `integrator.tprev` to avoid repeat event detection
+Return a nudged (if necessary) value of `integrator.tprev` to avoid repeat event detection
 - `integrator`
 - `callback`: Last occuring callback
 - `condition_tprev`: Condition of last occuring callback evaluated at `integrator.tprev`
diff --git a/lib/DiffEqBase/src/solve.jl b/lib/DiffEqBase/src/solve.jl
@@ -819,7 +819,8 @@ function promote_f(
                 J_T = Base.promote_op(similar, typeof(f.jac_prototype), Type{uElType})
                 sig = Tuple{J_T, typeof(u0), typeof(p), typeof(t)}
                 f = @set f.jac = FunctionWrappersWrappers.FunctionWrappersWrapper(
-                    Void(f.jac), (sig,), (Nothing,))
+                    Void(f.jac), (sig,), (Nothing,)
+                )
             elseif isdefined(f, :sparsity) && f.sparsity isa AbstractMatrix &&
                     !(f.sparsity isa Matrix)
                 # The sparsity pattern is a non-dense matrix (e.g. SparseMatrixCSC).
@@ -836,7 +837,8 @@ function promote_f(
             else
                 sig = Tuple{Matrix{uElType}, typeof(u0), typeof(p), typeof(t)}
                 f = @set f.jac = FunctionWrappersWrappers.FunctionWrappersWrapper(
-                    Void(f.jac), (sig,), (Nothing,))
+                    Void(f.jac), (sig,), (Nothing,)
+                )
             end
         end
         return unwrapped_f(f, wrapfun_iip(f.f, (u0, u0, p, t), Val(CS)))
diff --git a/lib/DiffEqBase/test/downstream/community_callback_tests.jl b/lib/DiffEqBase/test/downstream/community_callback_tests.jl
@@ -98,7 +98,7 @@ using StaticArrays
 using MultiScaleArrays
 
 t_last = 0.0
-function attactor(du, u, p, t)
+function attractor(du, u, p, t)
     α, β = p
     n = length(u.nodes)
     return for k in 1:n
@@ -195,7 +195,7 @@ cback = VectorContinuousCallback(
     (x -> Int(((x - 1) * x) / 2))(length(Newton.nodes))
 )
 
-problemp = ODEProblem(attactor, Newton, (0.0, Inf), parameters)
+problemp = ODEProblem(attractor, Newton, (0.0, Inf), parameters)
 
 world = init(problemp, AutoTsit5(Rosenbrock23()); save_everystep = false, callback = cback)
 
@@ -225,7 +225,7 @@ cb = VectorContinuousCallback(cond!, terminate_affect!, nothing, 1)
 u0 = [0.0, 0.0, 1.0]
 prob = ODEProblem(f!, u0, (0.0, 10.0); callback = cb)
 soln = solve(prob, Tsit5())
-@test soln.t[end] ≈ 4.712347213360699 atol = 1e-4
+@test soln.t[end] ≈ 4.712347213360699 atol = 1.0e-4
 
 odefun = ODEFunction((u, p, t) -> [u[2], u[2] - p]; mass_matrix = [1 0; 0 0])
 callback = PresetTimeCallback(0.5, integ -> (integ.p = -integ.p))
diff --git a/lib/DiffEqBase/test/dynamicquantities_ext.jl b/lib/DiffEqBase/test/dynamicquantities_ext.jl
@@ -25,11 +25,11 @@ using LinearAlgebra
 
     W = DiffEqBase.default_factorize(A)
     x = W \ b
-    @test maximum(abs.(ustrip.(A * x .- b))) ≤ 1e-12
+    @test maximum(abs.(ustrip.(A * x .- b))) ≤ 1.0e-12
 
     x2 = similar(b)
     ldiv!(x2, W, b)
-    @test maximum(abs.(ustrip.(A * x2 .- b))) ≤ 1e-12
+    @test maximum(abs.(ustrip.(A * x2 .- b))) ≤ 1.0e-12
 
     # _infer_ut fallback when all entries are zero
     Az = fill(0.0u"m", 2, 2)
diff --git a/lib/DiffEqBase/test/runtests.jl b/lib/DiffEqBase/test/runtests.jl
@@ -48,8 +48,10 @@ end
 
 @time begin
     # Core tests — basic DiffEqBase functionality, no downstream solvers needed
-    if TEST_GROUP ∉ ("QA", "Static", "Downstream", "Downstream2",
-        "ModelingToolkit", "Sundials")
+    if TEST_GROUP ∉ (
+            "QA", "Static", "Downstream", "Downstream2",
+            "ModelingToolkit", "Sundials",
+        )
         @time @safetestset "Callbacks" include("callbacks.jl")
         @time @safetestset "Plot Vars" include("plot_vars.jl")
         @time @safetestset "Problem Creation Tests" include("problem_creation_tests.jl")
@@ -68,8 +70,10 @@ end
     end
 
     # QA tests — Aqua quality checks
-    if TEST_GROUP ∉ ("Core", "Static", "Downstream", "Downstream2",
-        "ModelingToolkit", "Sundials") && isempty(VERSION.prerelease)
+    if TEST_GROUP ∉ (
+            "Core", "Static", "Downstream", "Downstream2",
+            "ModelingToolkit", "Sundials",
+        ) && isempty(VERSION.prerelease)
         @time @safetestset "Aqua" include("aqua.jl")
     end
 
diff --git a/lib/OrdinaryDiffEqBDF/test/jet.jl b/lib/OrdinaryDiffEqBDF/test/jet.jl
@@ -33,7 +33,7 @@ using Test
         # Regular BDF solvers (ODEProblem)
         regular_bdf_solvers = [
             ABDF2(), QNDF1(), QBDF1(), QNDF2(), QBDF2(), QNDF(), QBDF(), FBDF(),
-            MEBDF2()
+            MEBDF2(),
         ]
         # Some of these are type-stable for the initialization step, but not all
         stable_bdf_solvers = [QNDF(), QBDF(), FBDF(), MEBDF2()]
diff --git a/lib/OrdinaryDiffEqCore/src/solve.jl b/lib/OrdinaryDiffEqCore/src/solve.jl
@@ -717,7 +717,7 @@ function _ode_init(
     success_iter = 0
     erracc = QT(1)
     dtacc = tType(1)
-    reinitiailize = true
+    reinitialize = true
     saveiter = 0 # Starts at 0 so first save is at 1
     saveiter_dense = 0
     fsalfirst, fsallast = _cache !== nothing ? (nothing, nothing) :
@@ -757,7 +757,7 @@ function _ode_init(
         vector_event_last_time,
         last_event_error, accept_step,
         isout, reeval_fsal,
-        u_modified, reinitiailize, isdae,
+        u_modified, reinitialize, isdae,
         opts, stats, initializealg, differential_vars,
         fsalfirst, fsallast, _rng,
         W, P, sqdt,
diff --git a/lib/OrdinaryDiffEqNonlinearSolve/test/jet.jl b/lib/OrdinaryDiffEqNonlinearSolve/test/jet.jl
@@ -41,10 +41,10 @@ using JET
 
         # Solvers which are not fully type-stable for initialization
         iip_unstable_ode_solvers = [
-            ABDF2(), QNDF1(), QBDF1(), QNDF2(), QBDF2(), QNDF(), QBDF(), FBDF(), MEBDF2(), 
+            ABDF2(), QNDF1(), QBDF1(), QNDF2(), QBDF2(), QNDF(), QBDF(), FBDF(), MEBDF2(),
             Rosenbrock23(), Rosenbrock32(), Rodas4(), Rodas4P(), Rodas5(), Rodas5P(),
-            Rosenbrock23(autodiff=ad), Rosenbrock32(autodiff=ad), Rodas4(autodiff=ad), 
-            Rodas4P(autodiff=ad), Rodas5(autodiff=ad), Rodas5P(autodiff=ad),
+            Rosenbrock23(autodiff = ad), Rosenbrock32(autodiff = ad), Rodas4(autodiff = ad),
+            Rodas4P(autodiff = ad), Rodas5(autodiff = ad), Rodas5P(autodiff = ad),
         ]
         # Some of these are type-stable for the initialization step, but not all
         iip_stable_ode_solvers = [
@@ -64,10 +64,10 @@ using JET
 
         # Solvers which are not fully type-stable for initialization
         oop_unstable_ode_solvers = [
-            ABDF2(), QNDF1(), QBDF1(), QNDF2(), QBDF2(), QNDF(), QBDF(), FBDF(), MEBDF2(), 
+            ABDF2(), QNDF1(), QBDF1(), QNDF2(), QBDF2(), QNDF(), QBDF(), FBDF(), MEBDF2(),
             Rosenbrock23(), Rosenbrock32(), Rodas4(), Rodas4P(), Rodas5(), Rodas5P(),
-            Rosenbrock23(autodiff=ad), Rosenbrock32(autodiff=ad), Rodas4(autodiff=ad), 
-            Rodas4P(autodiff=ad), Rodas5(autodiff=ad), Rodas5P(autodiff=ad),
+            Rosenbrock23(autodiff = ad), Rosenbrock32(autodiff = ad), Rodas4(autodiff = ad),
+            Rodas4P(autodiff = ad), Rodas5(autodiff = ad), Rodas5P(autodiff = ad),
         ]
         # Some of these are type-stable for the initialization step, but not all
         oop_stable_ode_solvers = [
@@ -97,4 +97,3 @@ using JET
 
     end
 end
-
diff --git a/lib/StochasticDiffEqLevyArea/src/alg_utils.jl b/lib/StochasticDiffEqLevyArea/src/alg_utils.jl
@@ -26,12 +26,12 @@ function norv end
 Returns the number of terms needed to achieve error at most `eps`.
 """
 function terms_needed(dim, stepsize, eps, alg::AbstractIteratedIntegralAlgorithm, norm::AbstractErrorNorm)
-    ceil(Int64, (errcoeff(dim, stepsize, alg, norm) / eps)^(1 // convorder(alg)))
+    return ceil(Int64, (errcoeff(dim, stepsize, alg, norm) / eps)^(1 // convorder(alg)))
 end
 
 function terms_needed(dim, q_12, stepsize, eps, alg::AbstractIteratedIntegralAlgorithm, norm::AbstractErrorNorm)
     length(q_12) == dim || throw(ArgumentError("Length of q_12 must be equal to the dimension."))
-    ceil(Int64, (errcoeff(dim, q_12, stepsize, alg, norm) / eps)^(1 // convorder(alg)))
+    return ceil(Int64, (errcoeff(dim, q_12, stepsize, alg, norm) / eps)^(1 // convorder(alg)))
 end
 
 """
@@ -40,10 +40,10 @@ end
 Returns the number of random numbers needed with the given parameters.
 """
 function effective_cost(dim, stepsize, eps, alg, norm)
-    norv(dim, terms_needed(dim, stepsize, eps, alg, norm), alg)
+    return norv(dim, terms_needed(dim, stepsize, eps, alg, norm), alg)
 end
 function effective_cost(dim, q_12, stepsize, eps, alg, norm)
-    norv(dim, terms_needed(dim, q_12, stepsize, eps, alg, norm), alg)
+    return norv(dim, terms_needed(dim, q_12, stepsize, eps, alg, norm), alg)
 end
 
 """
diff --git a/lib/StochasticDiffEqLevyArea/src/fourier.jl b/lib/StochasticDiffEqLevyArea/src/fourier.jl
@@ -4,16 +4,20 @@ convorder(::Fourier) = 1 // 2
 errcoeff(m, h, ::Fourier, ::MaxLp{2}) = h * √3 / (√2 * π)
 norv(m, n, ::Fourier) = 2 * m * n
 
-function levyarea(W::AbstractVector{T}, n::Integer, alg::Fourier;
-        rng::AbstractRNG = default_rng()) where {T <: AbstractFloat}
+function levyarea(
+        W::AbstractVector{T}, n::Integer, alg::Fourier;
+        rng::AbstractRNG = default_rng()
+    ) where {T <: AbstractFloat}
     m = length(W)
     X = randn(rng, T, n, m)
     Y = randn(rng, T, m, n)
     return _fourier_area(W, X, Y, n, m)
 end
 
-function levyarea(W::AbstractVector{T}, n::Integer, alg::Fourier,
-        coeffs::LevyAreaCoefficients{T}) where {T <: AbstractFloat}
+function levyarea(
+        W::AbstractVector{T}, n::Integer, alg::Fourier,
+        coeffs::LevyAreaCoefficients{T}
+    ) where {T <: AbstractFloat}
     return _fourier_area(W, coeffs.X, copy(coeffs.Y), n, coeffs.m)
 end
 
diff --git a/lib/StochasticDiffEqLevyArea/src/generate.jl b/lib/StochasticDiffEqLevyArea/src/generate.jl
@@ -6,32 +6,40 @@ depends on the algorithm:
 - Fourier, Milstein, Wiktorsson: X is n×m, Y is m×n
 - MronRoe: X is m×n, Y is n×m
 """
-function generate_coefficients(m::Int, n::Int, alg::Fourier,
-        rng::AbstractRNG = default_rng(); T::Type = Float64)
+function generate_coefficients(
+        m::Int, n::Int, alg::Fourier,
+        rng::AbstractRNG = default_rng(); T::Type = Float64
+    )
     X = randn(rng, T, n, m)
     Y = randn(rng, T, m, n)
     return LevyAreaCoefficients{T}(X, Y, T[], m, n)
 end
 
-function generate_coefficients(m::Int, n::Int, alg::Milstein,
-        rng::AbstractRNG = default_rng(); T::Type = Float64)
+function generate_coefficients(
+        m::Int, n::Int, alg::Milstein,
+        rng::AbstractRNG = default_rng(); T::Type = Float64
+    )
     X = randn(rng, T, n, m)
     Y = randn(rng, T, m, n)
     M = randn(rng, T, m)
     return LevyAreaCoefficients{T}(X, Y, M, m, n)
 end
 
-function generate_coefficients(m::Int, n::Int, alg::Wiktorsson,
-        rng::AbstractRNG = default_rng(); T::Type = Float64)
+function generate_coefficients(
+        m::Int, n::Int, alg::Wiktorsson,
+        rng::AbstractRNG = default_rng(); T::Type = Float64
+    )
     X = randn(rng, T, n, m)
     Y = randn(rng, T, m, n)
     n_tail = (m^2 - m) ÷ 2
     tail = randn(rng, T, n_tail)
     return LevyAreaCoefficients{T}(X, Y, tail, m, n)
 end
 
-function generate_coefficients(m::Int, n::Int, alg::MronRoe,
-        rng::AbstractRNG = default_rng(); T::Type = Float64)
+function generate_coefficients(
+        m::Int, n::Int, alg::MronRoe,
+        rng::AbstractRNG = default_rng(); T::Type = Float64
+    )
     # MronRoe uses transposed layout
     X = randn(rng, T, m, n)
     Y = randn(rng, T, n, m)
diff --git a/lib/StochasticDiffEqLevyArea/src/iterated_integrals.jl b/lib/StochasticDiffEqLevyArea/src/iterated_integrals.jl
@@ -6,7 +6,7 @@ Subtract h/2 from every diagonal element of I (Itô correction).
 function ito_correction!(I, h = 1)
     m, n = size(I)
     m == n || throw(DimensionMismatch("Matrix is not square: dimensions are $(size(I))"))
-    @inbounds for i in 1:m
+    return @inbounds for i in 1:m
         I[i, i] -= h / 2
     end
 end
@@ -16,11 +16,13 @@ end
 
 Simulate iterated stochastic integrals ∫₀ʰ∫₀ˢdWᵢ(t)dWⱼ(s) for all pairs i,j.
 """
-function iterated_integrals(W::AbstractVector{T}, h::Real, eps::Real = h^(3 / 2);
+function iterated_integrals(
+        W::AbstractVector{T}, h::Real, eps::Real = h^(3 / 2);
         ito_correction = true,
         error_norm::AbstractErrorNorm = MaxL2(),
         alg::AbstractIteratedIntegralAlgorithm = optimal_algorithm(length(W), h, eps, error_norm),
-        rng::AbstractRNG = default_rng()) where {T <: AbstractFloat}
+        rng::AbstractRNG = default_rng()
+    ) where {T <: AbstractFloat}
     m = length(W)
     n = terms_needed(m, h, eps, alg, error_norm)
     I = levyarea(W / √h, n, alg; rng = rng)
@@ -36,10 +38,12 @@ end
 
 Compute iterated integrals using pre-generated Fourier coefficients (deterministic).
 """
-function iterated_integrals(W::AbstractVector{T}, h::Real,
+function iterated_integrals(
+        W::AbstractVector{T}, h::Real,
         coeffs::LevyAreaCoefficients{T};
         ito_correction = true,
-        alg::AbstractIteratedIntegralAlgorithm = MronRoe()) where {T <: AbstractFloat}
+        alg::AbstractIteratedIntegralAlgorithm = MronRoe()
+    ) where {T <: AbstractFloat}
     n = coeffs.n
     I = levyarea(W / √h, n, alg, coeffs)
     if ito_correction
@@ -54,11 +58,13 @@ end
 
 Q-Wiener process version.
 """
-function iterated_integrals(W::AbstractVector{T}, q_12::AbstractVector, h::Real, eps::Real;
+function iterated_integrals(
+        W::AbstractVector{T}, q_12::AbstractVector, h::Real, eps::Real;
         ito_correction = true,
         error_norm::AbstractErrorNorm = FrobeniusL2(),
         alg::AbstractIteratedIntegralAlgorithm = optimal_algorithm(length(W), q_12, h, eps, error_norm),
-        rng::AbstractRNG = default_rng()) where {T <: AbstractFloat}
+        rng::AbstractRNG = default_rng()
+    ) where {T <: AbstractFloat}
     m = length(W)
     n = terms_needed(m, q_12, h, eps, alg, error_norm)
     I = levyarea(W ./ q_12 ./ √h, n, alg; rng = rng)
diff --git a/lib/StochasticDiffEqLevyArea/src/milstein.jl b/lib/StochasticDiffEqLevyArea/src/milstein.jl
@@ -4,8 +4,10 @@ convorder(::Milstein) = 1 // 2
 errcoeff(m, h, ::Milstein, ::MaxLp{2}) = h / (√2 * π)
 norv(m, n, ::Milstein) = 2 * m * n + m
 
-function levyarea(W::AbstractVector{T}, n::Integer, alg::Milstein;
-        rng::AbstractRNG = default_rng()) where {T <: AbstractFloat}
+function levyarea(
+        W::AbstractVector{T}, n::Integer, alg::Milstein;
+        rng::AbstractRNG = default_rng()
+    ) where {T <: AbstractFloat}
     m = length(W)
     X = randn(rng, T, n, m)
     Y = randn(rng, T, m, n)
@@ -25,8 +27,10 @@ function levyarea(W::AbstractVector{T}, n::Integer, alg::Milstein;
     return A
 end
 
-function levyarea(W::AbstractVector{T}, n::Integer, alg::Milstein,
-        coeffs::LevyAreaCoefficients{T}) where {T <: AbstractFloat}
+function levyarea(
+        W::AbstractVector{T}, n::Integer, alg::Milstein,
+        coeffs::LevyAreaCoefficients{T}
+    ) where {T <: AbstractFloat}
     M = coeffs.tail[1:(coeffs.m)]
     return _milstein_area(W, coeffs.X, copy(coeffs.Y), M, n, coeffs.m)
 end
diff --git a/lib/StochasticDiffEqLevyArea/src/mronroe.jl b/lib/StochasticDiffEqLevyArea/src/mronroe.jl
@@ -4,8 +4,10 @@ convorder(::MronRoe) = 1 // 1
 errcoeff(m, h, ::MronRoe, ::MaxLp{2}) = √m * h / (√12 * π)
 norv(m, n, ::MronRoe) = 2 * m * n + (m^2 + m) ÷ 2
 
-function levyarea(W::AbstractVector{T}, n::Integer, alg::MronRoe;
-        rng::AbstractRNG = default_rng()) where {T <: AbstractFloat}
+function levyarea(
+        W::AbstractVector{T}, n::Integer, alg::MronRoe;
+        rng::AbstractRNG = default_rng()
+    ) where {T <: AbstractFloat}
     m = length(W)
     X = randn(rng, T, m, n)
     Y = randn(rng, T, n, m)
@@ -29,8 +31,10 @@ function levyarea(W::AbstractVector{T}, n::Integer, alg::MronRoe;
     return A
 end
 
-function levyarea(W::AbstractVector{T}, n::Integer, alg::MronRoe,
-        coeffs::LevyAreaCoefficients{T}) where {T <: AbstractFloat}
+function levyarea(
+        W::AbstractVector{T}, n::Integer, alg::MronRoe,
+        coeffs::LevyAreaCoefficients{T}
+    ) where {T <: AbstractFloat}
     m = coeffs.m
     Ψ = coeffs.tail[1:m]
     tail_extra = coeffs.tail[(m + 1):end]
diff --git a/lib/StochasticDiffEqLevyArea/src/reconstruct.jl b/lib/StochasticDiffEqLevyArea/src/reconstruct.jl
diff --git a/lib/StochasticDiffEqLevyArea/src/wiktorsson.jl b/lib/StochasticDiffEqLevyArea/src/wiktorsson.jl
diff --git a/lib/StochasticDiffEqLevyArea/test/runtests.jl b/lib/StochasticDiffEqLevyArea/test/runtests.jl
diff --git a/test/ad/ad_tests.jl b/test/ad/ad_tests.jl

Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,7 @@ function DiffEqBase.solve_up(`
`175`	`175`	`)`
`176`	`176`	`end`
`177`	`177`
`178`		`-# Required becase ReverseDiff.@grad function DiffEqBase.solve_up is not supported!`
	`178`	`+# Required because ReverseDiff.@grad function DiffEqBase.solve_up is not supported!`
`179`	`179`	`import DiffEqBase: solve_up`
`180`	`180`	`ReverseDiff.@grad function solve_up(prob, sensealg, u0, p, args...; kwargs...)`
`181`	`181`	`out = DiffEqBase._solve_adjoint(`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ using Test`
`33`	`33`	`# Regular BDF solvers (ODEProblem)`
`34`	`34`	`regular_bdf_solvers = [`
`35`	`35`	`ABDF2(), QNDF1(), QBDF1(), QNDF2(), QBDF2(), QNDF(), QBDF(), FBDF(),`
`36`		`- MEBDF2()`
	`36`	`+ MEBDF2(),`
`37`	`37`	`]`
`38`	`38`	`# Some of these are type-stable for the initialization step, but not all`
`39`	`39`	`stable_bdf_solvers = [QNDF(), QBDF(), FBDF(), MEBDF2()]`