Run formatter

Author: avik-pal

ext/NonlinearSolveFastLevenbergMarquardtExt.jl

@@ -32,8 +32,8 @@ end
 (f::InplaceFunction{false})(fx, x, p) = (fx .= f.f(x, p))
 
 function SciMLBase.__init(prob::NonlinearLeastSquaresProblem,
-    alg::FastLevenbergMarquardtJL, args...; abstol = 1e-8, reltol = 1e-8,
-    verbose = false, maxiters = 1000, kwargs...)
+        alg::FastLevenbergMarquardtJL, args...; abstol = 1e-8, reltol = 1e-8,
+        verbose = false, maxiters = 1000, kwargs...)
     iip = SciMLBase.isinplace(prob)
 
     @assert prob.f.jac!==nothing "FastLevenbergMarquardt requires a Jacobian!"

ext/NonlinearSolveLeastSquaresOptimExt.jl

@@ -33,7 +33,7 @@ end
 (f::FunctionWrapper{false})(du, u) = (du .= f.f(u, f.p))
 
 function SciMLBase.__init(prob::NonlinearLeastSquaresProblem, alg::LeastSquaresOptimJL,
-    args...; abstol = 1e-8, reltol = 1e-8, verbose = false, maxiters = 1000, kwargs...)
+        args...; abstol = 1e-8, reltol = 1e-8, verbose = false, maxiters = 1000, kwargs...)
     iip = SciMLBase.isinplace(prob)
 
     f! = FunctionWrapper{iip}(prob.f, prob.p)

src/NonlinearSolve.jl

@@ -44,7 +44,7 @@ abstract type AbstractNonlinearSolveCache{iip} end
 isinplace(::AbstractNonlinearSolveCache{iip}) where {iip} = iip
 
 function SciMLBase.__solve(prob::Union{NonlinearProblem, NonlinearLeastSquaresProblem},
-    alg::AbstractNonlinearSolveAlgorithm, args...; kwargs...)
+        alg::AbstractNonlinearSolveAlgorithm, args...; kwargs...)
     cache = init(prob, alg, args...; kwargs...)
     return solve!(cache)
 end

src/ad.jl

@@ -26,16 +26,16 @@ function scalar_nlsolve_ad(prob, alg, args...; kwargs...)
 end
 
 function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number, SVector, <:AbstractArray},
-        false, <:Dual{T, V, P}}, alg::AbstractNewtonAlgorithm, args...;
-    kwargs...) where {T, V, P}
+            false, <:Dual{T, V, P}}, alg::AbstractNewtonAlgorithm, args...;
+        kwargs...) where {T, V, P}
     sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
     dual_soln = scalar_nlsolve_dual_soln(sol.u, partials, prob.p)
     return SciMLBase.build_solution(prob, alg, dual_soln, sol.resid; sol.retcode)
 end
 
 function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number, SVector, <:AbstractArray},
-        false, <:AbstractArray{<:Dual{T, V, P}}}, alg::AbstractNewtonAlgorithm, args...;
-    kwargs...) where {T, V, P}
+            false, <:AbstractArray{<:Dual{T, V, P}}}, alg::AbstractNewtonAlgorithm, args...;
+        kwargs...) where {T, V, P}
     sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
     dual_soln = scalar_nlsolve_dual_soln(sol.u, partials, prob.p)
     return SciMLBase.build_solution(prob, alg, dual_soln, sol.resid; sol.retcode)
@@ -53,11 +53,11 @@ function scalar_nlsolve_∂f_∂u(f, u, p)
 end
 
 function scalar_nlsolve_dual_soln(u::Number, partials,
-    ::Union{<:AbstractArray{<:Dual{T, V, P}}, Dual{T, V, P}}) where {T, V, P}
+        ::Union{<:AbstractArray{<:Dual{T, V, P}}, Dual{T, V, P}}) where {T, V, P}
     return Dual{T, V, P}(u, partials)
 end
 
 function scalar_nlsolve_dual_soln(u::AbstractArray, partials,
-    ::Union{<:AbstractArray{<:Dual{T, V, P}}, Dual{T, V, P}}) where {T, V, P}
+        ::Union{<:AbstractArray{<:Dual{T, V, P}}, Dual{T, V, P}}) where {T, V, P}
     return map(((uᵢ, pᵢ),) -> Dual{T, V, P}(uᵢ, pᵢ), zip(u, partials))
 end

src/broyden.jl

@@ -22,7 +22,7 @@ An implementation of `Broyden` with reseting and line search.
 end
 
 function GeneralBroyden(; max_resets = 3, linesearch = LineSearch(),
-    reset_tolerance = nothing)
+        reset_tolerance = nothing)
     linesearch = linesearch isa LineSearch ? linesearch : LineSearch(; method = linesearch)
     return GeneralBroyden(max_resets, reset_tolerance, linesearch)
 end
@@ -60,9 +60,9 @@ end
 get_fu(cache::GeneralBroydenCache) = cache.fu
 
 function SciMLBase.__init(prob::NonlinearProblem{uType, iip}, alg::GeneralBroyden, args...;
-    alias_u0 = false, maxiters = 1000, abstol = nothing, reltol = nothing,
-    termination_condition = nothing, internalnorm::F = DEFAULT_NORM,
-    kwargs...) where {uType, iip, F}
+        alias_u0 = false, maxiters = 1000, abstol = nothing, reltol = nothing,
+        termination_condition = nothing, internalnorm::F = DEFAULT_NORM,
+        kwargs...) where {uType, iip, F}
     @unpack f, u0, p = prob
     u = alias_u0 ? u0 : deepcopy(u0)
     fu = evaluate_f(prob, u)
@@ -172,9 +172,9 @@ function perform_step!(cache::GeneralBroydenCache{false})
 end
 
 function SciMLBase.reinit!(cache::GeneralBroydenCache{iip}, u0 = cache.u; p = cache.p,
-    abstol = cache.abstol, reltol = cache.reltol,
-    termination_condition = cache.termination_condition,
-    maxiters = cache.maxiters) where {iip}
+        abstol = cache.abstol, reltol = cache.reltol,
+        termination_condition = cache.termination_condition,
+        maxiters = cache.maxiters) where {iip}
     cache.p = p
     if iip
         recursivecopy!(cache.u, u0)

src/default.jl

@@ -42,7 +42,7 @@ end
 const Robusters = RobustMultiNewton
 
 function RobustMultiNewton(; concrete_jac = nothing, linsolve = nothing,
-    precs = DEFAULT_PRECS, adkwargs...)
+        precs = DEFAULT_PRECS, adkwargs...)
     return RobustMultiNewton{_unwrap_val(concrete_jac)}(adkwargs, linsolve, precs)
 end
 
@@ -53,7 +53,7 @@ end
 end
 
 function SciMLBase.__init(prob::NonlinearProblem{uType, iip}, alg::RobustMultiNewton,
-    args...; kwargs...) where {uType, iip}
+        args...; kwargs...) where {uType, iip}
     @unpack adkwargs, linsolve, precs = alg
 
     algs = (TrustRegion(; linsolve, precs, adkwargs...),
@@ -105,7 +105,7 @@ for more performance and then tries more robust techniques if the faster ones fa
 end
 
 function FastShortcutNonlinearPolyalg(; concrete_jac = nothing, linsolve = nothing,
-    precs = DEFAULT_PRECS, adkwargs...)
+        precs = DEFAULT_PRECS, adkwargs...)
     return FastShortcutNonlinearPolyalg{_unwrap_val(concrete_jac)}(adkwargs, linsolve,
         precs)
 end
@@ -118,13 +118,13 @@ end
 end
 
 function FastShortcutNonlinearPolyalgCache(; concrete_jac = nothing, linsolve = nothing,
-    precs = DEFAULT_PRECS, adkwargs...)
+        precs = DEFAULT_PRECS, adkwargs...)
     return FastShortcutNonlinearPolyalgCache{_unwrap_val(concrete_jac)}(adkwargs, linsolve,
         precs)
 end
 
 function SciMLBase.__init(prob::NonlinearProblem{uType, iip},
-    alg::FastShortcutNonlinearPolyalg, args...; kwargs...) where {uType, iip}
+        alg::FastShortcutNonlinearPolyalg, args...; kwargs...) where {uType, iip}
     @unpack adkwargs, linsolve, precs = alg
 
     algs = (GeneralKlement(; linsolve, precs),
@@ -141,8 +141,8 @@ end
 
 # This version doesn't allocate all the caches!
 @generated function SciMLBase.__solve(prob::NonlinearProblem{uType, iip},
-    alg::Union{FastShortcutNonlinearPolyalg, RobustMultiNewton}, args...;
-    kwargs...) where {uType, iip}
+        alg::Union{FastShortcutNonlinearPolyalg, RobustMultiNewton}, args...;
+        kwargs...) where {uType, iip}
     calls = [:(@unpack adkwargs, linsolve, precs = alg)]
 
     algs = if parameterless_type(alg) == RobustMultiNewton
@@ -210,7 +210,7 @@ end
 ## General shared polyalg functions
 
 @generated function SciMLBase.solve!(cache::Union{RobustMultiNewtonCache{iip, N},
-    FastShortcutNonlinearPolyalgCache{iip, N}}) where {iip, N}
+        FastShortcutNonlinearPolyalgCache{iip, N}}) where {iip, N}
     calls = [
         quote
             1 ≤ cache.current ≤ length(cache.caches) ||
@@ -260,7 +260,7 @@ end
 end
 
 function SciMLBase.reinit!(cache::Union{RobustMultiNewtonCache,
-        FastShortcutNonlinearPolyalgCache}, args...; kwargs...)
+            FastShortcutNonlinearPolyalgCache}, args...; kwargs...)
     for c in cache.caches
         SciMLBase.reinit!(c, args...; kwargs...)
     end
@@ -269,11 +269,11 @@ end
 ## Defaults
 
 function SciMLBase.__init(prob::NonlinearProblem{uType, iip}, alg::Nothing, args...;
-    kwargs...) where {uType, iip}
+        kwargs...) where {uType, iip}
     SciMLBase.__init(prob, FastShortcutNonlinearPolyalg(), args...; kwargs...)
 end
 
 function SciMLBase.__solve(prob::NonlinearProblem{uType, iip}, alg::Nothing, args...;
-    kwargs...) where {uType, iip}
+        kwargs...) where {uType, iip}
     SciMLBase.__solve(prob, FastShortcutNonlinearPolyalg(), args...; kwargs...)
 end

src/dfsane.jl

@@ -57,8 +57,8 @@ struct DFSane{T, F} <: AbstractNonlinearSolveAlgorithm
 end
 
 function DFSane(; σ_min = 1e-10, σ_max = 1e+10, σ_1 = 1.0, M = 10, γ = 1e-4, τ_min = 0.1,
-    τ_max = 0.5, n_exp = 2, η_strategy = (fn_1, n, x_n, f_n) -> fn_1 / n^2,
-    max_inner_iterations = 1000)
+        τ_max = 0.5, n_exp = 2, η_strategy = (fn_1, n, x_n, f_n) -> fn_1 / n^2,
+        max_inner_iterations = 1000)
     return DFSane{typeof(σ_min), typeof(η_strategy)}(σ_min, σ_max, σ_1, M, γ, τ_min, τ_max,
         n_exp, η_strategy, max_inner_iterations)
 end
@@ -96,9 +96,9 @@ end
 end
 
 function SciMLBase.__init(prob::NonlinearProblem{uType, iip}, alg::DFSane, args...;
-    alias_u0 = false, maxiters = 1000, abstol = nothing, reltol = nothing,
-    termination_condition = nothing, internalnorm::F = DEFAULT_NORM,
-    kwargs...) where {uType, iip, F}
+        alias_u0 = false, maxiters = 1000, abstol = nothing, reltol = nothing,
+        termination_condition = nothing, internalnorm::F = DEFAULT_NORM,
+        kwargs...) where {uType, iip, F}
     uₙ = alias_u0 ? prob.u0 : deepcopy(prob.u0)
 
     p = prob.p
@@ -307,9 +307,9 @@ function SciMLBase.solve!(cache::DFSaneCache)
 end
 
 function SciMLBase.reinit!(cache::DFSaneCache{iip}, u0 = cache.uₙ; p = cache.p,
-    abstol = cache.abstol, reltol = cache.reltol,
-    termination_condition = cache.termination_condition,
-    maxiters = cache.maxiters) where {iip}
+        abstol = cache.abstol, reltol = cache.reltol,
+        termination_condition = cache.termination_condition,
+        maxiters = cache.maxiters) where {iip}
     cache.p = p
     if iip
         recursivecopy!(cache.uₙ, u0)

src/extension_algs.jl

@@ -65,8 +65,8 @@ Wrapper over [FastLevenbergMarquardt.jl](https://github.com/kamesy/FastLevenberg
 end
 
 function FastLevenbergMarquardtJL(linsolve::Symbol = :cholesky; factor = 1e-6,
-    factoraccept = 13.0, factorreject = 3.0, factorupdate = :marquardt,
-    minscale = 1e-12, maxscale = 1e16, minfactor = 1e-28, maxfactor = 1e32)
+        factoraccept = 13.0, factorreject = 3.0, factorupdate = :marquardt,
+        minscale = 1e-12, maxscale = 1e16, minfactor = 1e-28, maxfactor = 1e32)
     @assert linsolve in (:qr, :cholesky)
     @assert factorupdate in (:marquardt, :nielson)
 

src/gaussnewton.jl

@@ -47,7 +47,7 @@ function set_ad(alg::GaussNewton{CJ}, ad) where {CJ}
 end
 
 function GaussNewton(; concrete_jac = nothing, linsolve = nothing,
-    precs = DEFAULT_PRECS, adkwargs...)
+        precs = DEFAULT_PRECS, adkwargs...)
     ad = default_adargs_to_adtype(; adkwargs...)
     return GaussNewton{_unwrap_val(concrete_jac)}(ad, linsolve, precs)
 end
@@ -81,9 +81,9 @@ end
 end
 
 function SciMLBase.__init(prob::NonlinearLeastSquaresProblem{uType, iip}, alg_::GaussNewton,
-    args...; alias_u0 = false, maxiters = 1000, abstol = nothing, reltol = nothing,
-    termination_condition = nothing, internalnorm::F = DEFAULT_NORM,
-    kwargs...) where {uType, iip, F}
+        args...; alias_u0 = false, maxiters = 1000, abstol = nothing, reltol = nothing,
+        termination_condition = nothing, internalnorm::F = DEFAULT_NORM,
+        kwargs...) where {uType, iip, F}
     alg = get_concrete_algorithm(alg_, prob)
     @unpack f, u0, p = prob
 
@@ -192,9 +192,9 @@ function perform_step!(cache::GaussNewtonCache{false})
 end
 
 function SciMLBase.reinit!(cache::GaussNewtonCache{iip}, u0 = cache.u; p = cache.p,
-    abstol = cache.abstol, reltol = cache.reltol,
-    termination_condition = cache.termination_condition,
-    maxiters = cache.maxiters) where {iip}
+        abstol = cache.abstol, reltol = cache.reltol,
+        termination_condition = cache.termination_condition,
+        maxiters = cache.maxiters) where {iip}
     cache.p = p
     if iip
         recursivecopy!(cache.u, u0)

src/jacobian.jl

@@ -50,8 +50,8 @@ jacobian!!(::Number, cache) = last(value_derivative(cache.uf, cache.u))
 
 # Build Jacobian Caches
 function jacobian_caches(alg::AbstractNonlinearSolveAlgorithm, f::F, u, p, ::Val{iip};
-    linsolve_kwargs = (;), lininit::Val{linsolve_init} = Val(true),
-    linsolve_with_JᵀJ::Val{needsJᵀJ} = Val(false)) where {iip, needsJᵀJ, linsolve_init, F}
+        linsolve_kwargs = (;), lininit::Val{linsolve_init} = Val(true),
+        linsolve_with_JᵀJ::Val{needsJᵀJ} = Val(false)) where {iip, needsJᵀJ, linsolve_init, F}
     uf = JacobianWrapper{iip}(f, p)
 
     haslinsolve = hasfield(typeof(alg), :linsolve)
@@ -136,8 +136,8 @@ __maybe_symmetric(x::SparseArrays.AbstractSparseMatrix) = x
 
 ## Special Handling for Scalars
 function jacobian_caches(alg::AbstractNonlinearSolveAlgorithm, f::F, u::Number, p,
-    ::Val{false}; linsolve_with_JᵀJ::Val{needsJᵀJ} = Val(false),
-    kwargs...) where {needsJᵀJ, F}
+        ::Val{false}; linsolve_with_JᵀJ::Val{needsJᵀJ} = Val(false),
+        kwargs...) where {needsJᵀJ, F}
     # NOTE: Scalar `u` assumes scalar output from `f`
     uf = JacobianWrapper{false}(f, p)
     needsJᵀJ && return uf, nothing, u, nothing, nothing, u, u, u