Add an attribute jump_variables in the model

Author: amontoison

docs/src/tutorial.md

@@ -23,15 +23,15 @@ Let's define the famous Rosenbrock function
 ```math
 f(x) = (x_1 - 1)^2 + 100(x_2 - x_1^2)^2,
 ```
-with starting point ``x^0 = (-1.2,1.0)``.
+with starting point ``x_0 = (-1.2, 1.0)``.
 
 ```@example jumpnlp
 using NLPModels, NLPModelsJuMP, JuMP
 
 x0 = [-1.2; 1.0]
 model = Model() # No solver is required
 @variable(model, x[i=1:2], start=x0[i])
-@NLobjective(model, Min, (x[1] - 1)^2 + 100 * (x[2] - x[1]^2)^2)
+@objective(model, Min, (x[1] - 1)^2 + 100 * (x[2] - x[1]^2)^2)
 
 nlp = MathOptNLPModel(model)
 ```
@@ -148,9 +148,9 @@ using NLPModels, NLPModelsJuMP, JuMP
 model = Model()
 x0 = [-1.2; 1.0]
 @variable(model, x[i=1:2] >= 0.0, start=x0[i])
-@NLobjective(model, Min, (x[1] - 1)^2 + 100 * (x[2] - x[1]^2)^2)
+@objective(model, Min, (x[1] - 1)^2 + 100 * (x[2] - x[1]^2)^2)
 @constraint(model, x[1] + x[2] == 3.0)
-@NLconstraint(model, x[1] * x[2] >= 1.0)
+@constraint(model, x[1] * x[2] >= 1.0)
 
 nlp = MathOptNLPModel(model)
 
@@ -184,7 +184,7 @@ using NLPModels, NLPModelsJuMP, JuMP
 model = Model()
 x0 = [-1.2; 1.0]
 @variable(model, x[i=1:2], start=x0[i])
-@NLexpression(model, F1, x[1] - 1)
+@expression(model, F1, x[1] - 1)
 @NLexpression(model, F2, 10 * (x[2] - x[1]^2))
 
 nls = MathOptNLSModel(model, [F1, F2], name="rosen-nls")

src/moi_nlp_model.jl

@@ -3,6 +3,7 @@ export MathOptNLPModel
 mutable struct MathOptNLPModel <: AbstractNLPModel{Float64, Vector{Float64}}
   meta::NLPModelMeta{Float64, Vector{Float64}}
   eval::MOI.Nonlinear.Evaluator
+  jump_variables::Dict{String,Int}
   lincon::LinearConstraints
   quadcon::QuadraticConstraints
   nlcon::NonLinearStructure
@@ -26,13 +27,12 @@ function MathOptNLPModel(jmodel::JuMP.Model; kws...)
 end
 
 function MathOptNLPModel(moimodel::MOI.ModelLike; kws...)
-  return nlp_model(moimodel; kws...)[1]
+  return nlp_model(moimodel; kws...)
 end
 
 function nlp_model(moimodel::MOI.ModelLike; hessian::Bool = true, name::String = "Generic")
-  index_map, nvar, lvar, uvar, x0 = parser_variables(moimodel)
-  nlin, lincon, lin_lcon, lin_ucon, quadcon, quad_lcon, quad_ucon =
-    parser_MOI(moimodel, index_map, nvar)
+  jump_variables, variables, nvar, lvar, uvar, x0 = parser_variables(moimodel)
+  nlin, lincon, lin_lcon, lin_ucon, quadcon, quad_lcon, quad_ucon = parser_MOI(moimodel, variables)
 
   nlp_data = _nlp_block(moimodel)
   nlcon = parser_NL(nlp_data, hessian = hessian)
@@ -44,7 +44,7 @@ function nlp_model(moimodel::MOI.ModelLike; hessian::Bool = true, name::String =
   if nlp_data.has_objective
     obj = Objective("NONLINEAR", 0.0, spzeros(Float64, nvar), COO(), 0)
   else
-    obj = parser_objective_MOI(moimodel, nvar, index_map)
+    obj = parser_objective_MOI(moimodel, variables)
   end
 
   # Total counts
@@ -77,6 +77,7 @@ function nlp_model(moimodel::MOI.ModelLike; hessian::Bool = true, name::String =
   return MathOptNLPModel(
     meta,
     nlp_data.evaluator,
+    jump_variables,
     lincon,
     quadcon,
     nlcon,
@@ -85,8 +86,7 @@ function nlp_model(moimodel::MOI.ModelLike; hessian::Bool = true, name::String =
     hv,
     obj,
     counters,
-  ),
-  index_map
+  )
 end
 
 function NLPModels.obj(nlp::MathOptNLPModel, x::AbstractVector)

src/moi_nls_model.jl

@@ -5,6 +5,7 @@ mutable struct MathOptNLSModel <: AbstractNLSModel{Float64, Vector{Float64}}
   nls_meta::NLSMeta{Float64, Vector{Float64}}
   Feval::MOI.Nonlinear.Evaluator
   ceval::MOI.Nonlinear.Evaluator
+  jump_variables::Dict{String,Int}
   lls::Objective
   linequ::LinearEquations
   nlequ::NonLinearStructure
@@ -26,15 +27,14 @@ Construct a `MathOptNLSModel` from a `JuMP` model and a container of JuMP
 """
 function MathOptNLSModel(cmodel::JuMP.Model, F; hessian::Bool = true, name::String = "Generic")
   moimodel = backend(cmodel)
-  index_map, nvar, lvar, uvar, x0 = parser_variables(moimodel)
+  jump_variables, variables, nvar, lvar, uvar, x0 = parser_variables(moimodel)
 
-  lls, linequ, nlinequ = parser_linear_expression(cmodel, nvar, index_map, F)
-  Feval, nlequ, nnlnequ = parser_nonlinear_expression(cmodel, nvar, F, hessian = hessian)
+  lls, linequ, nlinequ = parser_linear_expression(cmodel, variables, F)
+  Feval, nlequ, nnlnequ = parser_nonlinear_expression(cmodel, variables, F, hessian = hessian)
 
   _nlp_sync!(cmodel)
   moimodel = backend(cmodel)
-  nlin, lincon, lin_lcon, lin_ucon, quadcon, quad_lcon, quad_ucon =
-    parser_MOI(moimodel, index_map, nvar)
+  nlin, lincon, lin_lcon, lin_ucon, quadcon, quad_lcon, quad_ucon = parser_MOI(moimodel, variables)
 
   nlp_data = _nlp_block(moimodel)
   nlcon = parser_NL(nlp_data, hessian = hessian)
@@ -80,6 +80,7 @@ function MathOptNLSModel(cmodel::JuMP.Model, F; hessian::Bool = true, name::Stri
     nls_meta,
     Feval,
     nlp_data.evaluator,
+    jump_variables,
     lls,
     linequ,
     nlequ,

src/utils.jl

@@ -252,13 +252,13 @@ function coo_sym_dot(
 end
 
 """
-    parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon, index_map)
+    parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon)
 
 Parse a `ScalarAffineFunction` fun with its associated set.
 `linrows`, `lincols`, `linvals`, `lin_lcon` and `lin_ucon` are updated.
 """
-function parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon, index_map)
-  _index(v::MOI.VariableIndex) = index_map[v].value
+function parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon)
+  _index(v::MOI.VariableIndex) = v.value
 
   # Parse a ScalarAffineTerm{Float64}(coefficient, variable)
   for term in fun.terms
@@ -285,13 +285,13 @@ function parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_uco
 end
 
 """
-    parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon, index_map)
+    parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon)
 
 Parse a `VectorAffineFunction` fun with its associated set.
 `linrows`, `lincols`, `linvals`, `lin_lcon` and `lin_ucon` are updated.
 """
-function parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon, index_map)
-  _index(v::MOI.VariableIndex) = index_map[v].value
+function parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon)
+  _index(v::MOI.VariableIndex) = v.value
 
   # Parse a VectorAffineTerm{Float64}(output_index, scalar_term)
   for term in fun.terms
@@ -314,13 +314,13 @@ function parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_uco
 end
 
 """
-    parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
+    parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon)
 
 Parse a `ScalarQuadraticFunction` fun with its associated set.
 `qcons`, `quad_lcon`, `quad_ucon` are updated.
 """
-function parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
-  _index(v::MOI.VariableIndex) = index_map[v].value
+function parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon)
+  _index(v::MOI.VariableIndex) = v.value
 
   b = spzeros(Float64, nvar)
   rows = Int[]
@@ -376,13 +376,13 @@ function parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
 end
 
 """
-    parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
+    parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon)
 
 Parse a `VectorQuadraticFunction` fun with its associated set.
 `qcons`, `quad_lcon`, `quad_ucon` are updated.
 """
-function parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
-  _index(v::MOI.VariableIndex) = index_map[v].value
+function parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon)
+  _index(v::MOI.VariableIndex) = v.value
 
   ncon = length(fun.constants)
   for k = 1:ncon
@@ -443,11 +443,14 @@ function parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
 end
 
 """
-    parser_MOI(moimodel, index_map, nvar)
+    parser_MOI(moimodel, variables)
 
 Parse linear constraints of a `MOI.ModelLike`.
 """
-function parser_MOI(moimodel, index_map, nvar)
+function parser_MOI(moimodel, variables)
+
+  # Number of variables
+  nvar = length(variables)
 
   # Variables associated to linear constraints
   nlin = 0
@@ -475,30 +478,25 @@ function parser_MOI(moimodel, index_map, nvar)
     F <: AF || F <: QF || F == SNF || F == VI || error("Function $F is not supported.")
     S <: LS || error("Set $S is not supported.")
 
+    (F == VI) && continue
     conindices = MOI.get(moimodel, MOI.ListOfConstraintIndices{F, S}())
     for cidx in conindices
       fun = MOI.get(moimodel, MOI.ConstraintFunction(), cidx)
-      if F == VI
-        index_map[cidx] = MOI.ConstraintIndex{F, S}(fun.value)
-        continue
-      else
-        index_map[cidx] = MOI.ConstraintIndex{F, S}(nlin)
-      end
       set = MOI.get(moimodel, MOI.ConstraintSet(), cidx)
       if typeof(fun) <: SAF
-        parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon, index_map)
+        parser_SAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon)
         nlin += 1
       end
       if typeof(fun) <: VAF
-        parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon, index_map)
+        parser_VAF(fun, set, linrows, lincols, linvals, nlin, lin_lcon, lin_ucon)
         nlin += set.dimension
       end
       if typeof(fun) <: SQF
-        parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
+        parser_SQF(fun, set, nvar, qcons, quad_lcon, quad_ucon)
         nquad += 1
       end
       if typeof(fun) <: VQF
-        parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon, index_map)
+        parser_VQF(fun, set, nvar, qcons, quad_lcon, quad_ucon)
         nquad += set.dimension
       end
     end
@@ -633,7 +631,7 @@ function parser_oracles(moimodel)
     MOI.ListOfConstraintIndices{MOI.VectorOfVariables, MOI.VectorNonlinearOracle{Float64}}(),
   )
     f = MOI.get(moimodel, MOI.ConstraintFunction(), ci)  # ::MOI.VectorOfVariables
-    set = MOI.get(moimodel, MOI.ConstraintSet(), ci)       # ::MOI.VectorNonlinearOracle{Float64}
+    set = MOI.get(moimodel, MOI.ConstraintSet(), ci)     # ::MOI.VectorNonlinearOracle{Float64}
 
     cache = _VectorNonlinearOracleCache(set)
     push!(oracles, (f, cache))
@@ -668,20 +666,23 @@ Parse variables informations of a `MOI.ModelLike`.
 """
 function parser_variables(model::MOI.ModelLike)
   # Number of variables and bounds constraints
-  vars = MOI.get(model, MOI.ListOfVariableIndices())
-  nvar = length(vars)
+  variables = MOI.get(model, MOI.ListOfVariableIndices())
+  nvar = length(variables)
   lvar = zeros(nvar)
   uvar = zeros(nvar)
+
   # Initial solution
   x0 = zeros(nvar)
   has_start = MOI.VariablePrimalStart() in MOI.get(model, MOI.ListOfVariableAttributesSet())
 
-  index_map = MOI.Utilities.IndexMap()
-  for (i, vi) in enumerate(vars)
-    index_map[vi] = MOI.VariableIndex(i)
-  end
+  jump_variables = Dict{String,Int}()
+  sizehint!(jump_variables, nvar)
+
+  for vi in variables
+    i = vi.value
+    name = MOI.get(model, MOI.VariableName(), vi)
+    jump_variables[name] = i
 
-  for (i, vi) in enumerate(vars)
     lvar[i], uvar[i] = MOI.Utilities.get_bounds(model, Float64, vi)
     if has_start
       val = MOI.get(model, MOI.VariablePrimalStart(), vi)
@@ -691,16 +692,19 @@ function parser_variables(model::MOI.ModelLike)
     end
   end
 
-  return index_map, nvar, lvar, uvar, x0
+  return jump_variables, variables, nvar, lvar, uvar, x0
 end
 
 """
-    parser_objective_MOI(moimodel, nvar, index_map)
+    parser_objective_MOI(moimodel, variables)
 
 Parse linear and quadratic objective of a `MOI.ModelLike`.
 """
-function parser_objective_MOI(moimodel, nvar, index_map)
-  _index(v::MOI.VariableIndex) = index_map[v].value
+function parser_objective_MOI(moimodel, variables)
+  _index(v::MOI.VariableIndex) = v.value
+
+  # Number of variables
+  nvar = length(variables)
 
   # Variables associated to linear and quadratic objective
   type = "UNKNOWN"
@@ -751,11 +755,14 @@ function parser_objective_MOI(moimodel, nvar, index_map)
 end
 
 """
-    parser_linear_expression(cmodel, nvar, index_map, F)
+    parser_linear_expression(cmodel, variables, F)
 
 Parse linear expressions of type `VariableRef` and `GenericAffExpr{Float64,VariableRef}`.
 """
-function parser_linear_expression(cmodel, nvar, index_map, F)
+function parser_linear_expression(cmodel, variables, F)
+
+  # Number of variables
+  nvar = length(variables)
 
   # Variables associated to linear expressions
   rows = Int[]
@@ -810,7 +817,7 @@ function parser_linear_expression(cmodel, nvar, index_map, F)
     end
   end
   moimodel = backend(cmodel)
-  lls = parser_objective_MOI(moimodel, nvar, index_map)
+  lls = parser_objective_MOI(moimodel, variables)
   return lls, LinearEquations(COO(rows, cols, vals), constants, length(vals)), nlinequ
 end
 
@@ -844,11 +851,14 @@ function add_constraint_model(Fmodel, Fi::AbstractArray)
 end
 
 """
-    parser_nonlinear_expression(cmodel, nvar, F; hessian)
+    parser_nonlinear_expression(cmodel, variables, F; hessian)
 
 Parse nonlinear expressions of type `NonlinearExpression`.
 """
-function parser_nonlinear_expression(cmodel, nvar, F; hessian::Bool = true)
+function parser_nonlinear_expression(cmodel, variables, F; hessian::Bool = true)
+
+  # Number of variables
+  nvar = length(variables)
 
   # Nonlinear least squares model
   F_is_array_of_containers = F isa Array{<:AbstractArray}