Rename solve by minimize

Author: tmigot

docs/src/index.md

@@ -15,13 +15,13 @@ All these solvers rely on the `NLPModel API` from [NLPModels.jl](https://github.
 
 The package `JSOSuite` exports a function [`solve`](@ref): 
 ```
-output = solve(args...; kwargs...)
+output = minimize(args...; kwargs...)
 ```
 The arguments are used to define the problem, see [Tutorial](@ref tutorial-section).
 
 It is also possible to define an `NLPModel` or a `JuMP` model representing the problem, and then call `solve`:
 ```
-output = solve(nlpmodel; kwargs...)
+output = minimize(nlpmodel; kwargs...)
 ```
 
 The `NLPModel API` is a general consistent API for solvers to interact with models by providing flexible data types to represent the objective and constraint functions to evaluate their derivatives, and to provide essentially any information that a solver might request from a model. [JuliaSmoothOrganization's website](https://juliasmoothoptimizers.github.io) or [NLPModels.jl's documentation](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/) provide more tutorials on this topic.

docs/src/nls.md

@@ -44,21 +44,21 @@ nls = ADNLSModel(F, x0, nres, c, l, l, name="AD-Rosenbrock")
 Note that the length of the residual function is given explictly to avoid any superfluous evaluation of this (potentially very large) function.
 
 ```@example ex1
-stats = solve(nls)
+stats = minimize(nls)
 ```
 
 `JSOSuite.jl` uses by default automatic differentiation, so the following code would be equivalent:
 
 ```@example ex1
-stats = solve(F, x0, nres, c, l, l)
+stats = minimize(F, x0, nres, c, l, l)
 ```
 
 By default, `JSOSuite.solve` will use a solver tailored for nonlineat least squares problem.
 Nevertheless, it is also possible to specify the solver to be used.
 
 ```@example ex1
 using NLPModelsIpopt
-stats = solve("IPOPT", F, x0, nres, c, l, l)
+stats = minimize("IPOPT", F, x0, nres, c, l, l)
 ```
 
 We refer to the documentation of [`ADNLPModels.jl`](https://juliasmoothoptimizers.github.io/ADNLPModels.jl/dev/backend/) for more details on the AD system use and how to modify it.
@@ -78,7 +78,7 @@ x0 = [-1.2; 1.0]
 @NLconstraint(model, x[1] * x[2] == 1)
 
 nls = MathOptNLSModel(model, [F1, F2], name="Ju-Rosenbrock")
-stats = solve(nls)
+stats = minimize(nls)
 ```
 
 ## Find a feasible point of an optimization problem or solve a nonlinear system

docs/src/qp.md

@@ -18,10 +18,10 @@ In JuliaSmoothOptimizers, the package [`QuadraticModels.jl`](https://github.com/
 The function `solve` with the following sets of arguments will automatically build a `QuadraticModel` and choose the adequate solver.
 
 ```julia
-  stats = solve(c, H, c0 = c0, x0 = x0, name = name; kwargs...)
-  stats = solve(c, H, lvar, uvar, c0 = c0, x0 = x0, name = name; kwargs...)
-  stats = solve(c, H, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
-  stats = solve(c, H, lvar, uvar, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
+  stats = minimize(c, H, c0 = c0, x0 = x0, name = name; kwargs...)
+  stats = minimize(c, H, lvar, uvar, c0 = c0, x0 = x0, name = name; kwargs...)
+  stats = minimize(c, H, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
+  stats = minimize(c, H, lvar, uvar, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
 ```
 
 ## Example
@@ -41,20 +41,20 @@ The quadratic model can then be solved using [`solve`](@ref).
 
 ```@example ex1
 using JSOSuite
-  stats = solve(c, H, A, lcon, ucon, name = "eqconqp_QP")
+  stats = minimize(c, H, A, lcon, ucon, name = "eqconqp_QP")
 ```
 
 This is equivalent to building a `QuadraticModel` and then [`solve`](@ref).
 
 ```@example ex1
 using QuadraticModels, JSOSuite
   qp_model = QuadraticModel(c, H, A, lcon, ucon, name = "eqconqp_QP")
-  stats = solve(qp_model)
+  stats = minimize(qp_model)
 ```
 
 As usual, it is also possible to select manually the solver to be used.
 
 ```@example ex1
   using RipQP
-  stats = solve("RipQP", c, H, A, lcon, ucon, name = "eqconqp_QP")
+  stats = minimize("RipQP", c, H, A, lcon, ucon, name = "eqconqp_QP")
 ```

docs/src/speed-up.md

@@ -16,7 +16,7 @@ The latter is usually a good tradeoff for very large problems.
 using JSOSuite
 f = x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2
 x0 = [-1.2; 1.0]
-stats = solve(f, x0, verbose = 0, highest_derivative_available = 1)
+stats = minimize(f, x0, verbose = 0, highest_derivative_available = 1)
 stats
 ```
 

docs/src/tutorial.md

@@ -19,7 +19,7 @@ All these optimizers rely on the `NLPModel API` from [NLPModels.jl](https://gith
 
 The function `solve` accepts as an argument any model `nlp` subtype of `AbstractNLPModel`.
 ```julia
-output = solve(nlpmodel::AbstractNLPModel; kwargs...)
+output = minimize(nlpmodel::AbstractNLPModel; kwargs...)
 ```
 
 In the rest of this section, we focus on examples using generic modeling tools.
@@ -35,7 +35,7 @@ model = Model()
 @variable(model, y)
 @NLobjective(model, Min, (1 - x)^2 + 100 * (y - x^2)^2)
 
-solve(model)
+minimize(model)
 ```
 
 We refer to [`JuMP tutorial`](https://jump.dev/JuMP.jl/stable/).
@@ -50,15 +50,15 @@ We refer to [`ADNLPModel`](https://juliasmoothoptimizers.github.io/ADNLPModels.j
 using JSOSuite
 f = x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2
 x0 = [-1.2; 1.0]
-stats = solve(f, x0, verbose = 0)
+stats = minimize(f, x0, verbose = 0)
 ```
 
 ```@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)
-stats = solve(nlp)
+stats = minimize(nlp)
 ```
 
 One of the main advantages of this constructor is the possibility to run computations in different arithmetics. 
@@ -67,7 +67,7 @@ One of the main advantages of this constructor is the possibility to run computa
 using JSOSuite
 f = x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2
 x0 = Float32[-1.2; 1.0]
-stats = solve(f, x0, verbose = 0)
+stats = minimize(f, x0, verbose = 0)
 ```
 
 #### Bound-constrained
@@ -77,15 +77,15 @@ using JSOSuite
 f = x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2
 x0 = [-1.2; 1.0]
 lvar, uvar = 2 * ones(2), 4 * ones(2)
-stats = solve(f, x0, lvar, uvar, verbose = 0)
+stats = minimize(f, x0, lvar, uvar, verbose = 0)
 ```
 
 ```@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)
-stats = solve(nlp)
+stats = minimize(nlp)
 ```
 
 #### Nonlinear constrained
@@ -96,7 +96,7 @@ f = x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2
 x0 = [-1.2; 1.0]
 c = x -> [x[1]]
 l = ones(1)
-stats = solve(f, x0, c, l, l, verbose = 0)
+stats = minimize(f, x0, c, l, l, verbose = 0)
 ```
 
 #### Linearly constrained
@@ -110,7 +110,7 @@ A = sparse([
     2.0 3.0
 ])
 l = ones(2)
-stats = solve(f, x0, A, l, l, verbose = 0)
+stats = minimize(f, x0, A, l, l, verbose = 0)
 ```
 
 #### All constraints
@@ -122,7 +122,7 @@ x0 = [-1.2; 1.0]
 A = sparse([2.0 3.0])
 c = x -> [x[1]]
 l = ones(2)
-stats = solve(f, x0, A, c, l, l, verbose = 0)
+stats = minimize(f, x0, A, c, l, l, verbose = 0)
 ```
 
 ## Solving
@@ -170,7 +170,7 @@ 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)
-stats = solve(nlp, atol = 1e-5, rtol = 1e-7, max_time = 10.0, max_eval = 10000, verbose = 1)
+stats = minimize(nlp, atol = 1e-5, rtol = 1e-7, max_time = 10.0, max_eval = 10000, verbose = 1)
 ```
 
 Further possible options are documented in each solver's documentation. For instance, we can update the `mem` parameter of `LBFGS`.
@@ -180,5 +180,5 @@ 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)
-stats = solve("LBFGS", nlp, mem = 10, verbose = 1)
+stats = minimize("LBFGS", nlp, mem = 10, verbose = 1)
 ```

src/JSOSuite.jl

@@ -297,28 +297,28 @@ push!(
 
 include("selection.jl")
 
-export solve, solve!, feasible_point
+export minimize, solve!, feasible_point
 
 """
-    stats = solve(nlp::Union{AbstractNLPModel, JuMP.Model}; kwargs...)
+    stats = minimize(nlp::Union{AbstractNLPModel, JuMP.Model}; kwargs...)
 
 Compute a local minimum of the optimization problem `nlp`.
 
-    stats = solve(f::Function, x0::AbstractVector, args...; kwargs...)
-    stats = solve(F::Function, x0::AbstractVector, nequ::Integer, args...; kwargs...)
+    stats = minimize(f::Function, x0::AbstractVector, args...; kwargs...)
+    stats = minimize(F::Function, x0::AbstractVector, nequ::Integer, args...; kwargs...)
 
 Define an NLPModel using [`ADNLPModel`](https://juliasmoothoptimizers.github.io/ADNLPModels.jl/stable/).
 
-    stats = solve(c, H, c0 = c0, x0 = x0, name = name; kwargs...)
-    stats = solve(c, H, lvar, uvar, c0 = c0, x0 = x0, name = name; kwargs...)
-    stats = solve(c, H, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
-    stats = solve(c, H, lvar, uvar, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
+    stats = minimize(c, H, c0 = c0, x0 = x0, name = name; kwargs...)
+    stats = minimize(c, H, lvar, uvar, c0 = c0, x0 = x0, name = name; kwargs...)
+    stats = minimize(c, H, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
+    stats = minimize(c, H, lvar, uvar, A, lcon, ucon, c0 = c0, x0 = x0, name = name; kwargs...)
 
 Define a QuadraticModel using [`QuadraticModel`](https://juliasmoothoptimizers.github.io/QuadraticModels.jl/stable/).
 
-The solver can be chosen as follows.
+The optimizer can be chosen as follows.
 
-    stats = solve(solver_name::String, args...; kwargs...)
+    stats = minimize(optimizer_name::String, args...; kwargs...)
 
 `JuMP.Model` are converted in NLPModels via NLPModelsJuMP.jl.
 
@@ -359,7 +359,7 @@ The value returned is a `GenericExecutionStats`, see `SolverCore.jl`.
 # Examples
 ```jldoctest; output = false
 using JSOSuite
-stats = solve(x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0], verbose = 0)
+stats = minimize(x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0], verbose = 0)
 stats
 
 # output
@@ -371,7 +371,7 @@ The list of available solver can be obtained using `JSOSuite.optimizers[!, :name
 
 ```jldoctest; output = false
 using JSOSuite
-stats = solve("TRON", x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0], verbose = 0)
+stats = minimize("TRON", x -> 100 * (x[2] - x[1]^2)^2 + (x[1] - 1)^2, [-1.2; 1.0], verbose = 0)
 stats
 
 # output
@@ -383,13 +383,13 @@ Some optimizers are available after loading only.
 
 ```jldoctest; output = false
 using JSOSuite
-# We solve here a quadratic problem with bound-constraints
+# We minimize here a quadratic problem with bound-constraints
 c = [1.0; 1.0]
 H = [-2.0 0.0; 3.0 4.0]
 uvar = [1.0; 1.0]
 lvar = [0.0; 0.0]
 x0 = [0.5; 0.5]
-stats = solve("TRON", c, H, lvar, uvar, x0 = x0, name = "bndqp_QP", verbose = 0)
+stats = minimize("TRON", c, H, lvar, uvar, x0 = x0, name = "bndqp_QP", verbose = 0)
 stats
 
 # output
@@ -399,7 +399,7 @@ stats
 ```
 
 """
-function solve end
+function minimize end
 
 """
     solve!(solver::AbstractOptimizationSolver, model::Union{AbstractNLPModel, JuMP.Model}; kwargs...)
@@ -421,7 +421,7 @@ include("solve.jl")
 @init begin
   @require CaNNOLeS = "5a1c9e79-9c58-5ec0-afc4-3298fdea2875" begin
     JSOSuite.optimizers[JSOSuite.optimizers.name .== "CaNNOLeS", :is_available] .= 1
-    function solve(::Val{:CaNNOLeS}, nlp; kwargs...)
+    function minimize(::Val{:CaNNOLeS}, nlp; kwargs...)
       return CaNNOLeS.cannoles(nlp; linsolve = :ldlfactorizations, kwargs...)
     end
 
@@ -431,7 +431,7 @@ end
 @init begin
   @require DCISolver = "bee2e536-65f6-11e9-3844-e5bb4c9c55c9" begin
     JSOSuite.optimizers[JSOSuite.optimizers.name .== "DCISolver", :is_available] .= 1
-    function solve(::Val{:DCISolver}, nlp; kwargs...)
+    function minimize(::Val{:DCISolver}, nlp; kwargs...)
       return DCISolver.dci(nlp; kwargs...)
     end
   end
@@ -440,7 +440,7 @@ end
 @init begin
   @require FletcherPenaltySolver = "e59f0261-166d-4fee-8bf3-5e50457de5db" begin
     JSOSuite.optimizers[JSOSuite.optimizers.name .== "FletcherPenaltySolver", :is_available] .= 1
-    function solve(::Val{:FletcherPenaltySolver}, nlp; kwargs...)
+    function minimize(::Val{:FletcherPenaltySolver}, nlp; kwargs...)
       return FletcherPenaltySolver.fps_solve(nlp; kwargs...)
     end
   end
@@ -576,7 +576,7 @@ function bmark_solvers end
     )
       for s in solver_names
         solvers[Symbol(s)] =
-          nlp -> solve(
+          nlp -> minimize(
             s,
             nlp;
             atol = atol,
@@ -619,7 +619,7 @@ function feasible_point end
 
 function feasible_point(nlp::AbstractNLPModel, args...; kwargs...)
   nls = FeasibilityFormNLS(FeasibilityResidual(nlp))
-  stats_nls = solve(nls, args...; kwargs...)
+  stats_nls = minimize(nls, args...; kwargs...)
   stats = GenericExecutionStats(nlp)
   set_status!(stats, stats_nls.status)
   set_solution!(stats, stats_nls.solution[1:get_nvar(nlp)])

src/solve.jl

@@ -1,4 +1,4 @@
-function solve(
+function minimize(
   nlp::AbstractNLPModel;
   verbose = 1,
   highest_derivative_available::Integer = 2,
@@ -7,10 +7,10 @@ function solve(
   select = select_optimizers(nlp, verbose, highest_derivative_available)
   (verbose ≥ 1) && println("Solve using $(first(select).name):")
   solver = first(select)
-  return solve(Val(Symbol(solver.name)), nlp; verbose = verbose, kwargs...)
+  return minimize(Val(Symbol(solver.name)), nlp; verbose = verbose, kwargs...)
 end
 
-function solve(
+function minimize(
   nlp::AbstractNLSModel;
   verbose = 1,
   highest_derivative_available::Integer = 2,
@@ -24,16 +24,16 @@ function solve(
     first(select)
   end
   (verbose ≥ 1) && println("Solve using $(solver.name):")
-  return solve(Val(Symbol(solver.name)), nlp; verbose = verbose, kwargs...)
+  return minimize(Val(Symbol(solver.name)), nlp; verbose = verbose, kwargs...)
 end
 
-function solve(solver_name::String, nlp; kwargs...)
+function minimize(solver_name::String, nlp; kwargs...)
   solver = optimizers[optimizers.name .== solver_name, :]
   if isempty(solver)
     @warn "$(solver_name) does not exist."
     return GenericExecutionStats(nlp)
   end
-  return solve(Val(Symbol(solver_name)), nlp; kwargs...)
+  return minimize(Val(Symbol(solver_name)), nlp; kwargs...)
 end
 
 function throw_error_solve(solver::Symbol)
@@ -47,7 +47,7 @@ function throw_error_solve(solver::Symbol)
   return throw(ArgumentError(str))
 end
 
-function solve(::Val{solver_name}, nlp; kwargs...) where {solver_name}
+function minimize(::Val{solver_name}, nlp; kwargs...) where {solver_name}
   solver = optimizers[optimizers.name .== string(solver_name), :]
   if !is_available(solver_name)
     throw_error_solve(solver_name)