def OT_2D_Match(Mu, Nu): # Main Pyomo model model = ConcreteModel() # Parameters model.I = RangeSet(n) model.J = RangeSet(n) # Variables model.PI = Var(model.I, model.J, within=NonNegativeReals) # Objective Function Cost = lambda x, y: (x[0] - y[0])**2 + (x[1] - y[1])**2 model.obj = Objective(expr=sum(model.PI[i, j] * Cost(Mu[i - 1], Nu[j - 1]) for i, j in model.PI)) # Constraints on the marginals model.Mu = Constraint(model.I, rule=lambda m, i: sum(m.PI[i, j] for j in m.J) == 1) model.Nu = Constraint(model.J, rule=lambda m, j: sum(m.PI[i, j] for i in m.I) == 1) # Solve the model sol = SolverFactory('gurobi').solve(model, tee=True) # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return model.obj(), dict([((i - 1, j - 1), model.PI[i, j]()) for i, j in model.PI if model.PI[i, j]() > 0])
def OT_LP(Mu, Nu, Xm, Xn): # Main Pyomo model model = ConcreteModel() # Parameters model.I = RangeSet(len(Mu)) model.J = RangeSet(len(Nu)) # Variables model.PI = Var(model.I, model.J, within=NonNegativeReals) # Objective Function model.obj = Objective(expr=sum(model.PI[i, j] * Cost(Xm[i - 1], Xn[j - 1]) for i, j in model.PI)) # Constraints on the marginals model.Mu = Constraint(model.I, rule=lambda m, i: sum(m.PI[i, j] for j in m.J) == Mu[i - 1]) model.Nu = Constraint(model.J, rule=lambda m, j: sum(m.PI[i, j] for i in m.I) == Nu[j - 1]) # Solve the model sol = SolverFactory('glpk').solve(model) # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return model.obj(), dict([((i - 1, j - 1), model.PI[i, j]()) for i, j in model.PI if model.PI[i, j]() > 0])
def TSP(C): # Number of places n, n = C.shape # Create concrete model model = ConcreteModel() # Set of indices model.I = RangeSet(1, n) model.J = RangeSet(1, n) # Variables model.X = Var(model.I, model.J, within=Binary) model.U = Var(model.I, within=PositiveReals) # Objective Function model.obj = Objective(expr=sum(C[i - 1, j - 1] * model.X[i, j] for i, j in model.X)) # Constraints on the marginals model.InDegree = Constraint(model.I, rule=lambda m, i: sum(m.X[i, j] for j in m.J) == 1) model.OutDegree = Constraint(model.J, rule=lambda m, j: sum(m.X[i, j] for i in m.I) == 1) model.onedir = ConstraintList() for i in model.I: for j in model.J: model.onedir.add(expr=model.X[i, j] + model.X[j, i] <= 1) # # Subtour model.subtour = ConstraintList() for i in model.I: for j in model.J: if i > 1 and j > 1 and i != j: model.subtour.add( model.U[i] - model.U[j] + n * model.X[i, j] <= n - 1) model.fix = Constraint(expr=model.U[1] == 1) # Solve the model sol = SolverFactory('gurobi').solve(model, tee=True) # CHECK SOLUTION STATUS # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return [(i - 1, j - 1) for i, j in model.X if model.X[i, j]() > 0.5]
def QuadraticClassifier(Xs0, Ys): Xs = [] for x in Xs0: Xs.append([x[0]*x[0], x[0], x[1]]) # Main Pyomo model model = ConcreteModel() # Parameters n = len(Xs) model.I = RangeSet(n) m = len(Xs[0]) model.J = RangeSet(m) # Variables model.X = Var(model.J, within=Reals) model.X0 = Var(within=Reals) model.W = Var(model.I, within=NonNegativeReals) model.U = Var(model.I, within=Binary) # Objective Function # model.obj = Objective(expr=sum(model.W[i] for i in model.I)) model.obj = Objective(expr=sum(model.U[i] for i in model.I)) # Constraints on the separation hyperplane def ConLabel(m, i): if Ys[i-1] == 0: return sum(Xs[i-1][j-1]*m.X[j] for j in m.J) >= m.X0 + 1 - m.W[i] else: return sum(Xs[i-1][j-1]*m.X[j] for j in m.J) <= m.X0 - 1 + m.W[i] model.Label = Constraint(model.I, rule = ConLabel) model.Viol = Constraint(model.I, rule = lambda m, i: m.W[i] <= 10000*m.U[i]) # Solve the model sol = SolverFactory('gurobi').solve(model, tee=True) # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return model.obj(), [model.X[j]() for j in model.J] + [model.X0()]
def MaxMargin(Xs, Ys): # Main Pyomo model model = ConcreteModel() # Parameters n = len(Xs) model.I = RangeSet(n) m = len(Xs[0]) model.J = RangeSet(m) # Variables model.X = Var(model.J, within=Reals) model.X0 = Var(within=Reals) model.Gamma = Var(within=Reals) # Objective Function model.obj = Objective(expr=model.Gamma, sense=maximize) # Constraints on the separation hyperplane def ConLabel(m, i): if Ys[i-1] == 0: return sum(Xs[i-1][j-1]*m.X[j] for j in m.J) >= m.X0 + m.Gamma# - m.W[i] else: return sum(Xs[i-1][j-1]*m.X[j] for j in m.J) <= m.X0 - m.Gamma# + m.W[i] model.Margin = Constraint(model.I, rule = ConLabel) model.Norm = Constraint(expr = sum(model.X[j] for j in model.J) - model.X0 == 1) # Solve the model sol = SolverFactory('gurobi').solve(model, tee=True) # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return model.obj(), [model.X[j]() for j in model.J] + [model.X0()]
model.no_cross_pair = ConstraintList() for i in range(1, n + 1): for j in range(i, n + 1): for h in range(1, i): for k in range(i + 1, j): model.no_cross_pair.add(no_cross_rule(model, i, j, h, k)) model.no_cross_pair.add(no_cross_rule(model, j, i, h, k)) model.no_cross_pair.add(no_cross_rule(model, i, j, k, h)) model.no_cross_pair.add(no_cross_rule(model, j, i, k, h)) #obj function model.obj = Objective(expr=sum(model.P[i, j] for i in model.I for j in model.J), sense=maximize) sol = SolverFactory('glpk').solve(model) sol_json = sol.json_repn() if sol_json['Solver'][0]['Status'] != 'ok': print("Problem unsolved") if sol_json['Solver'][0]['Termination condition'] != 'optimal': print("Problem unsolved") for i in range(1, n + 1): for j in range(1, n + 1): if model.P[i, j] == 1: print(i, j) #try a plot
def SudokuSolver(Data): # Create concrete model model = ConcreteModel() # Sudoku of size 9x9, with subsquare 3x3 n = 9 model.I = RangeSet(1, n) model.J = RangeSet(1, n) model.K = RangeSet(1, n) # Variables model.x = Var(model.I, model.J, model.K, within=Binary) # Objective Function model.obj = Objective(expr=sum(model.x[i, j, k] for i in model.I for j in model.J for k in model.K)) # 1. A single digit for each position model.unique = ConstraintList() for i in model.I: for j in model.J: expr = 0 for k in model.K: expr += model.x[i, j, k] model.unique.add(expr == 1) # 2. Row constraints model.rows = ConstraintList() for i in model.I: for k in model.K: expr = 0 for j in model.J: expr += model.x[i, j, k] model.rows.add(expr == 1) # 3. Column constraints model.columns = ConstraintList() for j in model.J: for k in model.K: expr = 0 for i in model.I: expr += model.x[i, j, k] model.columns.add(expr == 1) # 4. Submatrix constraints model.blocks = ConstraintList() S = [1, 4, 7] for i0 in S: for j0 in S: for k in model.K: expr = 0 for i in range(3): for j in range(3): expr += model.x[i0 + i, j0 + j, k] model.blocks.add(expr == 1) # 5. Fix input data for i in range(n): for j in range(n): if Data[i][j] > 0: model.x[i + 1, j + 1, Data[i][j]].fix(1) # Solve the model sol = SolverFactory('glpk').solve(model, tee=True) # CHECK SOLUTION STATUS # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None # Print useful information of the solution print("objective value:", model.obj()) for i in model.I: for j in model.J: for k in model.K: if model.x[i, j, k]() > 0: print(k, end=" ") print() return model.x
def MagicSquareSolver(n): # Create concrete model model = ConcreteModel() # Set of indices model.I = RangeSet(1, n) model.J = RangeSet(1, n) model.K = RangeSet(1, n * n) # Variables model.z = Var(within=PositiveIntegers) model.x = Var(model.I, model.J, model.K, within=Binary) # Objective Function model.obj = Objective(expr=model.z) # Every number "k" can appear in a single cell "(i,j)" def Unique(model, k): return sum(model.x[i, j, k] for j in model.J for i in model.I) == 1 model.unique = Constraint(model.K, rule=Unique) # Every cell "(i,j)" can contain a single number "k" def CellUnique(model, i, j): return sum(model.x[i, j, k] for k in model.K) == 1 model.cellUnique = Constraint(model.I, model.J, rule=CellUnique) # The sum of the numbers over each row "i" must be equal to "z" def Row(model, i): return sum(k * model.x[i, j, k] for j in model.J for k in model.K) == model.z model.row = Constraint(model.I, rule=Row) # The sum of the numbers over a column "j" must be equal to "z" def Col(model, j): return sum(k * model.x[i, j, k] for i in model.I for k in model.K) == model.z model.column = Constraint(model.J, rule=Col) # The sum over the main diagonal and the off-diagonal must be equal model.diag1 = Constraint(expr=sum(k * model.x[i, i, k] for i in model.I for k in model.K) == model.z) model.diag2 = Constraint(expr=sum(k * model.x[i, n - i + 1, k] for i in model.I for k in model.K) == model.z) # Write the LP model in standard format model.write("magic_{}.lp".format(n)) # Solve the model sol = SolverFactory('gurobi').solve(model, tee=True) # CHECK SOLUTION STATUS # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return model.x
def TSP(C): # Dimension of the problem n, n = C.shape print('city:', n) model = ConcreteModel() # The set of indces for our variables model.I = RangeSet(1, n) # NOTE: it is different from "range(n)" # the RangeSet is in [1,..n], the second is [0,n( model.J = RangeSet(1, n) # Variable definition model.X = Var(model.I, model.J, within=Binary) # Variables for the MTZ subtour constraints model.U = Var(model.I, within=PositiveReals) # Objective function model.obj = Objective(expr=sum(C[i - 1, j - 1] * model.X[i, j] for i, j in model.X)) # The constraints # model.Indegree = Constraint(model.I, # rule = lambda m, i: sum(m.X[i,j] for j in m.J) == 1) def OutDegRule(m, i): return sum(m.X[i, j] for j in m.J) == 1 model.Outdegree = Constraint(model.I, rule=OutDegRule) def InDegRule(m, j): return sum(m.X[i, j] for i in m.I) == 1 model.Indegree = Constraint(model.J, rule=InDegRule) # easily for forbding "pairs" tour model.pairs = ConstraintList() for i in model.I: for j in model.J: model.pairs.add(expr=model.X[i, j] + model.X[j, i] <= 1) # MTZ constraints for forbidding subtours model.subtour = ConstraintList() for i in model.I: for j in model.J: if i > 1 and j > 1 and i != j: model.subtour.add(model.U[i] - model.U[j] + (n - 1) * model.X[i, j] <= (n - 1) - 1) # Solve the model sol = SolverFactory('gurobi').solve(model, tee=True) sol_json = sol.json_repn() #print(sol_json) if sol_json['Solver'][0]['Status'] != 'ok': print("qualcosa è andato storto") return None # Retrieve the solution: as a list of edges in the optimal tour return [(i - 1, j - 1) for i, j in model.X if model.X[i, j]() > 0.0]
def VRP(n, K, C, Ps, Ds, d, F, TimeLimit): m = ConcreteModel() m.I = RangeSet(len(Ps)) m.J = RangeSet(len(Ps)) m.x = Var(m.I, m.J, domain=Binary) # Es = N x N \ {(i,i)} Es = [] for i in m.I: for j in m.J: if i != j: Es.append((i, j)) m.obj = Objective(expr=sum(F(Ps[i], Ps[j]) * m.x[i, j] for i, j in Es)) # Vincoli archi uscenti m.outdegree = ConstraintList() for i in m.I: if i != d: Ls = [] for z in Ps: if i != z: Ls.append(z) Ls = list(filter(lambda z: z != i, Ps)) m.outdegree.add(expr=sum(m.x[i, j] for j in Ls) == 1) # Vincoli archi entranti m.indegree = ConstraintList() for j in m.J: if j != d: Ls = list(filter(lambda z: z != j, Ps)) m.indegree.add(expr=sum(m.x[i, j] for i in Ls) == 1) Ls = list(filter(lambda z: z != d, Ps)) m.d1 = Constraint(expr=sum(m.x[d, i] for i in Ls) >= 3) m.d2 = Constraint(expr=sum(m.x[i, d] for i in Ls) >= 3) m.pairs = ConstraintList() # for a, b in [(19,20),(15,18),(7,2)]: # m.pairs.add( expr = m.x[a,b] + m.x[b,a] <= 1 ) for a, b in [(19, 20), (15, 18), (7, 2), (5, 6), (22, 8), (14, 12), (11, 14)]: Fs = [] for i in Ps: if i == a or i == b: for j in Ps: if i != j and j != a and j != b: Fs.append((i, j)) m.pairs.add(expr=sum(m.x[i, j] for i, j in Fs) >= 1) for a, b, c in [(5, 6, 9)]: Fs = [] for i in Ps: if i == a or i == b or i == c: for j in Ps: if i != j and j != a and j != b and j != c: Fs.append((i, j)) m.pairs.add(expr=sum(m.x[i, j] for i, j in Fs) >= 1) for S in [(10, 11, 14), (5, 6, 9, 10), (2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23), (2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23), (2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 20, 21, 22, 23)]: Fs = [] for i in Ps: if i in S: for j in Ps: if i != j and (j not in S): Fs.append((i, j)) K = ceil(sum(Ds[i] for i in S) / C) m.pairs.add(expr=sum(m.x[i, j] for i, j in Fs) >= K) # Fissiamo un sottoinsieme S \subset N = {2,...n} di nodi # Troviamo tutti le coppie (i,j) con i in S, j non in S (abbiamo chiamato Fs) # Poniamo il vincolo: # \sum_{ij in Fs} x_ij >= "stima per difetto del numero di veicoli che mi servono # " per serivere tutti i nodi in S" # " intero più grande( \sum_{i in S} d_i/C) # Solve the model sol = SolverFactory('gurobi').solve(m, tee=True) # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None selected = [] for i in m.I: for j in m.J: if i != j: if m.x[i, j]() > 0: selected.append((i, j)) return m.obj(), selected
def MagicSquareSolver(n): # Create concrete model model = ConcreteModel() # Set of indices model.I = RangeSet(1, n) model.J = RangeSet(1, n) model.K = RangeSet(1, n * n) # Variables model.z = Var(within=PositiveIntegers) model.x = Var(model.I, model.J, model.K, within=Binary) # Objective Function model.obj = Objective(expr=model.z) def Unique(model, k): return sum(model.x[i, j, k] for j in model.J for i in model.I) == 1 model.unique = Constraint(model.K, rule=Unique) def CellUnique(model, i, j): return sum(model.x[i, j, k] for k in model.K) == 1 model.cellUnique = Constraint(model.I, model.J, rule=CellUnique) def Row(model, i): return sum(k * model.x[i, j, k] for j in model.J for k in model.K) == model.z model.row = Constraint(model.I, rule=Row) def Col(model, j): return sum(k * model.x[i, j, k] for i in model.I for k in model.K) == model.z model.column = Constraint(model.J, rule=Col) model.diag1 = Constraint(expr=sum(k * model.x[i, i, k] for i in model.I for k in model.K) == model.z) model.diag2 = Constraint(expr=sum(k * model.x[i, n - i + 1, k] for i in model.I for k in model.K) == model.z) # Write the LP model in standard format model.write("magic_{}.lp".format(n)) # Solve the model sol = SolverFactory('glpk').solve(model) # CHECK SOLUTION STATUS # Get a JSON representation of the solution sol_json = sol.json_repn() # Check solution status if sol_json['Solver'][0]['Status'] != 'ok': return None if sol_json['Solver'][0]['Termination condition'] != 'optimal': return None return model.x
def VRP(n, K, C, Ps, Ds, d, F, TimeLimit): m = ConcreteModel() m.I = RangeSet(len(Ps)) m.J = RangeSet(len(Ps)) m.x = Var(m.I, m.J, domain=Binary) # Objective Function Es = [] for i in m.I: for j in m.J: if i != j: Es.append((i,j)) m.obj = Objective(expr = sum(F(Ps[i], Ps[j])*m.x[i,j] for i,j in Es)) # Add outdegree constraint m.outdegree = ConstraintList() for j in m.J: if j != d: Ls = list(filter(lambda z: z!=j, Ps)) m.outdegree.add(expr = sum(m.x[i,j] for i in Ls) == 1) # Add indegree constraint m.indegree = ConstraintList() for i in m.J: if i != d: Ls = list(filter(lambda z: z!=i, Ps)) m.indegree.add(expr = sum(m.x[i,j] for j in Ls) == 1) Ls = list(filter(lambda z: z!=d, Ps)) m.d1 = Constraint(expr = sum(m.x[i,d] for i in Ls) >= 3) m.d2 = Constraint(expr = sum(m.x[d,j] for j in Ls) >= 3) m.subtours = ConstraintList() for a,b in [(15,18), (9,22), (19,20), (5,6), (8,22), (7,2), (9,10)]: m.subtours.add(expr = m.x[a,b] + m.x[b,a] <= 1) m.triple = ConstraintList() for a,b,c in [(5,6,9), (10,11,14)]: Fs = [] for i in Ps: if i == a or i == b or i == c: for j in Ps: if i != j and j != a and j != b and j != c: Fs.append((i,j)) m.triple.add(expr = sum(m.x[i,j] for i,j in Fs) >= 2) # Solve the model sol = SolverFactory('gurobi').solve(m, tee=True) # CHECK SOLUTION STATUS # Get a JSON representation of the solution sol_json = sol.json_repn() if sol_json['Solver'][0]['Status'] != 'ok': print('Error in solving the model') return(None) # DOPO AVER CONTROLLATO LO STATUS print("Optimal solution value:", round(m.obj(), 3)) selected = [] for i in m.I: for j in m.J: if i!=j: if m.x[i,j]() > 0: selected.append((i,j)) return m.obj(), selected