Run formatter

Author: avik-pal

Diff for: src/core/approximate_jacobian.jl

@@ -165,18 +165,17 @@ function SciMLBase.__init(
         INV = store_inverse_jacobian(alg.update_rule)
 
         linsolve = get_linear_solver(alg.descent)
-        initialization_cache = __internal_init(
-            prob, alg.initialization, alg, f, fu, u, p; stats, linsolve, maxiters, internalnorm)
+        initialization_cache = __internal_init(prob, alg.initialization, alg, f, fu, u, p;
+            stats, linsolve, maxiters, internalnorm)
 
         abstol, reltol, termination_cache = init_termination_cache(
             prob, abstol, reltol, fu, u, termination_condition)
         linsolve_kwargs = merge((; abstol, reltol), linsolve_kwargs)
 
         J = initialization_cache(nothing)
         inv_workspace, J = INV ? __safe_inv_workspace(J) : (nothing, J)
-        descent_cache = __internal_init(
-            prob, alg.descent, J, fu, u; stats, abstol, reltol, internalnorm,
-            linsolve_kwargs, pre_inverted = Val(INV), timer)
+        descent_cache = __internal_init(prob, alg.descent, J, fu, u; stats, abstol, reltol,
+            internalnorm, linsolve_kwargs, pre_inverted = Val(INV), timer)
         du = get_du(descent_cache)
 
         reinit_rule_cache = __internal_init(alg.reinit_rule, J, fu, u, du)

Diff for: src/core/generalized_first_order.jl

@@ -153,9 +153,10 @@ end
 
 function SciMLBase.__init(
         prob::AbstractNonlinearProblem{uType, iip}, alg::GeneralizedFirstOrderAlgorithm,
-        args...; stats=empty_nlstats(), alias_u0 = false, maxiters = 1000, abstol = nothing,
-        reltol = nothing, maxtime = nothing, termination_condition = nothing,
-        internalnorm = DEFAULT_NORM, linsolve_kwargs = (;), kwargs...) where {uType, iip}
+        args...; stats = empty_nlstats(), alias_u0 = false, maxiters = 1000,
+        abstol = nothing, reltol = nothing, maxtime = nothing,
+        termination_condition = nothing, internalnorm = DEFAULT_NORM,
+        linsolve_kwargs = (;), kwargs...) where {uType, iip}
     timer = get_timer_output()
     @static_timeit timer "cache construction" begin
         (; f, u0, p) = prob
@@ -173,8 +174,8 @@ function SciMLBase.__init(
             prob, alg, f, fu, u, p; stats, autodiff = alg.jacobian_ad, linsolve,
             jvp_autodiff = alg.forward_ad, vjp_autodiff = alg.reverse_ad)
         J = jac_cache(nothing)
-        descent_cache = __internal_init(prob, alg.descent, J, fu, u; stats, abstol, reltol,
-            internalnorm, linsolve_kwargs, timer)
+        descent_cache = __internal_init(prob, alg.descent, J, fu, u; stats, abstol,
+            reltol, internalnorm, linsolve_kwargs, timer)
         du = get_du(descent_cache)
 
         if alg.trustregion !== missing && alg.linesearch !== missing

Diff for: src/core/generic.jl

@@ -1,5 +1,5 @@
 function SciMLBase.__solve(prob::Union{NonlinearProblem, NonlinearLeastSquaresProblem},
-        alg::AbstractNonlinearSolveAlgorithm, args...; stats=empty_nlstats(), kwargs...)
+        alg::AbstractNonlinearSolveAlgorithm, args...; stats = empty_nlstats(), kwargs...)
     cache = SciMLBase.__init(prob, alg, args...; stats, kwargs...)
     return solve!(cache)
 end

Diff for: src/descent/steepest.jl

@@ -30,8 +30,8 @@ end
 @internal_caches SteepestDescentCache :lincache
 
 @inline function __internal_init(
-        prob::AbstractNonlinearProblem, alg::SteepestDescent, J, fu,
-        u; stats, shared::Val{N} = Val(1), pre_inverted::Val{INV} = False,
+        prob::AbstractNonlinearProblem, alg::SteepestDescent, J, fu, u;
+        stats, shared::Val{N} = Val(1), pre_inverted::Val{INV} = False,
         linsolve_kwargs = (;), abstol = nothing, reltol = nothing,
         timer = get_timer_output(), kwargs...) where {INV, N}
     INV && @assert length(fu)==length(u) "Non-Square Jacobian Inverse doesn't make sense."
@@ -40,8 +40,8 @@ end
         @bb δu_ = similar(u)
     end
     if INV
-        lincache = LinearSolverCache(alg, alg.linsolve, transpose(J), _vec(fu),
-            _vec(u); stats, abstol, reltol, linsolve_kwargs...)
+        lincache = LinearSolverCache(alg, alg.linsolve, transpose(J), _vec(fu), _vec(u);
+            stats, abstol, reltol, linsolve_kwargs...)
     else
         lincache = nothing
     end

Diff for: src/globalization/line_search.jl

@@ -251,8 +251,8 @@ end
 end
 
 function __internal_init(
-        prob::AbstractNonlinearProblem, alg::RobustNonMonotoneLineSearch, f::F, fu,
-        u, p, args...; stats, internalnorm::IN = DEFAULT_NORM, kwargs...) where {F, IN}
+        prob::AbstractNonlinearProblem, alg::RobustNonMonotoneLineSearch, f::F, fu, u,
+        p, args...; stats, internalnorm::IN = DEFAULT_NORM, kwargs...) where {F, IN}
     @bb u_cache = similar(u)
     @bb fu_cache = similar(fu)
     T = promote_type(eltype(fu), eltype(u))
@@ -343,8 +343,8 @@ end
 end
 
 function __internal_init(
-        prob::AbstractNonlinearProblem, alg::LiFukushimaLineSearch, f::F, fu, u,
-        p, args...; stats, internalnorm::IN = DEFAULT_NORM, kwargs...) where {F, IN}
+        prob::AbstractNonlinearProblem, alg::LiFukushimaLineSearch, f::F, fu, u, p,
+        args...; stats, internalnorm::IN = DEFAULT_NORM, kwargs...) where {F, IN}
     @bb u_cache = similar(u)
     @bb fu_cache = similar(fu)
     T = promote_type(eltype(fu), eltype(u))

Diff for: src/globalization/trust_region.jl

@@ -366,8 +366,8 @@ end
 @inline __expand_factor(::Nothing, ::Type{T}, method) where {T} = T(2)
 
 function __internal_init(
-        prob::AbstractNonlinearProblem, alg::GenericTrustRegionScheme, f::F, fu,
-        u, p, args...; stats, internalnorm::IF = DEFAULT_NORM, kwargs...) where {F, IF}
+        prob::AbstractNonlinearProblem, alg::GenericTrustRegionScheme, f::F, fu, u,
+        p, args...; stats, internalnorm::IF = DEFAULT_NORM, kwargs...) where {F, IF}
     T = promote_type(eltype(u), eltype(fu))
     u0_norm = internalnorm(u)
     fu_norm = internalnorm(fu)

Diff for: src/internal/jacobian.jl

@@ -49,9 +49,8 @@ function reinit_cache!(cache::JacobianCache{iip}, args...; p = cache.p,
     cache.uf = JacobianWrapper{iip}(cache.f, p)
 end
 
-function JacobianCache(
-        prob, alg, f::F, fu_, u, p; stats, autodiff = nothing, vjp_autodiff = nothing,
-        jvp_autodiff = nothing, linsolve = missing) where {F}
+function JacobianCache(prob, alg, f::F, fu_, u, p; stats, autodiff = nothing,
+        vjp_autodiff = nothing, jvp_autodiff = nothing, linsolve = missing) where {F}
     iip = isinplace(prob)
     uf = JacobianWrapper{iip}(f, p)
 
@@ -96,8 +95,8 @@ function JacobianCache(
         J, f, uf, fu, u, p, jac_cache, alg, stats, autodiff, vjp_autodiff, jvp_autodiff)
 end
 
-function JacobianCache(
-        prob, alg, f::F, ::Number, u::Number, p; stats, autodiff = nothing, kwargs...) where {F}
+function JacobianCache(prob, alg, f::F, ::Number, u::Number, p; stats,
+        autodiff = nothing, kwargs...) where {F}
     uf = JacobianWrapper{false}(f, p)
     autodiff = get_concrete_forward_ad(autodiff, prob; check_forward_mode = false)
     if !(autodiff isa AutoForwardDiff ||

Diff for: src/utils.jl

@@ -146,8 +146,9 @@ function __build_solution_less_specialize(prob::AbstractNonlinearProblem, alg, u
     T = eltype(eltype(u))
     N = ndims(u)
 
-    return SciMLBase.NonlinearSolution{T, N, typeof(u), typeof(resid), typeof(prob),
-        typeof(alg), Any, typeof(left), typeof(stats), typeof(trace)}(
+    return SciMLBase.NonlinearSolution{
+        T, N, typeof(u), typeof(resid), typeof(prob), typeof(alg),
+        Any, typeof(left), typeof(stats), typeof(trace)}(
         u, resid, prob, alg, retcode, original, left, right, stats, trace)
 end