building

arnavk23 · ChrisRackauckas · commit 93c308ba614e · 2025-08-06T05:21:14.000-04:00
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_bounded.jmd b/benchmarks/OptimizationCUTEst/CUTEst_bounded.jmd
@@ -20,7 +20,6 @@ using OptimizationNLPModels
 using CUTEst
 using OptimizationOptimJL
 using OptimizationOptimisers
-using OptimizationOptimJL: LBFGS, ConjugateGradient, NelderMead, SimulatedAnnealing, ParticleSwarm
 using Ipopt
 using OptimizationMOI
 using OptimizationMOI: MOI as MOI
@@ -245,4 +244,7 @@ else
 end
 ```
 
-
+```
+using SciMLBenchmarks
+SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])
+```
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_quadratic.jmd b/benchmarks/OptimizationCUTEst/CUTEst_quadratic.jmd
@@ -7,15 +7,17 @@ author: Alonso M. Cisneros
 
 CUTEst, the Constraind and Unconstrained Testing Environment is, as the name suggests is a
 collection of around 1500 problems for general nonlinear optimization used to test
-
-```julia; eval = true; @setup
+optimization routines. The wrapper
+[CUTEst.jl](https://github.com/JuliaSmoothOptimizers/CUTEst.jl) provides convenient access
+to the problem collection, which we can leverage to test the optimizers made available by
+Optimization.jl.
+```julia
 using Pkg; Pkg.activate("."); Pkg.instantiate()
 using Optimization
 using OptimizationNLPModels
 using CUTEst
 using OptimizationOptimJL
 using OptimizationOptimisers
-using OptimizationOptimJL: LBFGS, ConjugateGradient, NelderMead, SimulatedAnnealing, ParticleSwarm
 using Ipopt
 using OptimizationMOI
 using OptimizationMOI: MOI as MOI
@@ -48,6 +50,8 @@ function run_benchmarks(problems, optimizers; chunk_size=1)
     solver = String[]
     retcode = Symbol[]
     optz = length(optimizers)
+    n = length(problems)
+    @info "Processing $(n) problems with $(optz) optimizers in chunks of $(chunk_size)"
     broadcast(c -> sizehint!(c, optz * n), [problem, n_vars, secs, solver, retcode])
     for chunk_start in 1:chunk_size:n
         chunk_end = min(chunk_start + chunk_size - 1, n)
@@ -128,6 +132,7 @@ constraints. There are 252 such problems in the suite.
 
 # Select a moderate subset of quadratic problems for a realistic mix of successes and failures
 quad_problems = CUTEst.select_sif_problems(objtype="quadratic", contype="linear")
+@info "Testing $(length(quad_problems)) quadratic problems with linear constraints"
 quad_problems = quad_problems[1:min(30, length(quad_problems))]
  # Skip HIER13, BLOWEYA, LUKVLE8, PATTERNNE, READING2, NINENEW, READING6, DITTERT, CVXQP2, and MSS1 if present
 quad_problems = filter(p -> !(lowercase(p) in ["hier13", "bloweya", "s268", "stcqp1", "cvxqp3", "avgasb", "lukvle8", "sosqp2", "patternne", "reading2", "ninenew", "reading6", "dittert", "liswet9", "cleuven4", "cvxqp2", "mss1", "mpc2", "cmpc10", "cmpc3"]), quad_problems)
@@ -261,3 +266,7 @@ else
 end
 ```
 
+```julia, echo = false
+using SciMLBenchmarks
+SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])
+```
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_safe_solvers.jmd b/benchmarks/OptimizationCUTEst/CUTEst_safe_solvers.jmd
@@ -9,7 +9,7 @@ This benchmark extends the original CUTEst unconstrained benchmark to demonstrat
 
 This serves as a proof-of-concept for the expanded solver testing objective while maintaining reliability.
 
-```julia; eval = true
+```julia
 using Optimization
 using OptimizationNLPModels
 using CUTEst
@@ -333,3 +333,8 @@ end
 """
 NOTE: Ensure all code chunks are evaluated in order. If running in a notebook or Weave, do not skip any chunks.
 """
+
+```julia, echo = false
+using SciMLBenchmarks
+SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])
+```
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_unbounded.jmd b/benchmarks/OptimizationCUTEst/CUTEst_unbounded.jmd
@@ -24,169 +24,13 @@ using Optimization
 using OptimizationNLPModels
 using CUTEst
 using OptimizationOptimJL
-using OptimizationOptimisers
-using OptimizationOptimJL: LBFGS, ConjugateGradient, NelderMead, SimulatedAnnealing, ParticleSwarm
 using Ipopt
 using OptimizationMOI
 using OptimizationMOI: MOI as MOI
-
-# Harmonized analysis block for equality-constrained unbounded problems
-function run_unbounded_benchmarks(problems, optimizers; chunk_size=3)
-    problem = String[]
-    n_vars = Int64[]
-    secs = Float64[]
-    solver = String[]
-    retcode = Symbol[]
-    optz = length(optimizers)
-    n = length(problems)
-    @info "Processing $(n) unbounded problems with $(optz) optimizers in chunks of $(chunk_size)"
-    broadcast(c -> sizehint!(c, optz * n), [problem, n_vars, secs, solver, retcode])
-    for chunk_start in 1:chunk_size:n
-        chunk_end = min(chunk_start + chunk_size - 1, n)
-        chunk_problems = problems[chunk_start:chunk_end]
-        @info "Processing chunk $(div(chunk_start-1, chunk_size)+1)/$(div(n-1, chunk_size)+1): problems $(chunk_start)-$(chunk_end)"
-        for (idx, prob_name) in enumerate(chunk_problems)
-            current_problem = chunk_start + idx - 1
-            # Removed stray reference to current_problem (only valid inside benchmark functions)
-            nlp_prob = nothing
-            try
-                nlp_prob = CUTEstModel(prob_name)
-                if nlp_prob.meta.nvar > 10000
-                    @info "  Skipping $(prob_name) (too large: $(nlp_prob.meta.nvar) variables)"
-                    finalize(nlp_prob)
-                    continue
-                end
-                prob = OptimizationNLPModels.OptimizationProblem(nlp_prob, Optimization.AutoForwardDiff())
-                for (optimizer_name, optimizer) in optimizers
-                    try
-                        sol = solve(prob, optimizer; maxiters = 1000, maxtime = 30.0)
-                        @info "✓ Solved $(prob_name) with $(optimizer_name) - Status: $(sol.retcode)"
-                        vars, time, alg, code = get_stats(sol, optimizer_name)
-                        push!(problem, prob_name)
-                        push!(n_vars, vars)
-                        push!(secs, time)
-                        push!(solver, alg)
-                        push!(retcode, code)
-                    catch e
-                        push!(problem, prob_name)
-                        push!(n_vars, nlp_prob !== nothing ? nlp_prob.meta.nvar : -1)
-                        push!(secs, NaN)
-                        push!(solver, optimizer_name)
-                        push!(retcode, :FAILED)
-                        println("ERROR: ", e)
-                        println("Stacktrace:")
-                        for (i, frame) in enumerate(stacktrace(e))
-                            println("  ", i, ": ", frame)
-                        end
-                    end
-                end
-            catch e
-                for (optimizer_name, optimizer) in optimizers
-                    push!(problem, prob_name)
-                    push!(n_vars, -1)
-                    push!(secs, NaN)
-                    push!(solver, optimizer_name)
-                    push!(retcode, :LOAD_FAILED)
-                end
-                println("LOAD ERROR: ", e)
-                println("Stacktrace:")
-                for (i, frame) in enumerate(stacktrace(e))
-                    println("  ", i, ": ", frame)
-                end
-            finally
-                if nlp_prob !== nothing
-                    try
-                        finalize(nlp_prob)
-                    catch e
-                    end
-                end
-            end
-        end
-        GC.gc()
-        @info "Completed chunk, memory usage cleaned up"
-    end
-    return DataFrame(problem = problem, n_vars = n_vars, secs = secs, solver = solver, retcode = retcode)
-end
-
-            @info "Problem $(current_problem)/$(n): $(prob_name)"
-println("Full results table for equality-constrained problems:")
-display(eq_unb_results)
-
-# Calculate and display success rates for equality constrained
-successful_codes = [:Success, :MaxIters, :MaxTime, :FirstOrderOptimal]
-successful_results = filter(row -> row.retcode in successful_codes, eq_unb_results)
-total_attempts = nrow(eq_unb_results)
-successful_attempts = nrow(successful_results)
-success_rate = total_attempts > 0 ? round(successful_attempts / total_attempts * 100, digits=1) : 0
-
-@info "EQUALITY CONSTRAINED SUCCESS RATE: $(success_rate)% ($(successful_attempts)/$(total_attempts))"
-
-if nrow(eq_unb_results) > 0
-    try
-        @df eq_unb_results scatter(:n_vars, :secs,
-            group = :solver,
-            xlabel = "n. variables",
-            ylabel = "secs.",
-            title = "Time to solution by optimizer and number of vars",
-        )
-        println("Plotted equality-constrained results.")
-    catch e
-        println("Plotting failed: ", e)
-    end
-else
-    println("Warning: equality-constrained results DataFrame is empty. No data to plot.")
-    println("Attempted problems:")
-    println(eq_unb_problems)
-end
-            nlp_prob = nothing
-            try
-                nlp_prob = CUTEstModel(prob_name)
-                if nlp_prob.meta.nvar > 10000
-                    @info "  Skipping $(prob_name) (too large: $(nlp_prob.meta.nvar) variables)"
-                    finalize(nlp_prob)
-                    continue
-                end
-                prob = OptimizationNLPModels.OptimizationProblem(nlp_prob, Optimization.AutoForwardDiff())
-                for (optimizer_name, optimizer) in optimizers
-                    try
-                        sol = solve(prob, optimizer; maxiters = 1000, maxtime = 30.0)
-                        @info "✓ Solved $(prob_name) with $(optimizer_name) - Status: $(sol.retcode)"
-                        vars, time, alg, code = get_stats(sol, optimizer_name)
-                        push!(problem, prob_name)
-                        push!(n_vars, vars)
-                        push!(secs, time)
-                        push!(solver, alg)
-                        push!(retcode, code)
-                    catch e
-                        push!(problem, prob_name)
-                        push!(n_vars, nlp_prob !== nothing ? nlp_prob.meta.nvar : -1)
-                        push!(secs, NaN)
-                        push!(solver, optimizer_name)
-                        push!(retcode, :FAILED)
-                    end
-                end
-            catch e
-                for (optimizer_name, optimizer) in optimizers
-                    push!(problem, prob_name)
-                    push!(n_vars, -1)
-                    push!(secs, NaN)
-                    push!(solver, optimizer_name)
-                    push!(retcode, :LOAD_FAILED)
-                end
-            finally
-                if nlp_prob !== nothing
-                    try
-                        finalize(nlp_prob)
-                    catch e
-                    end
-                end
-            end
-        end
-        GC.gc()
-        @info "Completed chunk, memory usage cleaned up"
-    end
-    return DataFrame(problem = problem, n_vars = n_vars, secs = secs, solver = solver, retcode = retcode)
-end
+using DataFrames
+using Plots
+using StatsPlots
+using StatsBase: countmap
 ```
 
 # Benchmarks
@@ -426,4 +270,8 @@ if total_attempts_ineq > 0
 else
     println("  No results to analyze")
 end
-```
+```
+```julia, echo = false
+using SciMLBenchmarks
+SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])
+```
diff --git a/benchmarks/OptimizationCUTEst/CUTEst_unconstrained.jmd b/benchmarks/OptimizationCUTEst/CUTEst_unconstrained.jmd
@@ -170,4 +170,10 @@ end
         ylabel = "secs.",
         title = "Time to solution by optimizer and number of vars",
     )
-```
+```
+
+
+```julia, echo = false
+using SciMLBenchmarks
+SciMLBenchmarks.bench_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])
+```
