def test_mip_file(solver: str, instance: str):
"""Tests optimization of MIP models stored in .mps or .lp files"""
m = Model(solver_name=solver)
# optional file for optimal LP basis
bas_file = ""
iname = ""
for ext in EXTS:
if instance.endswith(ext):
bas_file = instance.replace(ext, ".bas")
if not exists(bas_file):
bas_file = ""
iname = basename(instance.replace(ext, ""))
break
assert iname in BOUNDS.keys()
lb = BOUNDS[iname][0]
ub = BOUNDS[iname][1]
assert lb <= ub + TOL
has_opt = abs(ub - lb) <= TOL
max_dif = max(max(abs(ub), abs(lb)) * 0.01, TOL)
m.read(instance)
if bas_file:
m.verbose = True
m.read(bas_file)
m.optimize(relax=True)
print("Basis loaded!!! Obj value: %f" % m.objective_value)
m.optimize(max_nodes=MAX_NODES)
if m.status in [OptimizationStatus.OPTIMAL, OptimizationStatus.FEASIBLE]:
assert m.num_solutions >= 1
m.check_optimization_results()
assert m.objective_value >= lb - max_dif
if has_opt and m.status == OptimizationStatus.OPTIMAL:
assert abs(m.objective_value - ub) <= max_dif
elif m.status == OptimizationStatus.NO_SOLUTION_FOUND:
assert m.objective_bound <= ub + max_dif
else:
assert m.status not in [
OptimizationStatus.INFEASIBLE,
OptimizationStatus.INT_INFEASIBLE,
OptimizationStatus.UNBOUNDED,
OptimizationStatus.ERROR,
OptimizationStatus.CUTOFF,
]
assert m.objective_bound <= ub + max_dif
from mip import Model, CutType, OptimizationStatus
import mip
lp_path = ""
# using test data
lp_path = mip.__file__.replace("mip/__init__.py",
"test/data/1443_0-9.lp").replace(
"mip\\__init__.py",
"test\\data\\1443_0-9.lp")
m = Model()
if m.solver_name.upper() in ["GRB", "GUROBI"]:
print("This feature is currently not supported in Gurobi.")
else:
m.read(lp_path)
m.verbose = 0
m.optimize(relax=True)
print("Original LP bound: {}".format(m.objective_value))
best_impr = -1
best_cut = ""
for ct in CutType:
print()
m2 = m.copy()
m2.verbose = 0
m2.optimize(relax=True)
assert (m2.status == OptimizationStatus.OPTIMAL
and abs(m2.objective_value - m.objective_value) <= 1e-4)
class PythonMIPReader(FileReaderInterface):
def __init__(self, input_file: str) -> None:
self.instance_name = input_file.split("/")[-1].split(".")[0]
self.m = Model()
print("Reding lp file", self.instance_name)
self.m.read(input_file)
print("Reading of ", self.instance_name, " model done!")
self.vars = self.m.vars
self.constrs = self.m.constrs
self.tmp_reader_dir = tempfile.mkdtemp()
def __del__(self):
shutil.rmtree(self.tmp_reader_dir)
def write_model_with_new_bounds(self, lbs: List[float],
ubs: [List[float]]) -> str:
assert (len(lbs) == len(ubs) == len(self.m.vars))
for i in range(len(lbs)):
self.m.vars[i].lb = lbs[i]
self.m.vars[i].ub = ubs[i]
out_path = os.path.join(self.tmp_reader_dir,
str(self.instance_name) + ".mps")
self.m.write(out_path)
return out_path
def get_n_vars(self) -> int:
return self.m.num_cols
def get_n_cons(self) -> int:
return self.m.num_rows
def get_nnz(self) -> int:
return self.m.num_nz
def get_var_bounds(self) -> Tuple[List[float]]:
ubs = map(lambda var: var.ub, self.vars)
lbs = map(lambda var: var.lb, self.vars)
return list(lbs), list(ubs)
def get_lrhss(self) -> Tuple[List[float]]:
lhss = map(
lambda cons: float('-Inf')
if cons.expr.sense == '<' else cons.rhs, self.constrs)
rhss = map(
lambda cons: float('Inf')
if cons.expr.sense == '>' else cons.rhs, self.constrs)
return list(lhss), list(rhss)
def get_cons_matrix(self) -> Tuple[List[Union[int, float]]]:
def get_expr_coos(expr: LinExpr, var_indices: Dict[Var,
int]) -> Generator:
for var, coeff in expr.expr.items():
yield coeff, var_indices[var]
row_indices = []
row_ptrs = []
col_indices = []
coeffs = []
var_indices = {v: i for i, v in enumerate(self.vars)}
row_ctr = 0
row_ptrs.append(row_ctr)
for row_idx, constr in enumerate(self.constrs):
for coeff, col_idx in get_expr_coos(constr.expr, var_indices):
row_ctr += 1
row_indices.append(row_idx)
col_indices.append(col_idx)
coeffs.append(coeff)
row_ptrs.append(row_ctr)
return (coeffs, row_ptrs, col_indices)
def get_SCIP_vartypes(self) -> List[int]:
conversion_dict = {'B': 0, 'I': 1, 'C': 3}
python_mip_vartypes = map(lambda var: var.var_type, self.vars)
return list(map(conversion_dict.get, python_mip_vartypes))
