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
