Add missing functionalities and fix bugs

Author: Clara Witte

pyomo/contrib/appsi/solvers/maingo.py

@@ -120,6 +120,7 @@ def __init__(self, solver):
         super(MAiNGOResults, self).__init__()
         self.wallclock_time = None
         self.cpu_time = None
+        self.globally_optimal = None
         self.solution_loader = MAiNGOSolutionLoader(solver=solver)
 
 
@@ -228,9 +229,14 @@ def solve(self, model, timer: HierarchicalTimer = None):
             self._last_results_object.solution_loader.invalidate()
         if timer is None:
             timer = HierarchicalTimer()
-        timer.start("set_instance")
-        self.set_instance(model)
-        timer.stop("set_instance")
+        if model is not self._model:
+            timer.start("set_instance")
+            self.set_instance(model)
+            timer.stop("set_instance")
+        else:
+            timer.start("Update")
+            self.update(timer=timer)
+            timer.stop("Update")
         res = self._solve(timer)
         self._last_results_object = res
         if self.config.report_timing:
@@ -285,7 +291,7 @@ def _process_domain_and_bounds(self, var):
         return lb, ub, vtype
 
     def _add_variables(self, variables: List[_GeneralVarData]):
-        for ndx, var in enumerate(variables):
+        for var in variables:
             varname = self._symbol_map.getSymbol(var, self._labeler)
             lb, ub, vtype = self._process_domain_and_bounds(var)
             self._maingo_vars.append(
@@ -331,10 +337,11 @@ def set_instance(self, model):
             con_list=self._cons,
             objective=self._objective,
             idmap=self._pyomo_var_to_solver_var_id_map,
+            logger=logger,
         )
 
     def _add_constraints(self, cons: List[_GeneralConstraintData]):
-        self._cons = cons
+        self._cons += cons
 
     def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
         if len(cons) >= 1:
@@ -344,7 +351,8 @@ def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
         pass
 
     def _remove_constraints(self, cons: List[_GeneralConstraintData]):
-        pass
+        for con in cons:
+            self._cons.remove(con)
 
     def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
         if len(cons) >= 1:
@@ -354,28 +362,48 @@ def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
         pass
 
     def _remove_variables(self, variables: List[_GeneralVarData]):
-        pass
+        removed_maingo_vars = []
+        for var in variables:
+            varname = self._symbol_map.getSymbol(var, self._labeler)
+            del self._maingo_vars[self._pyomo_var_to_solver_var_id_map[id(var)]]
+            removed_maingo_vars += [self._pyomo_var_to_solver_var_id_map[id(var)]]
+            del self._pyomo_var_to_solver_var_id_map[id(var)]
+
+        for pyomo_var, maingo_var_id in self._pyomo_var_to_solver_var_id_map.items():
+            # How many variables before current var where removed?
+            num_removed = 0
+            for removed_var in removed_maingo_vars:
+                if removed_var <= maingo_var_id:
+                    num_removed += 1
+            self._pyomo_var_to_solver_var_id_map[pyomo_var] = (
+                maingo_var_id - num_removed
+            )
 
     def _remove_params(self, params: List[_ParamData]):
         pass
 
     def _update_variables(self, variables: List[_GeneralVarData]):
-        pass
+        for var in variables:
+            if id(var) not in self._pyomo_var_to_solver_var_id_map:
+                raise ValueError(
+                    'The Var provided to update_var needs to be added first: {0}'.format(
+                        var
+                    )
+                )
+            lb, ub, vtype = self._process_domain_and_bounds(var)
+            self._maingo_vars[self._pyomo_var_to_solver_var_id_map[id(var)]] = (
+                MaingoVar(name=var.name, type=vtype, lb=lb, ub=ub, init=var.value)
+            )
 
     def update_params(self):
-        pass
+        vars = [var[0] for var in self._vars.values()]
+        self._update_variables(vars)
 
     def _set_objective(self, obj):
-        if obj is None:
-            raise NotImplementedError(
-                "MAiNGO needs a objective. Please set a dummy objective."
-            )
-        else:
-            if not obj.sense in {minimize, maximize}:
-                raise ValueError(
-                    "Objective sense is not recognized: {0}".format(obj.sense)
-                )
-            self._objective = obj
+
+        if not obj.sense in {minimize, maximize}:
+            raise ValueError("Objective sense is not recognized: {0}".format(obj.sense))
+        self._objective = obj
 
     def _postsolve(self, timer: HierarchicalTimer):
         config = self.config
@@ -388,7 +416,9 @@ def _postsolve(self, timer: HierarchicalTimer):
 
         if status in {maingopy.GLOBALLY_OPTIMAL, maingopy.FEASIBLE_POINT}:
             results.termination_condition = TerminationCondition.optimal
+            results.globally_optimal = True
             if status == maingopy.FEASIBLE_POINT:
+                results.globally_optimal = False
                 logger.warning(
                     "MAiNGO did only find a feasible solution but did not prove its global optimality."
                 )
@@ -425,8 +455,8 @@ def _postsolve(self, timer: HierarchicalTimer):
 
         timer.start("load solution")
         if config.load_solution:
-            if not results.best_feasible_objective is None:
-                if results.termination_condition != TerminationCondition.optimal:
+            if results.termination_condition is TerminationCondition.optimal:
+                if not results.globally_optimal:
                     logger.warning(
                         "Loading a feasible but suboptimal solution. "
                         "Please set load_solution=False and check "
@@ -487,6 +517,15 @@ def get_reduced_costs(self, vars_to_load=None):
     def get_duals(self, cons_to_load=None):
         raise ValueError("MAiNGO does not support returning Duals")
 
+    def update(self, timer: HierarchicalTimer = None):
+        super(MAiNGO, self).update(timer=timer)
+        self._solver_model = maingo_solvermodel.SolverModel(
+            var_list=self._maingo_vars,
+            con_list=self._cons,
+            objective=self._objective,
+            idmap=self._pyomo_var_to_solver_var_id_map,
+            logger=logger,
+        )
 
     def _set_maingo_options(self):
         pass

pyomo/contrib/appsi/solvers/maingo_solvermodel.py

@@ -13,6 +13,7 @@
 
 from pyomo.common.dependencies import attempt_import
 from pyomo.core.base.var import ScalarVar
+from pyomo.core.base.expression import ScalarExpression
 import pyomo.core.expr.expr_common as common
 import pyomo.core.expr as EXPR
 from pyomo.core.expr.numvalue import (
@@ -178,50 +179,66 @@ def visiting_potential_leaf(self, node):
             return True, maingo_var
 
     def _monomial_to_maingo(self, node):
-        if node.__class__ is ScalarVar:
-            var = node
-            const = 1
-        else:
-            const, var = node.args
-        maingo_var_id = self.idmap[id(var)]
-        maingo_var = self.variables[maingo_var_id]
+        const, var = node.args
         if const.__class__ not in native_types:
             const = value(const)
         if var.is_fixed():
             return const * var.value
         if not const:
             return 0
+        maingo_var = self._var_to_maingo(var)
         if const in _plusMinusOne:
             if const < 0:
                 return -maingo_var
             else:
                 return maingo_var
         return const * maingo_var
 
+    def _var_to_maingo(self, var):
+        maingo_var_id = self.idmap[id(var)]
+        maingo_var = self.variables[maingo_var_id]
+        return maingo_var
+
     def _linear_to_maingo(self, node):
         values = [
             (
                 self._monomial_to_maingo(arg)
-                if (arg.__class__ in {EXPR.MonomialTermExpression, ScalarVar})
-                else (value(arg))
+                if (arg.__class__ is EXPR.MonomialTermExpression)
+                else (
+                    value(arg)
+                    if arg.__class__ in native_numeric_types
+                    else (
+                        self._var_to_maingo(arg)
+                        if arg.is_variable_type()
+                        else value(arg)
+                    )
+                )
             )
             for arg in node.args
         ]
         return sum(values)
 
 
 class SolverModel(maingopy.MAiNGOmodel):
-    def __init__(self, var_list, objective, con_list, idmap):
+    def __init__(self, var_list, objective, con_list, idmap, logger):
         maingopy.MAiNGOmodel.__init__(self)
         self._var_list = var_list
         self._con_list = con_list
         self._objective = objective
         self._idmap = idmap
+        self._logger = logger
+        self._no_objective = False
+
+        if self._objective is None:
+            self._logger.warning("No objective given, setting a dummy objective of 1.")
+            self._no_objective = True
 
     def build_maingo_objective(self, obj, visitor):
+        if self._no_objective:
+            return visitor.variables[-1]
         maingo_obj = visitor.dfs_postorder_stack(obj.expr)
         if obj.sense == maximize:
-            maingo_obj *= -1
+            return -1 * maingo_obj
         return maingo_obj
 
     def build_maingo_constraints(self, cons, visitor):
@@ -235,7 +252,7 @@ def build_maingo_constraints(self, cons, visitor):
                 ineqs += [visitor.dfs_postorder_stack(con.lower - con.body)]
             elif con.has_ub():
                 ineqs += [visitor.dfs_postorder_stack(con.body - con.upper)]
-            elif con.has_ub():
+            elif con.has_lb():
                 ineqs += [visitor.dfs_postorder_stack(con.lower - con.body)]
             else:
                 raise ValueError(
@@ -245,18 +262,24 @@ def build_maingo_constraints(self, cons, visitor):
         return eqs, ineqs
 
     def get_variables(self):
-        return [
+        vars = [
             maingopy.OptimizationVariable(
                 maingopy.Bounds(var.lb, var.ub), var.type, var.name
             )
             for var in self._var_list
         ]
+        if self._no_objective:
+            vars += [maingopy.OptimizationVariable(maingopy.Bounds(1, 1), "dummy_obj")]
+        return vars
 
     def get_initial_point(self):
-        return [
+        initial = [
             var.init if not var.init is None else (var.lb + var.ub) / 2.0
             for var in self._var_list
         ]
+        if self._no_objective:
+            initial += [1]
+        return initial
 
     def evaluate(self, maingo_vars):
         visitor = ToMAiNGOVisitor(maingo_vars, self._idmap)