Merge pull request #190 from oscardssmith/use-NLStats

use NLStats

Author: ChrisRackauckas

Project.toml

@@ -11,11 +11,11 @@ FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
+PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 SimpleNonlinearSolve = "727e6d20-b764-4bd8-a329-72de5adea6c7"
-PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SparseDiffTools = "47a9eef4-7e08-11e9-0b38-333d64bd3804"
 StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"
@@ -28,11 +28,11 @@ EnumX = "1"
 FiniteDiff = "2"
 ForwardDiff = "0.10.3"
 LinearSolve = "2"
+PrecompileTools = "1"
 RecursiveArrayTools = "2"
 Reexport = "0.2, 1"
-SciMLBase = "1.73"
+SciMLBase = "1.92.4"
 SimpleNonlinearSolve = "0.1"
-PrecompileTools = "1"
 SparseDiffTools = "1, 2"
 StaticArraysCore = "1.4"
 UnPack = "1.0"

docs/make.jl

@@ -1,28 +1,28 @@
 using Documenter, NonlinearSolve, SimpleNonlinearSolve, Sundials, SciMLNLSolve,
-      NonlinearSolveMINPACK, SteadyStateDiffEq
+    NonlinearSolveMINPACK, SteadyStateDiffEq
 
 cp("./docs/Manifest.toml", "./docs/src/assets/Manifest.toml", force = true)
 cp("./docs/Project.toml", "./docs/src/assets/Project.toml", force = true)
 
 include("pages.jl")
 
 makedocs(sitename = "NonlinearSolve.jl",
-         authors = "Chris Rackauckas",
-         modules = [NonlinearSolve, NonlinearSolve.SciMLBase, NonlinearSolve.DiffEqBase,
-             SimpleNonlinearSolve, Sundials, SciMLNLSolve, NonlinearSolveMINPACK,
-             SteadyStateDiffEq],
-         clean = true, doctest = false,
-         strict = [
-             :doctest,
-             :linkcheck,
-             :parse_error,
-             :example_block,
-             # Other available options are
-             # :autodocs_block, :cross_references, :docs_block, :eval_block, :example_block, :footnote, :meta_block, :missing_docs, :setup_block
-         ],
-         format = Documenter.HTML(assets = ["assets/favicon.ico"],
-                                  canonical = "https://docs.sciml.ai/NonlinearSolve/stable/"),
-         pages = pages)
+    authors = "Chris Rackauckas",
+    modules = [NonlinearSolve, NonlinearSolve.SciMLBase, NonlinearSolve.DiffEqBase,
+        SimpleNonlinearSolve, Sundials, SciMLNLSolve, NonlinearSolveMINPACK,
+        SteadyStateDiffEq],
+    clean = true, doctest = false,
+    strict = [
+        :doctest,
+        :linkcheck,
+        :parse_error,
+        :example_block,
+        # Other available options are
+        # :autodocs_block, :cross_references, :docs_block, :eval_block, :example_block, :footnote, :meta_block, :missing_docs, :setup_block
+    ],
+    format = Documenter.HTML(assets = ["assets/favicon.ico"],
+        canonical = "https://docs.sciml.ai/NonlinearSolve/stable/"),
+    pages = pages)
 
 deploydocs(repo = "github.com/SciML/NonlinearSolve.jl.git";
-           push_preview = true)
+    push_preview = true)

docs/pages.jl

@@ -2,20 +2,20 @@
 
 pages = ["index.md",
     "Tutorials" => Any["tutorials/nonlinear.md",
-                       "tutorials/iterator_interface.md"],
+        "tutorials/iterator_interface.md"],
     "Basics" => Any["basics/NonlinearProblem.md",
-                    "basics/NonlinearFunctions.md",
-                    "basics/solve.md",
-                    "basics/NonlinearSolution.md",
-                    "basics/TerminationCondition.md",
-                    "basics/FAQ.md"],
+        "basics/NonlinearFunctions.md",
+        "basics/solve.md",
+        "basics/NonlinearSolution.md",
+        "basics/TerminationCondition.md",
+        "basics/FAQ.md"],
     "Solver Summaries and Recommendations" => Any["solvers/NonlinearSystemSolvers.md",
-                                                  "solvers/BracketingSolvers.md",
-                                                  "solvers/SteadyStateSolvers.md"],
+        "solvers/BracketingSolvers.md",
+        "solvers/SteadyStateSolvers.md"],
     "Detailed Solver APIs" => Any["api/nonlinearsolve.md",
-                                  "api/simplenonlinearsolve.md",
-                                  "api/minpack.md",
-                                  "api/nlsolve.md",
-                                  "api/sundials.md",
-                                  "api/steadystatediffeq.md"],
+        "api/simplenonlinearsolve.md",
+        "api/minpack.md",
+        "api/nlsolve.md",
+        "api/sundials.md",
+        "api/steadystatediffeq.md"],
 ]

docs/src/basics/FAQ.md

@@ -16,14 +16,14 @@ myfun(x, lv) = x * sin(x) - lv
 function f(out, levels, u0)
     for i in 1:N
         out[i] = solve(IntervalNonlinearProblem{false}(IntervalNonlinearFunction{false}(myfun),
-                                                       u0, levels[i]), Falsi()).u
+                u0, levels[i]), Falsi()).u
     end
 end
 
 function f2(out, levels, u0)
     for i in 1:N
         out[i] = solve(NonlinearProblem{false}(NonlinearFunction{false}(myfun),
-                                               u0, levels[i]), SimpleNewtonRaphson()).u
+                u0, levels[i]), SimpleNewtonRaphson()).u
     end
 end
 

src/NonlinearSolve.jl

@@ -17,6 +17,7 @@ using DiffEqBase
 using SparseDiffTools
 
 @reexport using SciMLBase
+using SciMLBase: NLStats
 @reexport using SimpleNonlinearSolve
 
 import SciMLBase: _unwrap_val
@@ -26,8 +27,8 @@ abstract type AbstractNewtonAlgorithm{CS, AD, FDT, ST, CJ} <:
               AbstractNonlinearSolveAlgorithm end
 
 function SciMLBase.__solve(prob::NonlinearProblem,
-                           alg::AbstractNonlinearSolveAlgorithm, args...;
-                           kwargs...)
+    alg::AbstractNonlinearSolveAlgorithm, args...;
+    kwargs...)
     cache = init(prob, alg, args...; kwargs...)
     sol = solve!(cache)
 end
@@ -56,7 +57,7 @@ PrecompileTools.@compile_workload begin
         end
 
         prob = NonlinearProblem{true}((du, u, p) -> du[1] = u[1] * u[1] - p[1], T[0.1],
-                                      T[2])
+            T[2])
         for alg in precompile_algs
             solve(prob, alg, abstol = T(1e-2))
         end

src/ad.jl

@@ -24,21 +24,21 @@ function scalar_nlsolve_ad(prob, alg, args...; kwargs...)
 end
 
 function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number, StaticArraysCore.SVector},
-                                                iip,
-                                                <:Dual{T, V, P}},
-                         alg::AbstractNewtonAlgorithm,
-                         args...; kwargs...) where {iip, T, V, P}
+        iip,
+        <:Dual{T, V, P}},
+    alg::AbstractNewtonAlgorithm,
+    args...; kwargs...) where {iip, T, V, P}
     sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
     return SciMLBase.build_solution(prob, alg, Dual{T, V, P}(sol.u, partials), sol.resid;
-                                    retcode = sol.retcode)
+        retcode = sol.retcode)
 end
 function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number, StaticArraysCore.SVector},
-                                                iip,
-                                                <:AbstractArray{<:Dual{T, V, P}}},
-                         alg::AbstractNewtonAlgorithm,
-                         args...;
-                         kwargs...) where {iip, T, V, P}
+        iip,
+        <:AbstractArray{<:Dual{T, V, P}}},
+    alg::AbstractNewtonAlgorithm,
+    args...;
+    kwargs...) where {iip, T, V, P}
     sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
     return SciMLBase.build_solution(prob, alg, Dual{T, V, P}(sol.u, partials), sol.resid;
-                                    retcode = sol.retcode)
+        retcode = sol.retcode)
 end

src/jacobian.jl

@@ -17,11 +17,11 @@ end
 
 function jacobian_finitediff_forward!(J, f, x, jac_config, forwardcache, cache)
     (FiniteDiff.finite_difference_jacobian!(J, f, x, jac_config, forwardcache);
-     maximum(jac_config.colorvec))
+    maximum(jac_config.colorvec))
 end
 function jacobian_finitediff!(J, f, x, jac_config, cache)
     (FiniteDiff.finite_difference_jacobian!(J, f, x, jac_config);
-     2 * maximum(jac_config.colorvec))
+    2 * maximum(jac_config.colorvec))
 end
 
 function jacobian!(J::AbstractMatrix{<:Number}, cache)
@@ -43,7 +43,7 @@ function jacobian!(J::AbstractMatrix{<:Number}, cache)
             uf(fx, x)
             #cache.destats.nf += 1
             tmp = jacobian_finitediff_forward!(J, uf, x, jac_config, fx,
-                                               cache)
+                cache)
         else # not forward difference
             tmp = jacobian_finitediff!(J, uf, x, jac_config, cache)
         end
@@ -71,18 +71,18 @@ function build_jac_config(alg, f::F1, uf::F2, du1, u, tmp, du2) where {F1, F2}
                 typeof(ForwardDiff.Tag(uf, eltype(u)))
             end
             jac_config = ForwardColorJacCache(uf, u, _chunksize; colorvec = colorvec,
-                                              sparsity = sparsity, tag = T)
+                sparsity = sparsity, tag = T)
         else
             if alg_difftype(alg) !== Val{:complex}
                 jac_config = FiniteDiff.JacobianCache(tmp, du1, du2, alg_difftype(alg),
-                                                      colorvec = colorvec,
-                                                      sparsity = sparsity)
+                    colorvec = colorvec,
+                    sparsity = sparsity)
             else
                 jac_config = FiniteDiff.JacobianCache(Complex{eltype(tmp)}.(tmp),
-                                                      Complex{eltype(du1)}.(du1), nothing,
-                                                      alg_difftype(alg), eltype(u),
-                                                      colorvec = colorvec,
-                                                      sparsity = sparsity)
+                    Complex{eltype(du1)}.(du1), nothing,
+                    alg_difftype(alg), eltype(u),
+                    colorvec = colorvec,
+                    sparsity = sparsity)
             end
         end
     else
@@ -91,23 +91,28 @@ function build_jac_config(alg, f::F1, uf::F2, du1, u, tmp, du2) where {F1, F2}
     jac_config
 end
 
-function get_chunksize(jac_config::ForwardDiff.JacobianConfig{T, V, N, D}) where {T, V, N, D
-                                                                                  }
+function get_chunksize(jac_config::ForwardDiff.JacobianConfig{
+    T,
+    V,
+    N,
+    D,
+}) where {T, V, N, D
+}
     Val(N)
 end # don't degrade compile time information to runtime information
 
 function jacobian_finitediff(f, x, ::Type{diff_type}, dir, colorvec, sparsity,
-                             jac_prototype) where {diff_type}
+    jac_prototype) where {diff_type}
     (FiniteDiff.finite_difference_derivative(f, x, diff_type, eltype(x), dir = dir), 2)
 end
 function jacobian_finitediff(f, x::AbstractArray, ::Type{diff_type}, dir, colorvec,
-                             sparsity, jac_prototype) where {diff_type}
+    sparsity, jac_prototype) where {diff_type}
     f_in = diff_type === Val{:forward} ? f(x) : similar(x)
     ret_eltype = eltype(f_in)
     J = FiniteDiff.finite_difference_jacobian(f, x, diff_type, ret_eltype, f_in,
-                                              dir = dir, colorvec = colorvec,
-                                              sparsity = sparsity,
-                                              jac_prototype = jac_prototype)
+        dir = dir, colorvec = colorvec,
+        sparsity = sparsity,
+        jac_prototype = jac_prototype)
     return J, _nfcount(maximum(colorvec), diff_type)
 end
 function jacobian(cache, f::F) where {F}
@@ -125,7 +130,7 @@ function jacobian(cache, f::F) where {F}
         sparsity, colorvec = sparsity_colorvec(cache.f, x)
         dir = true
         J, tmp = jacobian_finitediff(uf, x, alg_difftype(alg), dir, colorvec, sparsity,
-                                     jac_prototype)
+            jac_prototype)
     end
     J
 end
@@ -141,6 +146,6 @@ function jacobian_autodiff(f, x::AbstractArray, nonlinfun, alg)
                              SparseDiffTools.getsize(ForwardDiff.pickchunksize(maxcolor)))) :
                     Int(ceil(maxcolor / _unwrap_val(chunk_size)))
     (forwarddiff_color_jacobian(f, x, colorvec = colorvec, sparsity = sparsity,
-                                jac_prototype = jac_prototype, chunksize = chunk_size),
-     num_of_chunks)
+            jac_prototype = jac_prototype, chunksize = chunk_size),
+        num_of_chunks)
 end