def solve_tsp_by_mip(tsp_matrix): start = time() matrix_of_distances = get_matrix_of_distances(tsp_matrix) length = len(tsp_matrix) model = Model(solver_name='gurobi') model.verbose = 1 x = [[model.add_var(var_type=BINARY) for j in range(length)] for i in range(length)] y = [model.add_var() for i in range(length)] model.objective = xsum(matrix_of_distances[i][j] * x[i][j] for j in range(length) for i in range(length)) for i in range(length): model += xsum(x[j][i] for j in range(length) if j != i) == 1 model += xsum(x[i][j] for j in range(length) if j != i) == 1 for i in range(1, length): for j in [x for x in range(1, length) if x != i]: model += y[i] - (length + 1) * x[i][j] >= y[j] - length model.optimize(max_seconds=300) arcs = [(i, j) for i in range(length) for j in range(length) if x[i][j].x >= 0.99] best_distance = calculate_total_dist_by_arcs(matrix_of_distances, arcs) time_diff = time() - start return arcs, time_diff, best_distance
def solve_tsp_by_mip_with_sub_cycles_2(tsp_matrix): start = time() matrix_of_distances = get_matrix_of_distances(tsp_matrix) total_length = len(tsp_matrix) best_distance = sys.float_info.max found_cycles = [] arcs = [(i, i + 1) for i in range(total_length - 1)] iteration = 0 model = Model(solver_name='gurobi') model.verbose = 0 x = [[model.add_var(var_type=BINARY) for j in range(total_length)] for i in range(total_length)] y = [model.add_var() for i in range(total_length)] model.objective = xsum(matrix_of_distances[i][j] * x[i][j] for j in range(total_length) for i in range(total_length)) for i in range(total_length): model += (xsum(x[i][j] for j in range(0, i)) + xsum(x[j][i] for j in range(i + 1, total_length))) == 2 while len(found_cycles) != 1: model.optimize(max_seconds=300) arcs = [(i, j) for i in range(total_length) for j in range(total_length) if x[i][j].x >= 0.99] best_distance = calculate_total_dist_by_arcs(matrix_of_distances, arcs) found_cycles = get_cycle(arcs) for cycle in found_cycles: points = {} for arc in cycle: points = {*points, arc[0]} points = {*points, arc[1]} cycle_len = len(cycle) model += xsum(x[arc[0]][arc[1]] for arc in permutations(points, 2)) <= cycle_len - 1 # plot_connected_tsp_points_from_arcs(tsp_matrix, arcs, '../images/mip_xql662/{}'.format(iteration)) print(iteration) iteration += 1 time_diff = time() - start return arcs, time_diff, best_distance
def test_tsp_mipstart(solver: str): """tsp related tests""" announce_test("TSP - MIPStart", solver) N = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] n = len(N) i0 = N[0] A = { ('a', 'd'): 56, ('d', 'a'): 67, ('a', 'b'): 49, ('b', 'a'): 50, ('d', 'b'): 39, ('b', 'd'): 37, ('c', 'f'): 35, ('f', 'c'): 35, ('g', 'b'): 35, ('b', 'g'): 25, ('a', 'c'): 80, ('c', 'a'): 99, ('e', 'f'): 20, ('f', 'e'): 20, ('g', 'e'): 38, ('e', 'g'): 49, ('g', 'f'): 37, ('f', 'g'): 32, ('b', 'e'): 21, ('e', 'b'): 30, ('a', 'g'): 47, ('g', 'a'): 68, ('d', 'c'): 37, ('c', 'd'): 52, ('d', 'e'): 15, ('e', 'd'): 20 } # input and output arcs per node Aout = {n: [a for a in A if a[0] == n] for n in N} Ain = {n: [a for a in A if a[1] == n] for n in N} m = Model(solver_name=solver) m.verbose = 0 x = { a: m.add_var(name='x({},{})'.format(a[0], a[1]), var_type=BINARY) for a in A } m.objective = xsum(c * x[a] for a, c in A.items()) for i in N: m += xsum(x[a] for a in Aout[i]) == 1, 'out({})'.format(i) m += xsum(x[a] for a in Ain[i]) == 1, 'in({})'.format(i) # continuous variable to prevent subtours: each # city will have a different "identifier" in the planned route y = {i: m.add_var(name='y({})'.format(i), lb=0.0) for i in N} # subtour elimination for (i, j) in A: if i0 not in [i, j]: m.add_constr(y[i] - (n + 1) * x[(i, j)] >= y[j] - n) route = ['a', 'g', 'f', 'c', 'd', 'e', 'b', 'a'] m.start = [(x[route[i - 1], route[i]], 1.0) for i in range(1, len(route))] m.optimize() check_result("mip model status", m.status == OptimizationStatus.OPTIMAL) check_result("mip model objective", (abs(m.objective_value - 262)) <= 0.0001) print('')
print('solving TSP with {} cities'.format(len(N))) model = Model() # binary variables indicating if arc (i,j) is used on the route or not x = { a: model.add_var('x({},{})'.format(a[0], a[1]), var_type=BINARY) for a in A } # continuous variable to prevent subtours: each # city will have a different "identifier" in the planned route y = {i: model.add_var(name='y({})') for i in N} # objective function: minimize the distance model.objective = minimize(xsum(A[a] * x[a] for a in A)) # constraint : enter each city coming from another city for i in N: model += xsum(x[a] for a in OUT[i]) == 1 # constraint : leave each city coming from another city for i in N: model += xsum(x[a] for a in IN[i]) == 1 # no subtours of size 2 for a in A: if (a[1], a[0]) in A.keys(): model += x[a] + x[a[1], a[0]] <= 1 # computing farthest point for each point
def cg(): """ Simple column generation implementation for a Cutting Stock Problem """ L = 250 # bar length m = 4 # number of requests w = [187, 119, 74, 90] # size of each item b = [1, 2, 2, 1] # demand for each item # creating models and auxiliary lists master = Model() lambdas = [] constraints = [] # creating an initial pattern (which cut one item per bar) # to provide the restricted master problem with a feasible solution for i in range(m): lambdas.append(master.add_var(obj=1, name='lambda_%d' % (len(lambdas) + 1))) # creating constraints for i in range(m): constraints.append(master.add_constr(lambdas[i] >= b[i], name='i_%d' % (i + 1))) # creating the pricing problem pricing = Model(SOLVER) # creating pricing variables a = [] for i in range(m): a.append(pricing.add_var(obj=0, var_type=INTEGER, name='a_%d' % (i + 1))) # creating pricing constraint pricing.add_constr(xsum(w[i] * a[i] for i in range(m)) <= L, 'bar_length') pricing.write('pricing.lp') new_vars = True while new_vars: ########## # STEP 1: solving restricted master problem ########## master.optimize() # printing dual values print_solution(master) print('pi = ', end='') print([constraints[i].pi for i in range(m)]) print('') ########## # STEP 2: updating pricing objective with dual values from master ########## pricing.objective = 1 for i in range(m): a[i].obj = -constraints[i].pi # solving pricing problem pricing.optimize() # printing pricing solution z_val = pricing.objective_value print('Pricing:') print(' z = {z_val}'.format(**locals())) print(' a = ', end='') print([v.x for v in pricing.vars]) print('') ########## # STEP 3: adding the new columns ########## # checking if columns with negative reduced cost were produced and # adding them into the restricted master problem if 1 + pricing.objective_value < - EPS: coeffs = [a[i].x for i in range(m)] column = Column(constraints, coeffs) lambdas.append(master.add_var(obj=1, column=column, name='lambda_%d' % (len(lambdas) + 1))) print('new pattern = {coeffs}'.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') print_solution(master)
print('solving TSP with {} cities'.format(len(N))) model = Model() # binary variables indicating if arc (i,j) is used on the route or not x = { a: model.add_var('x({},{})'.format(a[0], a[1]), var_type=BINARY) for a in A.keys() } # continuous variable to prevent subtours: each # city will have a different "identifier" in the planned route y = {i: model.add_var(name='y({})') for i in N} # objective function: minimize the distance model.objective = minimize(xsum(A[a] * x[a] for a in A.keys())) # constraint : enter each city coming from another city for i in N: model += xsum(x[a] for a in OUT[i]) == 1 # constraint : leave each city coming from another city for i in N: model += xsum(x[a] for a in IN[i]) == 1 # subtour elimination for (i, j) in [a for a in A.keys() if n0 not in [a[0], a[1]]]: model += \ y[i] - (n+1)*x[(i, j)] >= y[j]-n, 'noSub({},{})'.format(i, j) print('model has {} variables, {} of which are integral and {} rows'.format(
inst = JSSPInstance(argv[1]) n, m, machines, times, M = inst.n, inst.m, inst.machines, inst.times, inst.M model = Model('JSSP') c = model.add_var(name="C") x = [[model.add_var(name='x({},{})'.format(j + 1, i + 1)) for i in range(m)] for j in range(n)] y = [[[ model.add_var(var_type=BINARY, name='y({},{},{})'.format(j + 1, k + 1, i + 1)) for i in range(m) ] for k in range(n)] for j in range(n)] model.objective = c for (j, i) in product(range(n), range(1, m)): model += x[j][machines[j][i]] - x[j][machines[j][i-1]] >= \ times[j][machines[j][i-1]] for (j, k) in product(range(n), range(n)): if k != j: for i in range(m): model += x[j][i] - x[k][i] + M * y[j][k][i] >= times[k][i] model += -x[j][i] + x[k][i] - M * y[j][k][i] >= times[j][i] - M for j in range(n): model += c - x[j][machines[j][m - 1]] >= times[j][machines[j][m - 1]] model.optimize()
"""0/1 Knapsack example""" from mip.model import Model, xsum, maximize from mip.constants import BINARY p = [10, 13, 18, 31, 7, 15] w = [11, 15, 20, 35, 10, 33] c = 47 n = len(w) m = Model('knapsack') x = [m.add_var(var_type=BINARY) for i in range(n)] m.objective = maximize(xsum(p[i] * x[i] for i in range(n))) m += xsum(w[i] * x[i] for i in range(n)) <= c m.optimize() selected = [i for i in range(n) if x[i].x >= 0.99] print('selected items: {}'.format(selected))
[5, 2], [2, 5], [0, 0]] c = [6, 8] S = [[0, 1], [0, 2], [0, 3], [1, 4], [1, 5], [2, 9], [2, 10], [3, 8], [4, 6], [4, 7], [5, 9], [5, 10], [6, 8], [6, 9], [7, 8], [8, 11], [9, 11], [10, 11]] (R, J, T) = (range(len(c)), range(len(p)), range(sum(p))) model = Model() x = [[model.add_var(name='x({},{})'.format(j, t), var_type=BINARY) for t in T] for j in J] model.objective = xsum(x[len(J) - 1][t] * t for t in T) for j in J: model += xsum(x[j][t] for t in T) == 1 for (r, t) in product(R, T): model += xsum(u[j][r] * x[j][t2] for j in J for t2 in range(max(0, t - p[j] + 1), t + 1)) <= c[r] for (j, s) in S: model += xsum(t * x[s][t] - t * x[j][t] for t in T) >= p[j] model.optimize() print('Schedule: ') for (j, t) in product(J, T):
import bmcp_greedy from mip.model import Model, xsum, minimize from mip.constants import MINIMIZE, BINARY data = bmcp_data.read('P1.col') N, r, d = data.N, data.r, data.d S = bmcp_greedy.build(data) C, U = S.C, [i for i in range(S.u_max + 1)] m = Model(sense=MINIMIZE) x = [[m.add_var('x({},{})'.format(i, c), var_type=BINARY) for c in U] for i in N] z = m.add_var('z') m.objective = minimize(z) for i in N: m += xsum(x[i][c] for c in U) == r[i] for i, j, c1, c2 in product(N, N, U, U): if i != j and c1 <= c2 < c1 + d[i][j]: m += x[i][c1] + x[j][c2] <= 1 for i, c1, c2 in product(N, U, U): if c1 < c2 < c1 + d[i][i]: m += x[i][c1] + x[i][c2] <= 1 for i, c in product(N, U): m += z >= (c + 1) * x[i][c]
model.add_cut(cut) return inst = TSPData(argv[1]) n, d = inst.n, inst.d model = Model() x = [[ model.add_var(name='x({},{})'.format(i, j), var_type=BINARY) for j in range(n) ] for i in range(n)] y = [model.add_var(name='y({})'.format(i), lb=0.0, ub=n) for i in range(n)] model.objective = xsum(d[i][j] * x[i][j] for j in range(n) for i in range(n)) for i in range(n): model += xsum(x[j][i] for j in range(n) if j != i) == 1 model += xsum(x[i][j] for j in range(n) if j != i) == 1 for (i, j) in [(i, j) for (i, j) in product(range(1, n), range(1, n)) if i != j]: model += y[i] - (n + 1) * x[i][j] >= y[j] - n F = [] for i in range(n): (md, dp) = (0, -1) for j in [k for k in range(n) if k != i]: if d[i][j] > md: (md, dp) = (d[i][j], j) F.append((i, dp))