def legalizeFloorplanResults( orig_v2s: Dict[Vertex, Slot], grouping_list: List[List[Vertex]], all_slot_list: List[Slot], resource_usage_limit: int ) -> Tuple[Dict[Slot, List[Vertex]], Dict[Vertex, Slot]]: """ adjust the floorplanning to satisfy the area requirement """ _logger.info('Begin legalizing the floorplan results...') _logger.info(f'Target resource usage limit: {resource_usage_limit}') m = Model() v_list = list(orig_v2s.keys()) s_list = all_slot_list v_to_s_to_var, s_to_v_to_var = _createILPVars(m, v_list, s_list) v_to_s_to_cost = _getVToSToCost(v_list, s_list, orig_v2s) _addAreaConstrains(m, s_to_v_to_var, resource_usage_limit) _addUniqueConstrains(m, v_to_s_to_var) _addGroupingConstraints(m, grouping_list, v_to_s_to_var, s_list) _addObjective(m, v_to_s_to_cost, v_to_s_to_var) status = m.optimize() if status != OptimizationStatus.OPTIMAL: _logger.warning( f'Fail to legalize the floorplan under target ratio {resource_usage_limit}' ) m.write('floorplan_legalization.lp') return None, None new_v2s, new_s2v = _getILPResults(v_to_s_to_var) _logResults(new_s2v, new_v2s, orig_v2s) _logger.info('Finish legalizing the floorplan results.') return new_s2v, new_v2s
def test_numpy(): model = Model() N = 1000 start = time.time() x = model.add_var_tensor(shape=(N, N), name="x") # inefficient way to compute trace, so we can test optimizations # equivalent to model += np.trace(x) model += np.ones((N, )) @ (x * np.eye(N)) @ np.ones((N, )) # constraints model += np.vectorize(lambda x_i_j: x_i_j >= 1)(x) stop = time.time() print("model built in: %.1f seconds" % (stop - start)) model.write("numpy_tensors.lp") result = model.optimize() assert result == OptimizationStatus.OPTIMAL
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))
# There are k x t variables, stored in a matrix of k rows by t columns x = [model.add_var(var_type=BINARY) for j in R] model.objective = minimize(xsum(x[i] for i in R)) nodes_forgotten = 0 for a in J: tagset = user_hashtag_matrix.iloc[a][user_hashtag_matrix.iloc[a] == 1] if len(tagset.index) == 0: nodes_forgotten += 1 else: model += xsum(x[i] for i in tagset.index) >= 1 model.optimize(max_seconds=optimization_runtime) if write_model_file: model.write(model_filename) sleep(1) foundClusters = [] if model.status == OptimizationStatus.OPTIMAL or model.status == OptimizationStatus.FEASIBLE: print('Tags in each cluster:') for v in model.vars: if abs(v.x) > 1e-6 and int( v.name[4:-1]) < (k * t): # only printing non-zeros if int(v.name[4:-1]) // t + 1 not in foundClusters: print("\nCluster", int(v.name[4:-1]) // t + 1) foundClusters.append(int(v.name[4:-1]) // t + 1) print(hashtags.iloc[(int(v.name[4:-1]) % t)][0]) if cover_or_forget: print('\nForgotten nodes:')
# STEP 3: adding the new columns (if any is obtained with negative reduced cost) ########## # checking if columns with negative reduced cost were produced and # adding them into the restricted master problem if pricing.objective_value < -1e-5: pattern = [a[i].x for i in range(m)] column = Column(constraints, pattern) lambdas.append( master.add_var(obj=1, column=column, name='lambda_%d' % (len(lambdas) + 1))) print('new pattern = {pattern}'.format(**locals())) # if no column with negative reduced cost was produced, then linear # relaxation of the restricted master problem is solved else: new_vars = False pricing.write('pricing.lp') # printing the solution print('') print('Objective value: {master.objective_value:.3}'.format(**locals())) print('Solution: ', end='') for v in lambdas: if v.x > 1e-6: print('{v.name} = {v.x:.3} {v.column}'.format(**locals())) print(' ', end='')
# conflicting items C = ((2, 3), (2, 4), (3, 4), (2, 5)) m = Model() x = {i: m.add_var("x({})".format(i), var_type=BINARY) for i in I} m.objective = maximize(xsum(p[i] * x[i] for i in I)) m += xsum(w[i] * x[i] for i in I) <= c for (i, j) in C: m += x[i] + x[j] <= 1 m.verbose = 0 m.write("b.lp") m.optimize(relax=True) print("constraints before clique merging: {}. lower bound:" "{}.".format(len(m.constrs), m.objective_value)) m.clique_merge() m.optimize(relax=True) print("constraints after clique merging: {}. lower bound:" "{}.".format(len(m.constrs), m.objective_value)) m.optimize() print("optimal: {}".format(m.objective_value))
#!/usr/bin/env python3 # # See: https://python-mip.readthedocs.io/en/latest/examples.html # from mip import Model, xsum, maximize, MAXIMIZE, MINIMIZE, minimize, BINARY, INTEGER, CONTINUOUS m = Model(sense=MINIMIZE) x1 = m.add_var(var_type=CONTINUOUS) x2 = m.add_var(var_type=CONTINUOUS) m.objective = minimize(1100 * x1 + 700 * x2) m += ((2 * x1 + 2 * x2) >= 16) m += ((3 * x1 + 1 * x2) >= 12) status = m.optimize() #(max_seconds=300) print("x1 =", x1.x, " x2 =", x2.x, " status =", status, " obj =", m.objective_value) m.write("ex_prova.lp")
# objective: minimize number of coins model.objective = x.sum() # boundary: amount must be equal to required change, within rouding errors required_change = 3.74 eps = 0.005 # total value of the coins amount = x.dot(vals) print("Value of the coins: %s" % amount) # these are 2 separate scalar constraints computed with tensor notation model += (required_change - eps) <= amount model += amount <= (required_change + eps) # coins availability # these are 8 different scalar constraints expressed with tensor notation model += x <= available, "availability" # go and see how the constraint lable was expanded model.write("numpy_tensor_example.lp") model.optimize() x_val = np.vectorize(lambda var: var.x)(x) print("Solution vector: %s" % x_val) print("Coins:") for coin_value, pieces in zip(vals, x_val): print("%0.2f euro coin: %d" % (coin_value, pieces))
#!/usr/bin/env python3 # # See: https://python-mip.readthedocs.io/en/latest/examples.html # from mip import Model, xsum, maximize, MAXIMIZE, BINARY, INTEGER m = Model(sense=MAXIMIZE) x1 = m.add_var(var_type=INTEGER) x2 = m.add_var(var_type=INTEGER) m.objective = maximize(5*x1 + 8*x2) m += ((x1 + x2) <= 6) m += ((5*x1 + 9*x2) <= 45) status = m.optimize() #(max_seconds=300) print("x1 =", x1.x, " x2 =", x2.x, " status =", status, " obj =",m.objective_value) m.write("ex1_marcone.lp")