Rename solvers as optimizers

Author: tmigot

docs/src/benchmark.md

@@ -1,8 +1,8 @@
-# Benchmarking solvers
+# Benchmarking optimizers
 
 Benchmarking is very important when researching new algorithms or selecting the most approriate ones.
 
-The package [`SolverBenchmark`](https://github.com/JuliaSmoothOptimizers/SolverBenchmark.jl) exports the function [`bmark_solvers`](https://github.com/JuliaSmoothOptimizers/SolverBenchmark.jl/blob/main/src/bmark_solvers.jl) that runs a set of solvers on a set of problems. `JSOSuite.jl` specialize this function, see `bmark_solvers`.
+The package [`SolverBenchmark`](https://github.com/JuliaSmoothOptimizers/SolverBenchmark.jl) exports the function [`bmark_solvers`](https://github.com/JuliaSmoothOptimizers/SolverBenchmark.jl/blob/main/src/bmark_solvers.jl) that runs a set of optimizers on a set of problems. `JSOSuite.jl` specialize this function, see `bmark_solvers`.
 
 The [JuliaSmoothOptimizers organization](https://juliasmoothoptimizers.github.io) contains several packages of test problems ready to use for benchmarking. The main ones are
 - [`OptimizationProblems.jl`](https://github.com/JuliaSmoothOptimizers/OptimizationProblems.jl): This package provides a collection of optimization problems in JuMP and ADNLPModels syntax;
@@ -36,21 +36,21 @@ ad_problems = [
 length(ad_problems) # return the number of problems
 ```
 
-We now want to select appropriate solvers using the `JSOSuite.solvers`.
+We now want to select appropriate optimizers using the `JSOSuite.optimizers`.
 
 ```@example op
-selected_solvers = JSOSuite.solvers
-# solvers can solve general `nlp` as some are specific to variants (NLS, ...)
-selected_solvers = selected_solvers[selected_solvers.can_solve_nlp, :]
-selected_solvers[selected_solvers.is_available, :] # solvers available
+selected_optimizers = JSOSuite.optimizers
+# optimizers can solve general `nlp` as some are specific to variants (NLS, ...)
+selected_optimizers = selected_optimizers[selected_optimizers.can_solve_nlp, :]
+selected_optimizers[selected_optimizers.is_available, :] # optimizers available
 ```
 
-For the purpose of this example, we will consider 3 solvers.
+For the purpose of this example, we will consider 3 optimizers.
 ```@example op
 select = ["IPOPT", "TRUNK", "LBFGS"]
 ```
 
-Once the problems and solvers are chosen, the function `bmark_solvers` runs the benchmark. 
+Once the problems and optimizers are chosen, the function `bmark_solvers` runs the benchmark. 
 
 ```@example op
 using SolverBenchmark
@@ -75,7 +75,7 @@ gr()
 profile_solvers(stats, costs, costnames)
 ```
 
-Note that there are fundamental differences between these solvers as highlighted in the following.
+Note that there are fundamental differences between these optimizers as highlighted in the following.
 
 ```@example op
 for solver in ["IPOPT", "TRUNK", "LBFGS"]

docs/src/speed-up.md

@@ -4,11 +4,11 @@ The following contains a list of tips to speed up the solver selection and usage
 
 ## Derivatives
 
-The solvers available in `JSOSuite.jl` are all using first and sometines second-order derivatives. There are mainly three categories:
+The optimizers available in `JSOSuite.jl` are all using first and sometines second-order derivatives. There are mainly three categories:
 - 1st order methods use only gradient information;
 - 1st order quasi-Newton methods require only gradient information, and uses it to build an approximation of the Hessian;
 - 2nd order methods: Those are using gradients and Hessian information.
-- 2nd order methods matrix-free: Those are solvers using Hessian information, but without ever forming the matrix, so only matrix-vector products are computed.
+- 2nd order methods matrix-free: Those are optimizers using Hessian information, but without ever forming the matrix, so only matrix-vector products are computed.
 
 The latter is usually a good tradeoff for very large problems.
 
@@ -22,7 +22,7 @@ stats
 
 ## Find a better initial guess
 
-The majority of derivative-based solvers are local methods whose performance are dependent of the initial guess. 
+The majority of derivative-based optimizers are local methods whose performance are dependent of the initial guess. 
 This usually relies on specific knowledge of the problem.
 
 The function [`feasible_point`](@ref) computes a point satisfying the constraints of the problem that can be used as an initial guess. 
@@ -31,15 +31,15 @@ An alternative is to solve a simpler version of the problem and reuse the soluti
 ## Use the structure of the problem
 
 If the problem has linear constraints, then it is efficient to specify it at the modeling stage to avoid having them treated like nonlinear ones.
-Some of the solvers will also exploit this information.
+Some of the optimizers will also exploit this information.
 
-Similarly, quadratic objective or least squares problems have tailored modeling tools and solvers.
+Similarly, quadratic objective or least squares problems have tailored modeling tools and optimizers.
 
 ## Change the parameters of the solver
 
-Once a solver has been chosen it is also possible to play with the key parameters. Find below a list of the available solvers and parameters.
+Once a solver has been chosen it is also possible to play with the key parameters. Find below a list of the available optimizers and parameters.
 
-Note that all solvers presented here have been carefully optimized. All have different strengths. Trying another solver on the same problem sometimes provide a different solution.
+Note that all optimizers presented here have been carefully optimized. All have different strengths. Trying another solver on the same problem sometimes provide a different solution.
 
 ### Unconstrained/Bound-constrained
 

docs/src/tutorial.md

@@ -6,7 +6,7 @@ There are two important challenges in solving an optimization problem: (i) model
 
 ## Modeling
 
-All these solvers rely on the `NLPModel API` from [NLPModels.jl](https://github.com/JuliaSmoothOptimizers/NLPModels.jl) for general nonlinear optimization problems of the form
+All these optimizers rely on the `NLPModel API` from [NLPModels.jl](https://github.com/JuliaSmoothOptimizers/NLPModels.jl) for general nonlinear optimization problems of the form
 
 ```math
 \begin{aligned}
@@ -127,37 +127,37 @@ stats = solve(f, x0, A, c, l, l, verbose = 0)
 
 ## Solving
 
-Internally, the `solve` function selects solvers according to the problem's property and JSO-compliant solvers available.
+Internally, the `solve` function selects optimizers according to the problem's property and JSO-compliant optimizers available.
 
-### Available solvers
+### Available optimizers
 
-All the information used by the handled solvers is available in the following `DataFrame`:
+All the information used by the handled optimizers is available in the following `DataFrame`:
 
 ```@example ex1
 using JSOSuite
-JSOSuite.solvers
+JSOSuite.optimizers
 ```
 
-Required information can be extracted by simple `DataFrame` manipulations. For instance, the list of solvers handled by this package
+Required information can be extracted by simple `DataFrame` manipulations. For instance, the list of optimizers handled by this package
 ```@example ex1
-JSOSuite.solvers.name
+JSOSuite.optimizers.name
 ```
 
-### Select solvers
+### Select optimizers
 
-The function [`JSOSuite.select_solvers`](@ref) returns a list of compatible solvers.
+The function [`JSOSuite.select_optimizers`](@ref) returns a list of compatible optimizers.
 ```@example
 using ADNLPModels, JSOSuite
 f = x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2
 x0 = [-1.2; 1.0]
 nlp = ADNLPModel(f, x0)
-JSOSuite.select_solvers(nlp)
+JSOSuite.select_optimizers(nlp)
 ```
 
 ### Fine-tune solve call
 
 All the keyword arguments are passed to the solver.
-Keywords available for all the solvers are given below:
+Keywords available for all the optimizers are given below:
 
 - `atol`: absolute tolerance;
 - `rtol`: relative tolerance;

src/JSOSuite.jl

@@ -11,7 +11,7 @@ using LinearOperators, NLPModelsModifiers, SolverCore
 using JSOSolvers, Percival
 
 """
-    solvers
+    optimizers
 
 DataFrame with the JSO-compliant solvers and their properties.
 
@@ -31,7 +31,7 @@ For each solver, the following are available:
 - `double_precision_only::Bool`: `true` if the solver only handles double precision (`Float64`);
 - `highest_derivative::Int`: order of the highest derivative used by the algorithm.
 """
-solvers = DataFrame(
+optimizers = DataFrame(
   name = String[],
   name_solver = Symbol[],
   name_pkg = String[],
@@ -48,7 +48,7 @@ solvers = DataFrame(
   highest_derivative = Int[],
 )
 push!(
-  solvers,
+  optimizers,
   (
     "KNITRO",
     :KnitroSolver,
@@ -67,7 +67,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "LBFGS",
     :LBFGSSolver,
@@ -86,7 +86,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "R2",
     :R2Solver,
@@ -105,7 +105,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "TRON",
     :TronSolver,
@@ -124,7 +124,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "TRUNK",
     :TrunkSolver,
@@ -143,7 +143,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "TRON-NLS",
     :TronSolverNLS,
@@ -162,7 +162,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "TRUNK-NLS",
     :TrunkSolverNLS,
@@ -181,7 +181,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "CaNNOLeS",
     :CaNNOLeSSolver,
@@ -200,7 +200,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "IPOPT",
     :IpoptSolver,
@@ -219,7 +219,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "DCISolver",
     :DCIWorkspace,
@@ -238,7 +238,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "FletcherPenaltySolver",
     :FPSSSolver,
@@ -257,7 +257,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "Percival",
     :PercivalSolver,
@@ -276,7 +276,7 @@ push!(
   ),
 )
 push!(
-  solvers,
+  optimizers,
   (
     "RipQP",
     :RipQPSolver,
@@ -367,7 +367,7 @@ stats
 "Execution stats: first-order stationary"
 ```
 
-The list of available solver can be obtained using `JSOSuite.solvers[!, :name]` or see [`select_solvers`](@ref).
+The list of available solver can be obtained using `JSOSuite.optimizers[!, :name]` or see [`select_optimizers`](@ref).
 
 ```jldoctest; output = false
 using JSOSuite
@@ -379,7 +379,7 @@ stats
 "Execution stats: first-order stationary"
 ```
 
-Some solvers are available after loading only.
+Some optimizers are available after loading only.
 
 ```jldoctest; output = false
 using JSOSuite
@@ -406,11 +406,11 @@ function solve end
     solve!(solver::AbstractOptimizationSolver, model::Union{AbstractNLPModel, JuMP.Model}, stats; kwargs...)
 
 `JSOSuite` extension of `SolverCore.solve!`.
-The first argument should be of type `SolverCore.AbstractOptimizationSolver`, see for instance `JSOSuite.solvers[!, :name_solver]`.
+The first argument should be of type `SolverCore.AbstractOptimizationSolver`, see for instance `JSOSuite.optimizers[!, :name_solver]`.
 """
 function SolverCore.solve!(solver, args...; kwargs...)
   throw(
-    "solve! not implemented first argument should be of type `SolverCore.AbstractOptimizationSolver` and not $(typeof(solver)), see for instance `JSOSuite.solvers[!, :name_solver]`.",
+    "solve! not implemented first argument should be of type `SolverCore.AbstractOptimizationSolver` and not $(typeof(solver)), see for instance `JSOSuite.optimizers[!, :name_solver]`.",
   )
 end
 
@@ -420,7 +420,7 @@ include("solve.jl")
 
 @init begin
   @require CaNNOLeS = "5a1c9e79-9c58-5ec0-afc4-3298fdea2875" begin
-    JSOSuite.solvers[JSOSuite.solvers.name .== "CaNNOLeS", :is_available] .= 1
+    JSOSuite.optimizers[JSOSuite.optimizers.name .== "CaNNOLeS", :is_available] .= 1
     function solve(::Val{:CaNNOLeS}, nlp; kwargs...)
       return CaNNOLeS.cannoles(nlp; linsolve = :ldlfactorizations, kwargs...)
     end
@@ -430,7 +430,7 @@ end
 
 @init begin
   @require DCISolver = "bee2e536-65f6-11e9-3844-e5bb4c9c55c9" begin
-    JSOSuite.solvers[JSOSuite.solvers.name .== "DCISolver", :is_available] .= 1
+    JSOSuite.optimizers[JSOSuite.optimizers.name .== "DCISolver", :is_available] .= 1
     function solve(::Val{:DCISolver}, nlp; kwargs...)
       return DCISolver.dci(nlp; kwargs...)
     end
@@ -439,7 +439,7 @@ end
 
 @init begin
   @require FletcherPenaltySolver = "e59f0261-166d-4fee-8bf3-5e50457de5db" begin
-    JSOSuite.solvers[JSOSuite.solvers.name .== "FletcherPenaltySolver", :is_available] .= 1
+    JSOSuite.optimizers[JSOSuite.optimizers.name .== "FletcherPenaltySolver", :is_available] .= 1
     function solve(::Val{:FletcherPenaltySolver}, nlp; kwargs...)
       return FletcherPenaltySolver.fps_solve(nlp; kwargs...)
     end
@@ -448,7 +448,7 @@ end
 
 @init begin
   @require NLPModelsIpopt = "f4238b75-b362-5c4c-b852-0801c9a21d71" begin
-    JSOSuite.solvers[JSOSuite.solvers.name .== "IPOPT", :is_available] .= 1
+    JSOSuite.optimizers[JSOSuite.optimizers.name .== "IPOPT", :is_available] .= 1
     include("solvers/ipopt_solve.jl")
   end
 end
@@ -457,7 +457,7 @@ end
   @require NLPModelsKnitro = "bec4dd0d-7755-52d5-9a02-22f0ffc7efcb" begin
     @init begin
       @require NLPModelsKnitro = "bec4dd0d-7755-52d5-9a02-22f0ffc7efcb" begin
-        JSOSuite.solvers[JSOSuite.solvers.name .== "KNITRO", :is_available] .= KNITRO.has_knitro()
+        JSOSuite.optimizers[JSOSuite.optimizers.name .== "KNITRO", :is_available] .= KNITRO.has_knitro()
       end
     end
     include("solvers/knitro_solve.jl")
@@ -466,7 +466,7 @@ end
 
 @init begin
   @require RipQP = "1e40b3f8-35eb-4cd8-8edd-3e515bb9de08" begin
-    JSOSuite.solvers[JSOSuite.solvers.name .== "RipQP", :is_available] .= 1
+    JSOSuite.optimizers[JSOSuite.optimizers.name .== "RipQP", :is_available] .= 1
     include("solvers/ripqp_solve.jl")
   end
 end
@@ -506,7 +506,7 @@ nlps = (
   ADNLPModel(x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0]),
   ADNLPModel(x -> 4 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0]),
 )
-names = ["LBFGS", "TRON"] # see `JSOSuite.solvers.name` for the complete list
+names = ["LBFGS", "TRON"] # see `JSOSuite.optimizers.name` for the complete list
 stats = bmark_solvers(nlps, names, atol = 1e-3, verbose = 0, colstats = [:name, :nvar, :ncon, :status])
 keys(stats)
 
@@ -532,7 +532,7 @@ nlps = (
   ADNLPModel(x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0]),
   ADNLPModel(x -> 4 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0]),
 )
-names = ["LBFGS", "TRON"] # see `JSOSuite.solvers.name` for the complete list
+names = ["LBFGS", "TRON"] # see `JSOSuite.optimizers.name` for the complete list
 other_solvers = Dict{Symbol, Function}(
   :test => nlp -> lbfgs(nlp; mem = 2, atol = 1e-3, verbose = 0),
 )