format

Author: vyudu

Diff for: lib/SimpleImplicitDiscreteSolve/src/SimpleImplicitDiscreteSolve.jl

@@ -24,20 +24,20 @@ function DiffEqBase.__init(prob::ImplicitDiscreteProblem, alg::SimpleIDSolve; dt
     sol, (sol.retcode != ReturnCode.Success)
 end
 
-function DiffEqBase.solve(prob::ImplicitDiscreteProblem, alg::SimpleIDSolve; 
-    dt = 1,
-    save_everystep = true,
-    save_start = true,
-    adaptive = false,
-    dense = false,
-    save_end = true,
-    kwargs...)
-
+function DiffEqBase.solve(prob::ImplicitDiscreteProblem, alg::SimpleIDSolve;
+        dt = 1,
+        save_everystep = true,
+        save_start = true,
+        adaptive = false,
+        dense = false,
+        save_end = true,
+        kwargs...)
     @assert !adaptive
     @assert !dense
     (initsol, initfail) = DiffEqBase.__init(prob, alg; dt)
     if initfail
-        sol = DiffEqBase.build_solution(prob, alg, prob.tspan[1], u0, k = nothing, stats = nothing, calculate_error = false) 
+        sol = DiffEqBase.build_solution(prob, alg, prob.tspan[1], u0, k = nothing,
+            stats = nothing, calculate_error = false)
         return SciMLBase.solution_new_retcode(sol, ReturnCode.InitialFailure)
     end
 
@@ -66,15 +66,17 @@ function DiffEqBase.solve(prob::ImplicitDiscreteProblem, alg::SimpleIDSolve;
     for i in 2:length(ts)
         uprev = u
         t = ts[i]
-        nlf = isinplace(f) ? (out, u, p) -> f(out, u, uprev, p, t) : (u, p) -> f(u, uprev, p, t)
+        nlf = isinplace(f) ? (out, u, p) -> f(out, u, uprev, p, t) :
+              (u, p) -> f(u, uprev, p, t)
         nlprob = NonlinearProblem{isinplace(f)}(nlf, uprev, p)
         nlsol = solve(nlprob, SimpleNewtonRaphson())
         u = nlsol.u
         save_everystep && (us[i] = u)
         convfail = (nlsol.retcode != ReturnCode.Success)
 
         if convfail
-            sol = DiffEqBase.build_solution(prob, alg, ts[1:i], us[1:i], k = nothing, stats = nothing, calculate_error = false)
+            sol = DiffEqBase.build_solution(prob, alg, ts[1:i], us[1:i], k = nothing,
+                stats = nothing, calculate_error = false)
             sol = SciMLBase.solution_new_retcode(sol, ReturnCode.ConvergenceFailure)
             return sol
         end
@@ -86,7 +88,8 @@ function DiffEqBase.solve(prob::ImplicitDiscreteProblem, alg::SimpleIDSolve;
         calculate_error = false)
 
     DiffEqBase.has_analytic(prob.f) &&
-        DiffEqBase.calculate_solution_errors!(sol; timeseries_errors = true, dense_errors = false)
+        DiffEqBase.calculate_solution_errors!(
+            sol; timeseries_errors = true, dense_errors = false)
     sol
 end
 

Diff for: lib/SimpleImplicitDiscreteSolve/test/runtests.jl

@@ -6,39 +6,39 @@ using OrdinaryDiffEqSDIRK
 # Test implicit Euler using ImplicitDiscreteProblem
 @testset "Implicit Euler" begin
     function lotkavolterra(u, p, t)
-        [1.5*u[1] - u[1]*u[2], -3.0*u[2] + u[1]*u[2]]
+        [1.5 * u[1] - u[1] * u[2], -3.0 * u[2] + u[1] * u[2]]
     end
 
     function f!(resid, u_next, u, p, t)
         lv = lotkavolterra(u_next, p, t)
-        resid[1] = u_next[1] - u[1] - 0.01*lv[1]
-        resid[2] = u_next[2] - u[2] - 0.01*lv[2]
+        resid[1] = u_next[1] - u[1] - 0.01 * lv[1]
+        resid[2] = u_next[2] - u[2] - 0.01 * lv[2]
         nothing
     end
-    u0 = [1., 1.]
-    tspan = (0., 0.5)
+    u0 = [1.0, 1.0]
+    tspan = (0.0, 0.5)
 
     idprob = ImplicitDiscreteProblem(f!, u0, tspan, [])
     idsol = solve(idprob, SimpleIDSolve(), dt = 0.01)
 
     oprob = ODEProblem(lotkavolterra, u0, tspan)
     osol = solve(oprob, ImplicitEuler())
 
-    @test isapprox(idsol[end-1], osol[end], atol = 0.1)
+    @test isapprox(idsol[end - 1], osol[end], atol = 0.1)
 
     ### free-fall
     # y, dy
-    function ff(u, p, t) 
+    function ff(u, p, t)
         [u[2], -9.8]
     end
 
-    function g!(resid, u_next, u, p, t) 
-        f = ff(u_next, p, t) 
-        resid[1] = u_next[1] - u[1] - 0.01*f[1]
-        resid[2] = u_next[2] - u[2] - 0.01*f[2]
+    function g!(resid, u_next, u, p, t)
+        f = ff(u_next, p, t)
+        resid[1] = u_next[1] - u[1] - 0.01 * f[1]
+        resid[2] = u_next[2] - u[2] - 0.01 * f[2]
         nothing
     end
-    u0 = [10., 0.]
+    u0 = [10.0, 0.0]
     tspan = (0, 0.5)
 
     idprob = ImplicitDiscreteProblem(g!, u0, tspan, [])
@@ -47,17 +47,17 @@ using OrdinaryDiffEqSDIRK
     oprob = ODEProblem(ff, u0, tspan)
     osol = solve(oprob, ImplicitEuler())
 
-    @test isapprox(idsol[end-1], osol[end], atol = 0.1)
+    @test isapprox(idsol[end - 1], osol[end], atol = 0.1)
 end
 
 @testset "Solver initializes" begin
-    function periodic!(resid, u_next, u, p, t) 
-        resid[1] = u_next[1] - u[1] - sin(t*π/4)
-        resid[2] = 16 - u_next[2]^2 - u_next[1]^2 
+    function periodic!(resid, u_next, u, p, t)
+        resid[1] = u_next[1] - u[1] - sin(t * π / 4)
+        resid[2] = 16 - u_next[2]^2 - u_next[1]^2
     end
 
     tsteps = 15
-    u0 = [1., 3.]
+    u0 = [1.0, 3.0]
     idprob = ImplicitDiscreteProblem(periodic!, u0, (0, tsteps), [])
     initsol, initfail = DiffEqBase.__init(idprob, SimpleIDSolve())
     @test initsol.u[1]^2 + initsol.u[2]^2 ≈ 16