Sort methods

miplearn/solvers/pyomo/base.py

@@ -70,35 +70,212 @@ class BasePyomoSolver(InternalSolver):
             self._pyomo_solver.options[key] = value
 
     @overrides
-    def solve_lp(
+    def add_constraint(
         self,
-        tee: bool = False,
-    ) -> LPSolveStats:
-        self.relax()
-        streams: List[Any] = [StringIO()]
-        if tee:
-            streams += [sys.stdout]
-        with _RedirectOutput(streams):
-            results = self._pyomo_solver.solve(tee=True)
-        self._termination_condition = results["Solver"][0]["Termination condition"]
-        self._restore_integrality()
-        opt_value = None
+        constr: Any,
+        name: str,
+    ) -> None:
+        assert self.model is not None
+        if isinstance(constr, Constraint):
+            lhs = 0.0
+            for (varname, coeff) in constr.lhs.items():
+                var = self._varname_to_var[varname]
+                lhs += var * coeff
+            if constr.sense == "=":
+                expr = lhs == constr.rhs
+            elif constr.sense == "<":
+                expr = lhs <= constr.rhs
+            else:
+                expr = lhs >= constr.rhs
+            cl = pe.Constraint(expr=expr, name=name)
+            self.model.add_component(name, cl)
+            self._pyomo_solver.add_constraint(cl)
+            self._cname_to_constr[name] = cl
+        else:
+            self._pyomo_solver.add_constraint(constr)
+        self._termination_condition = ""
         self._has_lp_solution = False
         self._has_mip_solution = False
-        if not self.is_infeasible():
-            opt_value = results["Problem"][0]["Lower bound"]
-            self._has_lp_solution = True
-        return LPSolveStats(
-            lp_value=opt_value,
-            lp_log=streams[0].getvalue(),
-            lp_wallclock_time=results["Solver"][0]["Wallclock time"],
+
+    @overrides
+    def are_callbacks_supported(self) -> bool:
+        return False
+
+    @overrides
+    def build_test_instance_infeasible(self) -> Instance:
+        return PyomoTestInstanceInfeasible()
+
+    @overrides
+    def build_test_instance_redundancy(self) -> Instance:
+        return PyomoTestInstanceRedundancy()
+
+    @overrides
+    def build_test_instance_knapsack(self) -> Instance:
+        return PyomoTestInstanceKnapsack(
+            weights=[23.0, 26.0, 20.0, 18.0],
+            prices=[505.0, 352.0, 458.0, 220.0],
+            capacity=67.0,
         )
 
-    def _restore_integrality(self) -> None:
-        for var in self._bin_vars:
-            var.domain = pyomo.core.base.set_types.Binary
+    @overrides
+    def fix(self, solution: Solution) -> None:
+        for (varname, value) in solution.items():
+            if value is None:
+                continue
+            var = self._varname_to_var[varname]
+            var.fix(value)
             self._pyomo_solver.update_var(var)
 
+    @overrides
+    def get_constraints(self) -> Dict[str, Constraint]:
+        assert self.model is not None
+
+        constraints = {}
+        for constr in self.model.component_objects(pyomo.core.Constraint):
+            if isinstance(constr, pe.ConstraintList):
+                for idx in constr:
+                    name = f"{constr.name}[{idx}]"
+                    assert name not in constraints
+                    constraints[name] = self._parse_pyomo_constraint(constr[idx])
+            else:
+                name = constr.name
+                assert name not in constraints
+                constraints[name] = self._parse_pyomo_constraint(constr)
+
+        return constraints
+
+    @overrides
+    def get_constraint_attrs(self) -> List[str]:
+        return [
+            "dual_value",
+            "lazy",
+            "lhs",
+            "rhs",
+            "sense",
+            "slack",
+        ]
+
+    @overrides
+    def get_dual(self, cid: str) -> float:
+        constr = self._cname_to_constr[cid]
+        return self._pyomo_solver.dual[constr]
+
+    @overrides
+    def get_solution(self) -> Optional[Solution]:
+        assert self.model is not None
+        if self.is_infeasible():
+            return None
+        solution: Solution = {}
+        for var in self.model.component_objects(Var):
+            for index in var:
+                if var[index].fixed:
+                    continue
+                solution[f"{var}[{index}]"] = var[index].value
+        return solution
+
+    @overrides
+    def get_variable_names(self) -> List[VariableName]:
+        assert self.model is not None
+        variables: List[VariableName] = []
+        for var in self.model.component_objects(Var):
+            for index in var:
+                if var[index].fixed:
+                    continue
+                variables += [f"{var}[{index}]"]
+        return variables
+
+    @overrides
+    def get_sense(self) -> str:
+        return self._obj_sense
+
+    @overrides
+    def get_variables(self) -> Dict[str, Variable]:
+        assert self.model is not None
+        variables = {}
+        for var in self.model.component_objects(pyomo.core.Var):
+            for idx in var:
+                varname = f"{var}[{idx}]"
+                if idx is None:
+                    varname = str(var)
+                variables[varname] = self._parse_pyomo_variable(var[idx])
+        return variables
+
+    @overrides
+    def get_variable_attrs(self) -> List[str]:
+        return [
+            # "basis_status",
+            "lower_bound",
+            "obj_coeff",
+            "reduced_cost",
+            # "sa_lb_down",
+            # "sa_lb_up",
+            # "sa_obj_down",
+            # "sa_obj_up",
+            # "sa_ub_down",
+            # "sa_ub_up",
+            "type",
+            "upper_bound",
+            "value",
+        ]
+
+    @overrides
+    def is_constraint_satisfied(self, constr: Constraint, tol: float = 1e-6) -> bool:
+        lhs = 0.0
+        for (varname, coeff) in constr.lhs.items():
+            var = self._varname_to_var[varname]
+            lhs += var.value * coeff
+        if constr.sense == "<":
+            return lhs <= constr.rhs + tol
+        elif constr.sense == ">":
+            return lhs >= constr.rhs - tol
+        else:
+            return abs(constr.rhs - lhs) < abs(tol)
+
+    @overrides
+    def is_infeasible(self) -> bool:
+        return self._termination_condition == TerminationCondition.infeasible
+
+    @overrides
+    def remove_constraint(self, name: str) -> None:
+        assert self.model is not None
+        constr = self._cname_to_constr[name]
+        del self._cname_to_constr[name]
+        self.model.del_component(constr)
+        self._pyomo_solver.remove_constraint(constr)
+
+    @overrides
+    def set_instance(
+        self,
+        instance: Instance,
+        model: Any = None,
+    ) -> None:
+        if model is None:
+            model = instance.to_model()
+        assert isinstance(model, pe.ConcreteModel)
+        self.instance = instance
+        self.model = model
+        self.model.extra_constraints = ConstraintList()
+        self.model.dual = Suffix(direction=Suffix.IMPORT)
+        self.model.rc = Suffix(direction=Suffix.IMPORT)
+        self.model.slack = Suffix(direction=Suffix.IMPORT)
+        self._pyomo_solver.set_instance(model)
+        self._update_obj()
+        self._update_vars()
+        self._update_constrs()
+
+    @overrides
+    def set_warm_start(self, solution: Solution) -> None:
+        self._clear_warm_start()
+        count_fixed = 0
+        for (var_name, value) in solution.items():
+            if value is None:
+                continue
+            var = self._varname_to_var[var_name]
+            var.value = solution[var_name]
+            count_fixed += 1
+        if count_fixed > 0:
+            self._is_warm_start_available = True
+
     @overrides
     def solve(
         self,
@@ -148,61 +325,38 @@ class BasePyomoSolver(InternalSolver):
         )
 
     @overrides
-    def get_solution(self) -> Optional[Solution]:
-        assert self.model is not None
-        if self.is_infeasible():
-            return None
-        solution: Solution = {}
-        for var in self.model.component_objects(Var):
-            for index in var:
-                if var[index].fixed:
-                    continue
-                solution[f"{var}[{index}]"] = var[index].value
-        return solution
-
-    @overrides
-    def get_variable_names(self) -> List[VariableName]:
-        assert self.model is not None
-        variables: List[VariableName] = []
-        for var in self.model.component_objects(Var):
-            for index in var:
-                if var[index].fixed:
-                    continue
-                variables += [f"{var}[{index}]"]
-        return variables
-
-    @overrides
-    def set_warm_start(self, solution: Solution) -> None:
-        self._clear_warm_start()
-        count_fixed = 0
-        for (var_name, value) in solution.items():
-            if value is None:
-                continue
-            var = self._varname_to_var[var_name]
-            var.value = solution[var_name]
-            count_fixed += 1
-        if count_fixed > 0:
-            self._is_warm_start_available = True
-
-    @overrides
-    def set_instance(
+    def solve_lp(
         self,
-        instance: Instance,
-        model: Any = None,
-    ) -> None:
-        if model is None:
-            model = instance.to_model()
-        assert isinstance(model, pe.ConcreteModel)
-        self.instance = instance
-        self.model = model
-        self.model.extra_constraints = ConstraintList()
-        self.model.dual = Suffix(direction=Suffix.IMPORT)
-        self.model.rc = Suffix(direction=Suffix.IMPORT)
-        self.model.slack = Suffix(direction=Suffix.IMPORT)
-        self._pyomo_solver.set_instance(model)
-        self._update_obj()
-        self._update_vars()
-        self._update_constrs()
+        tee: bool = False,
+    ) -> LPSolveStats:
+        self.relax()
+        streams: List[Any] = [StringIO()]
+        if tee:
+            streams += [sys.stdout]
+        with _RedirectOutput(streams):
+            results = self._pyomo_solver.solve(tee=True)
+        self._termination_condition = results["Solver"][0]["Termination condition"]
+        self._restore_integrality()
+        opt_value = None
+        self._has_lp_solution = False
+        self._has_mip_solution = False
+        if not self.is_infeasible():
+            opt_value = results["Problem"][0]["Lower bound"]
+            self._has_lp_solution = True
+        return LPSolveStats(
+            lp_value=opt_value,
+            lp_log=streams[0].getvalue(),
+            lp_wallclock_time=results["Solver"][0]["Wallclock time"],
+        )
+
+    @overrides
+    def relax(self) -> None:
+        for var in self._bin_vars:
+            lb, ub = var.bounds
+            var.setlb(lb)
+            var.setub(ub)
+            var.domain = pyomo.core.base.set_types.Reals
+            self._pyomo_solver.update_var(var)
 
     def _clear_warm_start(self) -> None:
         for var in self._all_vars:
@@ -210,96 +364,8 @@ class BasePyomoSolver(InternalSolver):
                 var.value = None
         self._is_warm_start_available = False
 
-    def _update_obj(self) -> None:
-        self._obj_sense = "max"
-        if self._pyomo_solver._objective.sense == pyomo.core.kernel.objective.minimize:
-            self._obj_sense = "min"
-
-    def _update_vars(self) -> None:
-        assert self.model is not None
-        self._all_vars = []
-        self._bin_vars = []
-        self._varname_to_var = {}
-        for var in self.model.component_objects(Var):
-            for idx in var:
-                self._varname_to_var[f"{var.name}[{idx}]"] = var[idx]
-                self._all_vars += [var[idx]]
-                if var[idx].domain == pyomo.core.base.set_types.Binary:
-                    self._bin_vars += [var[idx]]
-        for obj in self.model.component_objects(Objective):
-            self._obj = self._parse_pyomo_expr(obj.expr)
-            break
-
-    def _update_constrs(self) -> None:
-        assert self.model is not None
-        self._cname_to_constr.clear()
-        for constr in self.model.component_objects(pyomo.core.Constraint):
-            if isinstance(constr, pe.ConstraintList):
-                for idx in constr:
-                    self._cname_to_constr[f"{constr.name}[{idx}]"] = constr[idx]
-            else:
-                self._cname_to_constr[constr.name] = constr
-
-    @overrides
-    def fix(self, solution: Solution) -> None:
-        for (varname, value) in solution.items():
-            if value is None:
-                continue
-            var = self._varname_to_var[varname]
-            var.fix(value)
-            self._pyomo_solver.update_var(var)
-
-    @overrides
-    def add_constraint(
-        self,
-        constr: Any,
-        name: str,
-    ) -> None:
-        assert self.model is not None
-        if isinstance(constr, Constraint):
-            lhs = 0.0
-            for (varname, coeff) in constr.lhs.items():
-                var = self._varname_to_var[varname]
-                lhs += var * coeff
-            if constr.sense == "=":
-                expr = lhs == constr.rhs
-            elif constr.sense == "<":
-                expr = lhs <= constr.rhs
-            else:
-                expr = lhs >= constr.rhs
-            cl = pe.Constraint(expr=expr, name=name)
-            self.model.add_component(name, cl)
-            self._pyomo_solver.add_constraint(cl)
-            self._cname_to_constr[name] = cl
-        else:
-            self._pyomo_solver.add_constraint(constr)
-        self._termination_condition = ""
-        self._has_lp_solution = False
-        self._has_mip_solution = False
-
-    @overrides
-    def remove_constraint(self, name: str) -> None:
-        assert self.model is not None
-        constr = self._cname_to_constr[name]
-        del self._cname_to_constr[name]
-        self.model.del_component(constr)
-        self._pyomo_solver.remove_constraint(constr)
-
-    @overrides
-    def is_constraint_satisfied(self, constr: Constraint, tol: float = 1e-6) -> bool:
-        lhs = 0.0
-        for (varname, coeff) in constr.lhs.items():
-            var = self._varname_to_var[varname]
-            lhs += var.value * coeff
-        if constr.sense == "<":
-            return lhs <= constr.rhs + tol
-        elif constr.sense == ">":
-            return lhs >= constr.rhs - tol
-        else:
-            return abs(constr.rhs - lhs) < abs(tol)
-
     @staticmethod
-    def __extract(
+    def _extract(
         log: str,
         regexp: Optional[str],
         default: Optional[str] = None,
@@ -314,73 +380,23 @@ class BasePyomoSolver(InternalSolver):
             value = matches[0]
         return value
 
-    def _extract_warm_start_value(self, log: str) -> Optional[float]:
-        value = self.__extract(log, self._get_warm_start_regexp())
-        if value is None:
-            return None
-        return float(value)
-
     def _extract_node_count(self, log: str) -> Optional[int]:
-        value = self.__extract(log, self._get_node_count_regexp())
+        value = self._extract(log, self._get_node_count_regexp())
         if value is None:
             return None
         return int(value)
 
-    def _get_warm_start_regexp(self) -> Optional[str]:
-        return None
+    def _extract_warm_start_value(self, log: str) -> Optional[float]:
+        value = self._extract(log, self._get_warm_start_regexp())
+        if value is None:
+            return None
+        return float(value)
 
     def _get_node_count_regexp(self) -> Optional[str]:
         return None
 
-    @overrides
-    def relax(self) -> None:
-        for var in self._bin_vars:
-            lb, ub = var.bounds
-            var.setlb(lb)
-            var.setub(ub)
-            var.domain = pyomo.core.base.set_types.Reals
-            self._pyomo_solver.update_var(var)
-
-    @overrides
-    def is_infeasible(self) -> bool:
-        return self._termination_condition == TerminationCondition.infeasible
-
-    @overrides
-    def get_dual(self, cid: str) -> float:
-        constr = self._cname_to_constr[cid]
-        return self._pyomo_solver.dual[constr]
-
-    @overrides
-    def get_sense(self) -> str:
-        return self._obj_sense
-
-    @overrides
-    def build_test_instance_infeasible(self) -> Instance:
-        return PyomoTestInstanceInfeasible()
-
-    @overrides
-    def build_test_instance_redundancy(self) -> Instance:
-        return PyomoTestInstanceRedundancy()
-
-    @overrides
-    def build_test_instance_knapsack(self) -> Instance:
-        return PyomoTestInstanceKnapsack(
-            weights=[23.0, 26.0, 20.0, 18.0],
-            prices=[505.0, 352.0, 458.0, 220.0],
-            capacity=67.0,
-        )
-
-    @overrides
-    def get_variables(self) -> Dict[str, Variable]:
-        assert self.model is not None
-        variables = {}
-        for var in self.model.component_objects(pyomo.core.Var):
-            for idx in var:
-                varname = f"{var}[{idx}]"
-                if idx is None:
-                    varname = str(var)
-                variables[varname] = self._parse_pyomo_variable(var[idx])
-        return variables
+    def _get_warm_start_regexp(self) -> Optional[str]:
+        return None
 
     def _parse_pyomo_variable(self, var: pyomo.core.Var) -> Variable:
         # Variable type
@@ -420,24 +436,6 @@ class BasePyomoSolver(InternalSolver):
             reduced_cost=rc,
         )
 
-    @overrides
-    def get_constraints(self) -> Dict[str, Constraint]:
-        assert self.model is not None
-
-        constraints = {}
-        for constr in self.model.component_objects(pyomo.core.Constraint):
-            if isinstance(constr, pe.ConstraintList):
-                for idx in constr:
-                    name = f"{constr.name}[{idx}]"
-                    assert name not in constraints
-                    constraints[name] = self._parse_pyomo_constraint(constr[idx])
-            else:
-                name = constr.name
-                assert name not in constraints
-                constraints[name] = self._parse_pyomo_constraint(constr)
-
-        return constraints
-
     def _parse_pyomo_constraint(
         self,
         pyomo_constr: pyomo.core.Constraint,
@@ -490,38 +488,40 @@ class BasePyomoSolver(InternalSolver):
             raise Exception(f"Unknown expression type: {expr.__class__.__name__}")
         return lhs
 
-    @overrides
-    def are_callbacks_supported(self) -> bool:
-        return False
+    def _restore_integrality(self) -> None:
+        for var in self._bin_vars:
+            var.domain = pyomo.core.base.set_types.Binary
+            self._pyomo_solver.update_var(var)
 
-    @overrides
-    def get_constraint_attrs(self) -> List[str]:
-        return [
-            "dual_value",
-            "lazy",
-            "lhs",
-            "rhs",
-            "sense",
-            "slack",
-        ]
+    def _update_obj(self) -> None:
+        self._obj_sense = "max"
+        if self._pyomo_solver._objective.sense == pyomo.core.kernel.objective.minimize:
+            self._obj_sense = "min"
 
-    @overrides
-    def get_variable_attrs(self) -> List[str]:
-        return [
-            # "basis_status",
-            "lower_bound",
-            "obj_coeff",
-            "reduced_cost",
-            # "sa_lb_down",
-            # "sa_lb_up",
-            # "sa_obj_down",
-            # "sa_obj_up",
-            # "sa_ub_down",
-            # "sa_ub_up",
-            "type",
-            "upper_bound",
-            "value",
-        ]
+    def _update_vars(self) -> None:
+        assert self.model is not None
+        self._all_vars = []
+        self._bin_vars = []
+        self._varname_to_var = {}
+        for var in self.model.component_objects(Var):
+            for idx in var:
+                self._varname_to_var[f"{var.name}[{idx}]"] = var[idx]
+                self._all_vars += [var[idx]]
+                if var[idx].domain == pyomo.core.base.set_types.Binary:
+                    self._bin_vars += [var[idx]]
+        for obj in self.model.component_objects(Objective):
+            self._obj = self._parse_pyomo_expr(obj.expr)
+            break
+
+    def _update_constrs(self) -> None:
+        assert self.model is not None
+        self._cname_to_constr.clear()
+        for constr in self.model.component_objects(pyomo.core.Constraint):
+            if isinstance(constr, pe.ConstraintList):
+                for idx in constr:
+                    self._cname_to_constr[f"{constr.name}[{idx}]"] = constr[idx]
+            else:
+                self._cname_to_constr[constr.name] = constr
 
 
 class PyomoTestInstanceInfeasible(Instance):