Merge pull request #174 from SciML/auto-juliaformatter-pr

ChrisRackauckas · web-flow · commit 464f4178d76a · 2025-04-05T20:40:14.000-04:00
Automatic JuliaFormatter.jl run
diff --git a/ext/SimpleNonlinearSolveChainRulesCoreExt.jl b/ext/SimpleNonlinearSolveChainRulesCoreExt.jl
@@ -10,7 +10,8 @@ using SimpleNonlinearSolve: SimpleNonlinearSolve, ImmutableNonlinearProblem
 function ChainRulesCore.rrule(::typeof(SimpleNonlinearSolve.__internal_solve_up),
         prob::Union{ImmutableNonlinearProblem, NonlinearLeastSquaresProblem},
         sensealg, u0, u0_changed, p, p_changed, alg, args...; kwargs...)
-    out, ∇internal = DiffEqBase._solve_adjoint(
+    out,
+    ∇internal = DiffEqBase._solve_adjoint(
         prob, sensealg, u0, p, ChainRulesOriginator(), alg, args...; kwargs...)
     function ∇__internal_solve_up(Δ)
         ∂f, ∂prob, ∂sensealg, ∂u0, ∂p, ∂originator, ∂args... = ∇internal(Δ)
diff --git a/ext/SimpleNonlinearSolveReverseDiffExt.jl b/ext/SimpleNonlinearSolveReverseDiffExt.jl
@@ -52,7 +52,8 @@ for pType in (ImmutableNonlinearProblem, NonlinearLeastSquaresProblem)
         ReverseDiff.@grad function __internal_solve_up(
                 prob::$(pType), sensealg, u0, u0_changed,
                 p, p_changed, alg, args...; kwargs...)
-            out, ∇internal = DiffEqBase._solve_adjoint(
+            out,
+            ∇internal = DiffEqBase._solve_adjoint(
                 prob, sensealg, ReverseDiff.value(u0), ReverseDiff.value(p),
                 ReverseDiffOriginator(), alg, args...; kwargs...)
             function ∇__internal_solve_up(_args...)
diff --git a/ext/SimpleNonlinearSolveTaylorDiffExt.jl b/ext/SimpleNonlinearSolveTaylorDiffExt.jl
@@ -38,8 +38,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleHousehold
     @bb xo = copy(x)
     f = __fixed_parameter_function(prob)
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     for i in 1:maxiters
         num, den, fx = __get_higher_order_derivatives(alg, prob, f, x, fx)
diff --git a/ext/SimpleNonlinearSolveTrackerExt.jl b/ext/SimpleNonlinearSolveTrackerExt.jl
@@ -33,11 +33,13 @@ for pType in (ImmutableNonlinearProblem, NonlinearLeastSquaresProblem)
                 p_, p_changed, alg, args...; kwargs...)
             u0, p = Tracker.data(u0_), Tracker.data(p_)
             prob = remake(_prob; u0, p)
-            out, ∇internal = DiffEqBase._solve_adjoint(
+            out,
+            ∇internal = DiffEqBase._solve_adjoint(
                 prob, sensealg, u0, p, TrackerOriginator(), alg, args...; kwargs...)
 
             function ∇__internal_solve_up(Δ)
-                ∂prob, ∂sensealg, ∂u0, ∂p, ∂originator, ∂args... = ∇internal(Tracker.data(Δ))
+                ∂prob, ∂sensealg, ∂u0, ∂p, ∂originator,
+                ∂args... = ∇internal(Tracker.data(Δ))
                 return (∂prob, ∂sensealg, ∂u0, nothing, ∂p, nothing, nothing, ∂args...)
             end
 
diff --git a/src/ad.jl b/src/ad.jl
@@ -90,14 +90,16 @@ function __nlsolve_ad(prob::NonlinearLeastSquaresProblem, alg, args...; kwargs..
                 return nothing
             end
         else
-            _F = @closure (u, p) -> begin
+            _F = @closure (
+                u, p) -> begin
                 resid = prob.f(u, p)
                 return reshape(2 .* prob.f.vjp(resid, u, p), size(u))
             end
         end
     elseif SciMLBase.has_jac(prob.f)
         if isinplace(prob)
-            _F = @closure (du, u, p) -> begin
+            _F = @closure (
+                du, u, p) -> begin
                 J = __similar(du, length(sol.resid), length(u))
                 prob.f.jac(J, u, p)
                 resid = __similar(du, length(sol.resid))
@@ -106,13 +108,15 @@ function __nlsolve_ad(prob::NonlinearLeastSquaresProblem, alg, args...; kwargs..
                 return nothing
             end
         else
-            _F = @closure (u, p) -> begin
+            _F = @closure (u,
+                p) -> begin
                 return reshape(2 .* vec(prob.f(u, p))' * prob.f.jac(u, p), size(u))
             end
         end
     else
         if isinplace(prob)
-            _F = @closure (du, u, p) -> begin
+            _F = @closure (du, u,
+                p) -> begin
                 _f = @closure (du, u) -> prob.f(du, u, p)
                 resid = __similar(du, length(sol.resid))
                 v, J = DI.value_and_jacobian(_f, resid, AutoForwardDiff(), u)
@@ -128,7 +132,8 @@ function __nlsolve_ad(prob::NonlinearLeastSquaresProblem, alg, args...; kwargs..
                     return __zygote_compute_nlls_vjp(_f, u, p)
                 end
             else
-                _F = @closure (u, p) -> begin
+                _F = @closure (
+                    u, p) -> begin
                     _f = Base.Fix2(prob.f, p)
                     v, J = DI.value_and_jacobian(_f, AutoForwardDiff(), u)
                     return reshape(2 .* vec(v)' * J, size(u))
diff --git a/src/bracketing/bisection.jl b/src/bracketing/bisection.jl
@@ -72,8 +72,10 @@ function SciMLBase.solve(prob::IntervalNonlinearProblem, alg::Bisection,
         end
     end
 
-    sol, i, left, right, fl, fr = __bisection(
-        left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
+    sol, i,
+    left,
+    right,
+    fl, fr = __bisection(left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
 
     sol !== nothing && return sol
 
diff --git a/src/bracketing/brent.jl b/src/bracketing/brent.jl
@@ -109,8 +109,10 @@ function SciMLBase.solve(prob::IntervalNonlinearProblem, alg::Brent, args...;
         end
     end
 
-    sol, i, left, right, fl, fr = __bisection(
-        left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
+    sol, i,
+    left,
+    right,
+    fl, fr = __bisection(left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
 
     sol !== nothing && return sol
 
diff --git a/src/bracketing/falsi.jl b/src/bracketing/falsi.jl
@@ -67,8 +67,10 @@ function SciMLBase.solve(prob::IntervalNonlinearProblem, alg::Falsi, args...;
         end
     end
 
-    sol, i, left, right, fl, fr = __bisection(
-        left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
+    sol, i,
+    left,
+    right,
+    fl, fr = __bisection(left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
     sol !== nothing && return sol
 
     return SciMLBase.build_solution(
diff --git a/src/bracketing/ridder.jl b/src/bracketing/ridder.jl
@@ -74,8 +74,10 @@ function SciMLBase.solve(prob::IntervalNonlinearProblem, alg::Ridder, args...;
         end
     end
 
-    sol, i, left, right, fl, fr = __bisection(
-        left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
+    sol, i,
+    left,
+    right,
+    fl, fr = __bisection(left, right, fl, fr, f; abstol, maxiters = maxiters - i, prob, alg)
     sol !== nothing && return sol
 
     return SciMLBase.build_solution(
diff --git a/src/linesearch.jl b/src/linesearch.jl
@@ -50,7 +50,8 @@ function __generic_init(alg::LiFukushimaLineSearch, prob, fu, u)
     @bb fu_cache = similar(fu)
     T = promote_type(eltype(fu), eltype(u))
 
-    ϕ = @closure (u, δu, α) -> begin
+    ϕ = @closure (u, δu,
+        α) -> begin
         @bb @. u_cache = u + α * δu
         return NONLINEARSOLVE_DEFAULT_NORM(__eval_f(prob, fu_cache, u_cache))
     end
diff --git a/src/nlsolve/broyden.jl b/src/nlsolve/broyden.jl
@@ -48,8 +48,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleBroyden,
     @bb δJ⁻¹n = copy(x)
     @bb δJ⁻¹ = copy(J⁻¹)
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     ls_cache = __get_linesearch(alg) === Val(true) ? LiFukushimaLineSearch()(prob, fx, x) :
                nothing
diff --git a/src/nlsolve/dfsane.jl b/src/nlsolve/dfsane.jl
@@ -70,8 +70,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleDFSane{M}
     τ_min = T(alg.τ_min)
     τ_max = T(alg.τ_max)
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     fx_norm = NONLINEARSOLVE_DEFAULT_NORM(fx)^nexp
     α_1 = one(T)
diff --git a/src/nlsolve/halley.jl b/src/nlsolve/halley.jl
@@ -33,8 +33,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleHalley, a
 
     f = __fixed_parameter_function(prob)
     autodiff = __get_concrete_autodiff(prob, alg.autodiff)
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     @bb xo = copy(x)
 
diff --git a/src/nlsolve/klement.jl b/src/nlsolve/klement.jl
@@ -13,8 +13,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleKlement,
     T = eltype(x)
     fx = _get_fx(prob, x)
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     @bb δx = copy(x)
     @bb fprev = copy(fx)
diff --git a/src/nlsolve/lbroyden.jl b/src/nlsolve/lbroyden.jl
@@ -63,8 +63,8 @@ end
 
     U, Vᵀ = __init_low_rank_jacobian(x, fx, x isa StaticArray ? threshold : Val(η))
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     @bb xo = copy(x)
     @bb δx = copy(fx)
@@ -140,7 +140,8 @@ function __static_solve(
         init_α = inv(alg.alpha)
     end
 
-    converged, res = __unrolled_lbroyden_initial_iterations(
+    converged,
+    res = __unrolled_lbroyden_initial_iterations(
         prob, xo, fo, δx, abstol, U, Vᵀ, threshold, ls_cache, init_α)
 
     converged &&
diff --git a/src/nlsolve/raphson.jl b/src/nlsolve/raphson.jl
@@ -34,8 +34,8 @@ function SciMLBase.__solve(
     f = __fixed_parameter_function(prob)
     J, jac_cache = jacobian_cache(autodiff, prob, f, fx, x)
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     for i in 1:maxiters
         fx, dfx = value_and_jacobian(autodiff, prob, f, fx, x, jac_cache; J)
diff --git a/src/nlsolve/trustRegion.jl b/src/nlsolve/trustRegion.jl
@@ -89,8 +89,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleTrustRegi
     J, jac_cache = jacobian_cache(autodiff, prob, f, fx, x)
     fx, ∇f = value_and_jacobian(autodiff, prob, f, fx, x, jac_cache; J)
 
-    abstol, reltol, tc_cache = init_termination_cache(
-        prob, abstol, reltol, fx, x, termination_condition)
+    abstol, reltol,
+    tc_cache = init_termination_cache(prob, abstol, reltol, fx, x, termination_condition)
 
     # Set default trust region radius if not specified by user.
     Δₘₐₓ == 0 && (Δₘₐₓ = max(norm_fx, maximum(x) - minimum(x)))
diff --git a/src/termination_conditions.jl b/src/termination_conditions.jl
@@ -112,6 +112,7 @@ for name in (:Norm, :RelNorm, :AbsNorm)
 end
 
 for norm_type in (:Rel, :Abs), safety in (:Safe, :SafeBest)
+
     struct_name = Symbol(norm_type, safety, :TerminationMode)
     supertype_name = Symbol(:Abstract, safety, :NonlinearTerminationMode)
 
diff --git a/src/termination_conditions_deprecated.jl b/src/termination_conditions_deprecated.jl
@@ -245,8 +245,7 @@ function (cond::NLSolveTerminationCondition)(storage::Union{
             if objective ≤ typeof(criteria)(patience_objective_multiplier) * criteria
                 if nstep ≥ cond.safe_termination_options.patience_steps
                     last_k_values = objective_values[max(1,
-                        length(objective_values) -
-                        cond.safe_termination_options.patience_steps):end]
+                        length(objective_values) - cond.safe_termination_options.patience_steps):end]
                     if maximum(last_k_values) <
                        typeof(criteria)(cond.safe_termination_options.min_max_factor) *
                        minimum(last_k_values)
diff --git a/src/utils.jl b/src/utils.jl
@@ -205,8 +205,8 @@ end
 @inline value(x::Dual) = ForwardDiff.value(x)
 @inline value(x::AbstractArray{<:Dual}) = map(ForwardDiff.value, x)
 
-@inline __eval_f(prob, fx, x) = isinplace(prob) ? (prob.f(fx, x, prob.p); fx) :
-                                prob.f(x, prob.p)
+@inline __eval_f(
+    prob, fx, x) = isinplace(prob) ? (prob.f(fx, x, prob.p); fx) : prob.f(x, prob.p)
 
 # Unalias
 @inline __maybe_unaliased(x::Union{Number, SArray}, ::Bool) = x
diff --git a/test/core/23_test_problems_tests.jl b/test/core/23_test_problems_tests.jl
@@ -43,64 +43,64 @@ export problems, dicts, test_on_library
 end
 
 @testitem "23 Test Problems: SimpleNewtonRaphson" setup=[RobustnessTesting] tags=[:core] begin
-    alg_ops = (SimpleNewtonRaphson(),)
+    alg_ops=(SimpleNewtonRaphson(),)
 
-    broken_tests = Dict(alg => Int[] for alg in alg_ops)
-    broken_tests[alg_ops[1]] = []
+    broken_tests=Dict(alg=>Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]]=[]
 
     test_on_library(problems, dicts, alg_ops, broken_tests)
 end
 
 @testitem "23 Test Problems: SimpleHalley" setup=[RobustnessTesting] tags=[:core] begin
-    alg_ops = (SimpleHalley(),)
+    alg_ops=(SimpleHalley(),)
 
-    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests=Dict(alg=>Int[] for alg in alg_ops)
     if Sys.isapple()
-        broken_tests[alg_ops[1]] = [1, 5, 11, 15, 16, 18]
+        broken_tests[alg_ops[1]]=[1, 5, 11, 15, 16, 18]
     else
-        broken_tests[alg_ops[1]] = [1, 5, 15, 16, 18]
+        broken_tests[alg_ops[1]]=[1, 5, 15, 16, 18]
     end
 
     test_on_library(problems, dicts, alg_ops, broken_tests)
 end
 
 @testitem "23 Test Problems: SimpleTrustRegion" setup=[RobustnessTesting] tags=[:core] begin
-    alg_ops = (SimpleTrustRegion(), SimpleTrustRegion(; nlsolve_update_rule = Val(true)))
+    alg_ops=(SimpleTrustRegion(), SimpleTrustRegion(; nlsolve_update_rule = Val(true)))
 
-    broken_tests = Dict(alg => Int[] for alg in alg_ops)
-    broken_tests[alg_ops[1]] = [3, 15, 16, 21]
-    broken_tests[alg_ops[2]] = [15, 16]
+    broken_tests=Dict(alg=>Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]]=[3, 15, 16, 21]
+    broken_tests[alg_ops[2]]=[15, 16]
 
     test_on_library(problems, dicts, alg_ops, broken_tests)
 end
 
 @testitem "23 Test Problems: SimpleDFSane" setup=[RobustnessTesting] tags=[:core] begin
-    alg_ops = (SimpleDFSane(),)
+    alg_ops=(SimpleDFSane(),)
 
-    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests=Dict(alg=>Int[] for alg in alg_ops)
     if Sys.isapple()
-        broken_tests[alg_ops[1]] = [1, 2, 3, 5, 6, 21]
+        broken_tests[alg_ops[1]]=[1, 2, 3, 5, 6, 21]
     else
-        broken_tests[alg_ops[1]] = [1, 2, 3, 4, 5, 6, 11, 21]
+        broken_tests[alg_ops[1]]=[1, 2, 3, 4, 5, 6, 11, 21]
     end
 
     test_on_library(problems, dicts, alg_ops, broken_tests)
 end
 
 @testitem "23 Test Problems: SimpleBroyden" setup=[RobustnessTesting] tags=[:core] begin
-    alg_ops = (SimpleBroyden(),)
+    alg_ops=(SimpleBroyden(),)
 
-    broken_tests = Dict(alg => Int[] for alg in alg_ops)
-    broken_tests[alg_ops[1]] = [1, 5, 11]
+    broken_tests=Dict(alg=>Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]]=[1, 5, 11]
 
     test_on_library(problems, dicts, alg_ops, broken_tests)
 end
 
 @testitem "23 Test Problems: SimpleKlement" setup=[RobustnessTesting] tags=[:core] begin
-    alg_ops = (SimpleKlement(),)
+    alg_ops=(SimpleKlement(),)
 
-    broken_tests = Dict(alg => Int[] for alg in alg_ops)
-    broken_tests[alg_ops[1]] = [1, 2, 4, 5, 11, 12, 22]
+    broken_tests=Dict(alg=>Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]]=[1, 2, 4, 5, 11, 12, 22]
 
     test_on_library(problems, dicts, alg_ops, broken_tests)
 end
diff --git a/test/core/exotic_type_tests.jl b/test/core/exotic_type_tests.jl
@@ -17,13 +17,13 @@ end
 
     for alg in [SimpleNewtonRaphson(), SimpleBroyden(), SimpleKlement(), SimpleDFSane(),
         SimpleTrustRegion(), SimpleLimitedMemoryBroyden(; threshold = 2), SimpleHalley()]
-        sol = solve(prob_oop_bf, alg)
+        sol=solve(prob_oop_bf, alg)
         @test norm(sol.resid, Inf) < 1e-6
         @test SciMLBase.successful_retcode(sol.retcode)
 
-        alg isa SimpleHalley && continue
+        alg isa SimpleHalley&&continue
 
-        sol = solve(prob_iip_bf, alg)
+        sol=solve(prob_iip_bf, alg)
         @test norm(sol.resid, Inf) < 1e-6
         @test SciMLBase.successful_retcode(sol.retcode)
     end
diff --git a/test/core/forward_ad_tests.jl b/test/core/forward_ad_tests.jl
@@ -41,8 +41,8 @@ export test_f, test_f!, jacobian_f, solve_with, __compatible
 end
 
 @testitem "ForwardDiff.jl Integration: Rootfinding" setup=[ForwardADRootfindingTesting] tags=[:core] begin
-    @testset "$(nameof(typeof(alg)))" for alg in (
-        SimpleNewtonRaphson(), SimpleTrustRegion(),
+    @testset "$(nameof(typeof(alg)))" for alg in
+                                          (SimpleNewtonRaphson(), SimpleTrustRegion(),
         SimpleTrustRegion(; nlsolve_update_rule = Val(true)),
         SimpleHalley(), SimpleBroyden(), SimpleKlement(), SimpleDFSane())
         us = (2.0, @SVector[1.0, 1.0], [1.0, 1.0], ones(2, 2), @SArray ones(2, 2))
@@ -135,8 +135,8 @@ export loss_function, loss_function!, loss_function_jac, loss_function_vjp,
 end
 
 @testitem "ForwardDiff.jl Integration: NLLS" setup=[ForwardADNLLSTesting] tags=[:core] begin
-    @testset "$(nameof(typeof(alg)))" for alg in (
-        SimpleNewtonRaphson(), SimpleGaussNewton(),
+    @testset "$(nameof(typeof(alg)))" for alg in
+                                          (SimpleNewtonRaphson(), SimpleGaussNewton(),
         SimpleNewtonRaphson(AutoFiniteDiff()), SimpleGaussNewton(AutoFiniteDiff()))
         function obj_1(p)
             prob_oop = NonlinearLeastSquaresProblem{false}(loss_function, θ_init, p)
diff --git a/test/core/rootfind_tests.jl b/test/core/rootfind_tests.jl
