Fix the tests

Author: avik-pal

src/ad.jl

@@ -1,9 +1,8 @@
 function scalar_nlsolve_ad(prob, alg, args...; kwargs...)
     f = prob.f
     p = value(prob.p)
-    u0 = value(prob.u0)
     if prob isa IntervalNonlinearProblem
-        tspan = value(prob.tspan)
+        tspan = value.(prob.tspan)
         newprob = IntervalNonlinearProblem(f, tspan, p; prob.kwargs...)
     else
         u0 = value(prob.u0)

src/bracketing/bisection.jl

@@ -86,16 +86,18 @@ function __bisection(left, right, fl, fr, f::F; abstol, maxiters, prob, alg) whe
         end
 
         fm = f(mid)
-        if abs((right - left) / 2) < abstol || abs(fm) < abstol
+        if abs((right - left) / 2) < abstol
             sol = build_solution(prob, alg, mid, fm; left, right,
                 retcode = ReturnCode.Success)
             break
         end
 
-        if sign(fl * fm) < 0
-            right, fr = mid, fm
+        if iszero(fm)
+            right = mid
+            fr = fm
         else
-            left, fl = mid, fm
+            left = mid
+            fl = fm
         end
 
         i += 1

src/nlsolve/broyden.jl

@@ -43,7 +43,9 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleBroyden, args...;
 
         @bb @. δJ⁻¹n = (δx - J⁻¹δf) / d
 
-        @bb δJ⁻¹ = δJ⁻¹n × transpose(xᵀJ⁻¹)
+        δJ⁻¹n_ = _vec(δJ⁻¹n)
+        xᵀJ⁻¹_ = _vec(xᵀJ⁻¹)
+        @bb δJ⁻¹ = δJ⁻¹n_ × transpose(xᵀJ⁻¹_)
         @bb J⁻¹ .+= δJ⁻¹
 
         @bb copyto!(xo, x)

src/nlsolve/dfsane.jl

@@ -72,6 +72,7 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleDFSane, args...;
     fx_norm = norm(fx)^nexp
     α_1 = one(T)
     f_1 = fx_norm
+
     history_f_k = fill(fx_norm, M)
 
     # Generate the cache
@@ -118,6 +119,8 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleDFSane, args...;
 
             fx = __eval_f(prob, fx, x)
             fx_norm_new = norm(fx)^nexp
+
+            k += 1
         end
 
         tc_sol = check_termination(tc_cache, fx, x, xo, prob, alg)

src/nlsolve/halley.jl

@@ -58,7 +58,9 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleHalley, args...;
         @bb A .*= -1
         bᵢ = dfx \ Aaᵢ
 
-        @bb @. cᵢ = (aᵢ * aᵢ) / (-aᵢ + (T(0.5) * bᵢ))
+        cᵢ_ = _vec(cᵢ)
+        @bb @. cᵢ_ = (aᵢ * aᵢ) / (-aᵢ + (T(0.5) * bᵢ))
+        cᵢ = _restructure(cᵢ, cᵢ_)
 
         if i == 1
             if iszero(fx)

src/nlsolve/klement.jl

@@ -55,9 +55,9 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleKlement, args...;
 
         @bb copyto!(δx, fprev)
         if setindex_trait(δx) === CanSetindex()
-            ldiv!(F_, δx)
+            ldiv!(F_, _vec(δx))
         else
-            δx = F_ \ δx
+            δx = _restructure(δx, F_ \ _vec(δx))
         end
         @bb @. x = xo - δx
         fx = __eval_f(prob, fx, x)

src/nlsolve/trustRegion.jl

@@ -76,7 +76,7 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleTrustRegion, args.
 
     fₖ = 0.5 * norm(fx)^2
     H = ∇f' * ∇f
-    g = ∇f' * fx
+    g = _restructure(x, ∇f' * _vec(fx))
     shrink_counter = 0
 
     @bb δsd = copy(x)
@@ -96,7 +96,8 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleTrustRegion, args.
         fₖ₊₁ = norm(fx)^2 / T(2)
 
         # Compute the ratio of the actual to predicted reduction.
-        @bb Hδ = H × δ
+        # @show size(H), size(δ)
+        @bb Hδ = H × vec(δ)
         r = (fₖ₊₁ - fₖ) / (dot(δ', g) + dot(δ', Hδ) / T(2))
 
         # Update the trust region radius.
@@ -124,7 +125,7 @@ function SciMLBase.__solve(prob::NonlinearProblem, alg::SimpleTrustRegion, args.
             fₖ = fₖ₊₁
 
             @bb H = transpose(∇f) × ∇f
-            @bb g = transpose(∇f) × fx
+            @bb g = transpose(∇f) × vec(fx)
         end
     end
 
@@ -135,7 +136,7 @@ function dogleg_method!!(cache, J, f, g, Δ)
     (; δsd, δN_δsd, δN) = cache
 
     # Compute the Newton step.
-    @bb δN .= J \ f
+    @bb δN .= _restructure(δN, J \ _vec(f))
     @bb δN .*= -1
     # Test if the full step is within the trust region.
     (norm(δN) ≤ Δ) && return δN

test/23_test_problems.jl

@@ -0,0 +1,87 @@
+using SimpleNonlinearSolve, LinearAlgebra, NonlinearProblemLibrary, Test
+
+problems = NonlinearProblemLibrary.problems
+dicts = NonlinearProblemLibrary.dicts
+
+function test_on_library(problems, dicts, alg_ops, broken_tests, ϵ = 1e-4;
+        skip_tests = nothing)
+    for (idx, (problem, dict)) in enumerate(zip(problems, dicts))
+        x = dict["start"]
+        res = similar(x)
+        nlprob = NonlinearProblem(problem, copy(x))
+        @testset "$idx: $(dict["title"])" begin
+            for alg in alg_ops
+                try
+                    sol = solve(nlprob, alg;
+                        termination_condition = AbsNormTerminationMode())
+                    problem(res, sol.u, nothing)
+
+                    skip = skip_tests !== nothing && idx in skip_tests[alg]
+                    if skip
+                        @test_skip norm(res) ≤ ϵ
+                        continue
+                    end
+                    broken = idx in broken_tests[alg] ? true : false
+                    @test norm(res)≤ϵ broken=broken
+                catch
+                    broken = idx in broken_tests[alg] ? true : false
+                    if broken
+                        @test false broken=true
+                    else
+                        @test 1 == 2
+                    end
+                end
+            end
+        end
+    end
+end
+
+@testset "SimpleNewtonRaphson 23 Test Problems" begin
+    alg_ops = (SimpleNewtonRaphson(),)
+
+    # dictionary with indices of test problems where method does not converge to small residual
+    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]] = [6]
+
+    test_on_library(problems, dicts, alg_ops, broken_tests)
+end
+
+@testset "SimpleTrustRegion 23 Test Problems" begin
+    alg_ops = (SimpleTrustRegion(),)
+
+    # dictionary with indices of test problems where method does not converge to small residual
+    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]] = [3, 6, 15, 16, 21]
+
+    test_on_library(problems, dicts, alg_ops, broken_tests)
+end
+
+@testset "SimpleDFSane 23 Test Problems" begin
+    alg_ops = (SimpleDFSane(),)
+
+    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]] = [1, 2, 3, 4, 5, 6, 7, 9, 11, 12, 13, 15, 16, 17, 21, 22]
+
+    test_on_library(problems, dicts, alg_ops, broken_tests)
+end
+
+@testset "SimpleBroyden 23 Test Problems" begin
+    alg_ops = (SimpleBroyden(),)
+
+    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]] = [1, 2, 4, 5, 6, 11, 12, 13, 14]
+
+    skip_tests = Dict(alg => Int[] for alg in alg_ops)
+    skip_tests[alg_ops[1]] = [22]
+
+    test_on_library(problems, dicts, alg_ops, broken_tests; skip_tests)
+end
+
+@testset "SimpleKlement 23 Test Problems" begin
+    alg_ops = (SimpleKlement(),)
+
+    broken_tests = Dict(alg => Int[] for alg in alg_ops)
+    broken_tests[alg_ops[1]] = [1, 2, 4, 5, 6, 7, 9, 10, 11, 12, 13, 19, 21, 22]
+
+    test_on_library(problems, dicts, alg_ops, broken_tests)
+end

test/Project.toml

@@ -4,6 +4,7 @@ DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
+NonlinearProblemLibrary = "b7050fa9-e91f-4b37-bcee-a89a063da141"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"