chore: run formatter

Author: avik-pal

src/abstract_types.jl

@@ -277,7 +277,8 @@ Abstract Type for Damping Functions in DampedNewton.
 ### `__internal_init` specification
 
 ```julia
-__internal_init(prob::AbstractNonlinearProblem, f::AbstractDampingFunction, initial_damping,
+__internal_init(
+    prob::AbstractNonlinearProblem, f::AbstractDampingFunction, initial_damping,
     J, fu, u, args...; internal_norm = DEFAULT_NORM, kwargs...) -->
 AbstractDampingFunctionCache
 ```
@@ -361,7 +362,8 @@ Abstract Type for all Jacobian Initialization Algorithms used in NonlinearSolve.
 ### `__internal_init` specification
 
 ```julia
-__internal_init(prob::AbstractNonlinearProblem, alg::AbstractJacobianInitialization, solver,
+__internal_init(
+    prob::AbstractNonlinearProblem, alg::AbstractJacobianInitialization, solver,
     f::F, fu, u, p; linsolve = missing, internalnorm::IN = DEFAULT_NORM, kwargs...)
 ```
 
@@ -453,7 +455,8 @@ Abstract Type for all Trust Region Methods used in NonlinearSolve.jl.
 ### `__internal_init` specification
 
 ```julia
-__internal_init(prob::AbstractNonlinearProblem, alg::AbstractTrustRegionMethod, f::F, fu, u,
+__internal_init(
+    prob::AbstractNonlinearProblem, alg::AbstractTrustRegionMethod, f::F, fu, u,
     p, args...; internalnorm::IF = DEFAULT_NORM, kwargs...) where {F, IF} -->
 AbstractTrustRegionMethodCache
 ```

src/algorithms/broyden.jl

@@ -28,7 +28,8 @@ search.
         useful for specific problems, but whether it will work may depend strongly on the
         problem
 """
-function Broyden(; max_resets = 100, linesearch = NoLineSearch(), reset_tolerance = nothing,
+function Broyden(;
+        max_resets = 100, linesearch = NoLineSearch(), reset_tolerance = nothing,
         init_jacobian::Val{IJ} = Val(:identity), autodiff = nothing,
         alpha = nothing, update_rule::Val{UR} = Val(:good_broyden)) where {IJ, UR}
     if IJ === :identity

src/algorithms/extension_algs.jl

@@ -252,20 +252,22 @@ function NLsolveJL(; method = :trust_region, autodiff = :central, store_trace =
     end
 
     if store_trace !== missing
-        Base.depwarn("`store_trace` for NLsolveJL has been deprecated and will be removed \
-                      in v4. Use the `store_trace` keyword argument via the logging API \
-                      https://docs.sciml.ai/NonlinearSolve/stable/basics/Logging/ \
-                      instead.",
+        Base.depwarn(
+            "`store_trace` for NLsolveJL has been deprecated and will be removed \
+             in v4. Use the `store_trace` keyword argument via the logging API \
+             https://docs.sciml.ai/NonlinearSolve/stable/basics/Logging/ \
+             instead.",
             :NLsolveJL)
     else
         store_trace = false
     end
 
     if extended_trace !== missing
-        Base.depwarn("`extended_trace` for NLsolveJL has been deprecated and will be \
-                      removed in v4. Use the `trace_level = TraceAll()` keyword argument \
-                      via the logging API \
-                      https://docs.sciml.ai/NonlinearSolve/stable/basics/Logging/ instead.",
+        Base.depwarn(
+            "`extended_trace` for NLsolveJL has been deprecated and will be \
+             removed in v4. Use the `trace_level = TraceAll()` keyword argument \
+             via the logging API \
+             https://docs.sciml.ai/NonlinearSolve/stable/basics/Logging/ instead.",
             :NLsolveJL)
     else
         extended_trace = false

src/algorithms/levenberg_marquardt.jl

@@ -53,7 +53,8 @@ function LevenbergMarquardt(;
         descent = GeodesicAcceleration(descent, finite_diff_step_geodesic, α_geodesic)
     end
     trustregion = LevenbergMarquardtTrustRegion(b_uphill)
-    return GeneralizedFirstOrderAlgorithm(; concrete_jac = true, name = :LevenbergMarquardt,
+    return GeneralizedFirstOrderAlgorithm(;
+        concrete_jac = true, name = :LevenbergMarquardt,
         trustregion, descent, jacobian_ad = autodiff)
 end
 

src/core/generalized_first_order.jl

@@ -57,11 +57,13 @@ function GeneralizedFirstOrderAlgorithm{concrete_jac, name}(;
         max_shrink_times::Int = typemax(Int)) where {concrete_jac, name}
     forward_ad = ifelse(forward_ad !== nothing,
         forward_ad,
-        ifelse(jacobian_ad !== nothing && ADTypes.mode(jacobian_ad) isa ADTypes.ForwardMode,
+        ifelse(
+            jacobian_ad !== nothing && ADTypes.mode(jacobian_ad) isa ADTypes.ForwardMode,
             jacobian_ad, nothing))
     reverse_ad = ifelse(reverse_ad !== nothing,
         reverse_ad,
-        ifelse(jacobian_ad !== nothing && ADTypes.mode(jacobian_ad) isa ADTypes.ReverseMode,
+        ifelse(
+            jacobian_ad !== nothing && ADTypes.mode(jacobian_ad) isa ADTypes.ReverseMode,
             jacobian_ad, nothing))
 
     if linesearch !== missing && !(linesearch isa AbstractNonlinearSolveLineSearchAlgorithm)

src/default.jl

@@ -432,7 +432,8 @@ function FastShortcutNonlinearPolyalg(
             end
         else
             if __is_complex(T)
-                algs = (Broyden(), Broyden(; init_jacobian = Val(:true_jacobian), autodiff),
+                algs = (
+                    Broyden(), Broyden(; init_jacobian = Val(:true_jacobian), autodiff),
                     Klement(; linsolve, precs, autodiff),
                     NewtonRaphson(; concrete_jac, linsolve, precs, autodiff))
             else

src/descent/geodesic_acceleration.jl

@@ -31,7 +31,8 @@ for other methods are not theorectically or experimentally verified.
 end
 
 function Base.show(io::IO, alg::GeodesicAcceleration)
-    print(io, "GeodesicAcceleration(descent = $(alg.descent), finite_diff_step_geodesic = ",
+    print(
+        io, "GeodesicAcceleration(descent = $(alg.descent), finite_diff_step_geodesic = ",
         "$(alg.finite_diff_step_geodesic), α = $(alg.α))")
 end
 
@@ -102,7 +103,8 @@ function __internal_init(prob::AbstractNonlinearProblem, alg::GeodesicAccelerati
         T(alg.finite_diff_step_geodesic), Jv, fu_cache, u_cache, false)
 end
 
-function __internal_solve!(cache::GeodesicAccelerationCache, J, fu, u, idx::Val{N} = Val(1);
+function __internal_solve!(
+        cache::GeodesicAccelerationCache, J, fu, u, idx::Val{N} = Val(1);
         skip_solve::Bool = false, kwargs...) where {N}
     a, v, δu = get_acceleration(cache, idx), get_velocity(cache, idx), get_du(cache, idx)
     skip_solve && return DescentResult(; δu, extras = (; a, v))

src/internal/termination.jl

@@ -8,7 +8,8 @@ function init_termination_cache(
         AbsSafeBestTerminationMode(Base.Fix2(norm, 2); max_stalled_steps = 32))
 end
 
-function init_termination_cache(prob::Union{NonlinearProblem, NonlinearLeastSquaresProblem},
+function init_termination_cache(
+        prob::Union{NonlinearProblem, NonlinearLeastSquaresProblem},
         abstol, reltol, du, u, tc::AbstractNonlinearTerminationMode)
     tc_ = if hasfield(typeof(tc), :internalnorm) && tc.internalnorm === nothing
         internalnorm = ifelse(