format

Author: ChrisRackauckas

src/SimpleNonlinearSolve.jl

@@ -20,10 +20,10 @@ using LinearAlgebra: LinearAlgebra, I, convert, copyto!, diagind, dot, issuccess
 using MaybeInplace: @bb, setindex_trait, CanSetindex, CannotSetindex
 using Reexport: @reexport
 using SciMLBase: @add_kwonly, SciMLBase, AbstractNonlinearProblem, IntervalNonlinearProblem,
-                 AbstractNonlinearFunction, StandardNonlinearProblem,
-                 NonlinearFunction, NonlinearLeastSquaresProblem, NonlinearProblem,
-                 ReturnCode, init, remake, solve, AbstractNonlinearAlgorithm,
-                 build_solution, isinplace, _unwrap_val, warn_paramtype
+                 AbstractNonlinearFunction, StandardNonlinearProblem, NonlinearFunction,
+                 NonlinearLeastSquaresProblem, NonlinearProblem, ReturnCode, init, remake,
+                 solve, AbstractNonlinearAlgorithm, build_solution, isinplace, _unwrap_val,
+                 warn_paramtype
 using Setfield: @set!
 using StaticArraysCore: StaticArray, SVector, SMatrix, SArray, MArray, Size
 
@@ -81,8 +81,9 @@ function SciMLBase.solve(prob::NonlinearProblem, alg::AbstractSimpleNonlinearSol
         p === nothing, alg, args...; prob.kwargs..., kwargs...)
 end
 
-function SciMLBase.solve(prob::ImmutableNonlinearProblem, alg::AbstractSimpleNonlinearSolveAlgorithm,
-    args...; sensealg = nothing, u0 = nothing, p = nothing, kwargs...)
+function SciMLBase.solve(
+        prob::ImmutableNonlinearProblem, alg::AbstractSimpleNonlinearSolveAlgorithm,
+        args...; sensealg = nothing, u0 = nothing, p = nothing, kwargs...)
     if sensealg === nothing && haskey(prob.kwargs, :sensealg)
         sensealg = prob.kwargs[:sensealg]
     end
@@ -92,8 +93,8 @@ function SciMLBase.solve(prob::ImmutableNonlinearProblem, alg::AbstractSimpleNon
         p === nothing, alg, args...; prob.kwargs..., kwargs...)
 end
 
-function __internal_solve_up(_prob::ImmutableNonlinearProblem, sensealg, u0, u0_changed,
-        p, p_changed, alg, args...; kwargs...)
+function __internal_solve_up(_prob::ImmutableNonlinearProblem, sensealg, u0,
+        u0_changed, p, p_changed, alg, args...; kwargs...)
     prob = u0_changed || p_changed ? remake(_prob; u0, p) : _prob
     return SciMLBase.__solve(prob, alg, args...; kwargs...)
 end

src/ad.jl

@@ -42,7 +42,8 @@ for algType in (Bisection, Brent, Alefeld, Falsi, ITP, Ridder)
 end
 
 function __nlsolve_ad(
-        prob::Union{IntervalNonlinearProblem, NonlinearProblem, ImmutableNonlinearProblem}, alg, args...; kwargs...)
+        prob::Union{IntervalNonlinearProblem, NonlinearProblem, ImmutableNonlinearProblem},
+        alg, args...; kwargs...)
     p = value(prob.p)
     if prob isa IntervalNonlinearProblem
         tspan = value.(prob.tspan)

src/immutable_nonlinear_problem.jl

@@ -1,65 +1,60 @@
 struct ImmutableNonlinearProblem{uType, isinplace, P, F, K, PT} <:
-    AbstractNonlinearProblem{uType, isinplace}
- f::F
- u0::uType
- p::P
- problem_type::PT
- kwargs::K
- @add_kwonly function ImmutableNonlinearProblem{iip}(f::AbstractNonlinearFunction{iip}, u0,
-         p = NullParameters(),
-         problem_type = StandardNonlinearProblem();
-         kwargs...) where {iip}
-     if haskey(kwargs, :p)
-         error("`p` specified as a keyword argument `p = $(kwargs[:p])` to `NonlinearProblem`. This is not supported.")
-     end
-     warn_paramtype(p)
-     new{typeof(u0), iip, typeof(p), typeof(f),
-         typeof(kwargs), typeof(problem_type)}(f,
-         u0,
-         p,
-         problem_type,
-         kwargs)
- end
+       AbstractNonlinearProblem{uType, isinplace}
+    f::F
+    u0::uType
+    p::P
+    problem_type::PT
+    kwargs::K
+    @add_kwonly function ImmutableNonlinearProblem{iip}(
+            f::AbstractNonlinearFunction{iip}, u0, p = NullParameters(),
+            problem_type = StandardNonlinearProblem(); kwargs...) where {iip}
+        if haskey(kwargs, :p)
+            error("`p` specified as a keyword argument `p = $(kwargs[:p])` to `NonlinearProblem`. This is not supported.")
+        end
+        warn_paramtype(p)
+        new{typeof(u0), iip, typeof(p), typeof(f), typeof(kwargs), typeof(problem_type)}(
+            f, u0, p, problem_type, kwargs)
+    end
 
- """
- Define a steady state problem using the given function.
- `isinplace` optionally sets whether the function is inplace or not.
- This is determined automatically, but not inferred.
- """
- function ImmutableNonlinearProblem{iip}(f, u0, p = NullParameters(); kwargs...) where {iip}
-     ImmutableNonlinearProblem{iip}(NonlinearFunction{iip}(f), u0, p; kwargs...)
- end
+    """
+    Define a steady state problem using the given function.
+    `isinplace` optionally sets whether the function is inplace or not.
+    This is determined automatically, but not inferred.
+    """
+    function ImmutableNonlinearProblem{iip}(
+            f, u0, p = NullParameters(); kwargs...) where {iip}
+        ImmutableNonlinearProblem{iip}(NonlinearFunction{iip}(f), u0, p; kwargs...)
+    end
 end
 
 """
 Define a nonlinear problem using an instance of
 [`AbstractNonlinearFunction`](@ref AbstractNonlinearFunction).
 """
-function ImmutableNonlinearProblem(f::AbstractNonlinearFunction, u0, p = NullParameters(); kwargs...)
- ImmutableNonlinearProblem{isinplace(f)}(f, u0, p; kwargs...)
+function ImmutableNonlinearProblem(
+        f::AbstractNonlinearFunction, u0, p = NullParameters(); kwargs...)
+    ImmutableNonlinearProblem{isinplace(f)}(f, u0, p; kwargs...)
 end
 
 function ImmutableNonlinearProblem(f, u0, p = NullParameters(); kwargs...)
- ImmutableNonlinearProblem(NonlinearFunction(f), u0, p; kwargs...)
+    ImmutableNonlinearProblem(NonlinearFunction(f), u0, p; kwargs...)
 end
 
 """
 Define a ImmutableNonlinearProblem problem from SteadyStateProblem
 """
 function ImmutableNonlinearProblem(prob::AbstractNonlinearProblem)
- ImmutableNonlinearProblem{isinplace(prob)}(prob.f, prob.u0, prob.p)
+    ImmutableNonlinearProblem{isinplace(prob)}(prob.f, prob.u0, prob.p)
 end
 
-
-function Base.convert(::Type{ImmutableNonlinearProblem}, prob::T) where {T <: NonlinearProblem}
- ImmutableNonlinearProblem{isinplace(prob)}(prob.f,
-     prob.u0,
-     prob.p,
-     prob.problem_type;
-     prob.kwargs...)
+function Base.convert(
+        ::Type{ImmutableNonlinearProblem}, prob::T) where {T <: NonlinearProblem}
+    ImmutableNonlinearProblem{isinplace(prob)}(
+        prob.f, prob.u0, prob.p, prob.problem_type; prob.kwargs...)
 end
 
-function DiffEqBase.get_concrete_problem(prob::ImmutableNonlinearProblem, isadapt; kwargs...)
+function DiffEqBase.get_concrete_problem(
+        prob::ImmutableNonlinearProblem, isadapt; kwargs...)
     u0 = DiffEqBase.get_concrete_u0(prob, isadapt, nothing, kwargs)
     u0 = DiffEqBase.promote_u0(u0, prob.p, nothing)
     p = DiffEqBase.get_concrete_p(prob, kwargs)

src/nlsolve/lbroyden.jl

@@ -44,7 +44,8 @@ function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleLimitedMe
     return __generic_solve(prob, alg, args...; termination_condition, kwargs...)
 end
 
-@views function __generic_solve(prob::ImmutableNonlinearProblem, alg::SimpleLimitedMemoryBroyden,
+@views function __generic_solve(
+        prob::ImmutableNonlinearProblem, alg::SimpleLimitedMemoryBroyden,
         args...; abstol = nothing, reltol = nothing, maxiters = 1000,
         alias_u0 = false, termination_condition = nothing, kwargs...)
     x = __maybe_unaliased(prob.u0, alias_u0)
@@ -114,7 +115,8 @@ end
 # Non-allocating StaticArrays version of SimpleLimitedMemoryBroyden is actually quite
 # finicky, so we'll implement it separately from the generic version
 # Ignore termination_condition. Don't pass things into internal functions
-function __static_solve(prob::ImmutableNonlinearProblem{<:SArray}, alg::SimpleLimitedMemoryBroyden,
+function __static_solve(
+        prob::ImmutableNonlinearProblem{<:SArray}, alg::SimpleLimitedMemoryBroyden,
         args...; abstol = nothing, maxiters = 1000, kwargs...)
     x = prob.u0
     fx = _get_fx(prob, x)

src/nlsolve/raphson.jl

@@ -23,7 +23,8 @@ end
 
 const SimpleGaussNewton = SimpleNewtonRaphson
 
-function SciMLBase.__solve(prob::Union{ImmutableNonlinearProblem, NonlinearLeastSquaresProblem},
+function SciMLBase.__solve(
+        prob::Union{ImmutableNonlinearProblem, NonlinearLeastSquaresProblem},
         alg::SimpleNewtonRaphson, args...; abstol = nothing, reltol = nothing,
         maxiters = 1000, termination_condition = nothing, alias_u0 = false, kwargs...)
     x = __maybe_unaliased(prob.u0, alias_u0)

src/nlsolve/trustRegion.jl

@@ -55,8 +55,8 @@ scalar and static array problems.
     nlsolve_update_rule = Val(false)
 end
 
-function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleTrustRegion, args...;
-        abstol = nothing, reltol = nothing, maxiters = 1000,
+function SciMLBase.__solve(prob::ImmutableNonlinearProblem, alg::SimpleTrustRegion,
+        args...; abstol = nothing, reltol = nothing, maxiters = 1000,
         alias_u0 = false, termination_condition = nothing, kwargs...)
     x = __maybe_unaliased(prob.u0, alias_u0)
     T = eltype(real(x))

src/utils.jl

@@ -145,7 +145,8 @@ end
 # different. NonlinearSolve is more for robust / cached solvers while SimpleNonlinearSolve
 # is meant for low overhead solvers, users can opt into the other termination modes but the
 # default is to use the least overhead version.
-function init_termination_cache(prob::ImmutableNonlinearProblem, abstol, reltol, du, u, ::Nothing)
+function init_termination_cache(
+        prob::ImmutableNonlinearProblem, abstol, reltol, du, u, ::Nothing)
     return init_termination_cache(
         prob, abstol, reltol, du, u, AbsNormTerminationMode(Base.Fix1(maximum, abs)))
 end
@@ -155,7 +156,8 @@ function init_termination_cache(
         prob, abstol, reltol, du, u, AbsNormTerminationMode(Base.Fix2(norm, 2)))
 end
 
-function init_termination_cache(prob::Union{ImmutableNonlinearProblem, NonlinearLeastSquaresProblem},
+function init_termination_cache(
+        prob::Union{ImmutableNonlinearProblem, NonlinearLeastSquaresProblem},
         abstol, reltol, du, u, tc::AbstractNonlinearTerminationMode)
     T = promote_type(eltype(du), eltype(u))
     abstol = __get_tolerance(u, abstol, T)