def main():
t = 'k out of n'
n = 9
seed(100)
bound = [randint(5, 15) for _ in range(n)]
tableutils.printmat([['Max sum of'] + bound])
for k in range(1, n + 1):
s = pywraplp.Solver(t, pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
x = [s.NumVar(0, bound[i], '') for i in range(n)]
y = [s.NumVar(0, bound[i], '') for i in range(n)]
Costx = sum(x[i] for i in range(n))
Costy = sum(y[i] for i in range(n))
s.Maximize(Costx + Costy)
k_out_of_n(s, k, x, '==')
ldg = sosn(s, k, y)
rc = s.Solve()
if rc != 0:
print('Error', rc)
sy = SolVal(y)
sx = SolVal(x)
yy = [[' ', 'x'][e > 0] for e in sy]
xx = [[' ', 'x'][e > 0] for e in sx]
tableutils.printmat(
tableutils.wrapmat(
[xx, yy],
['{0}/{1}'.format(k, n), 'Adjacent {0}/{1}'.format(k, n)],
None), 0, False)
return rc
def solve_model(D):
s = newSolver('Job Shop Scheduling', True)
nJ, nM = len(D), len(D[0])
M = sum([D[i][k][1] for i in range(nJ) for k in range(nM)])
x = [[s.NumVar(0, M, '') for k in range(nM)] for i in range(nJ)]
p = [[D[i][k][0] for k in range(nM)] for i in range(nJ)]
d = [[D[i][k][1] for k in range(nM)] for i in range(nJ)]
z = [[[s.IntVar(0,1,'') for k in range(nM)] \
for j in range(nJ)] for i in range(nJ)]
T = s.NumVar(0, M, '')
for i in range(nJ):
for k in range(nM):
s.Add(x[i][p[i][k]] + d[i][k] <= T)
for j in range(nJ):
if i != j:
s.Add(z[i][j][k] == 1 - z[j][i][k])
s.Add(x[i][p[i][k]] + d[i][k] - M*z[i][j][p[i][k]] \
<= x[j][p[i][k]])
s.Add(x[j][p[j][k]] + d[j][k] - M*z[j][i][p[j][k]] \
<= x[i][p[j][k]])
for k in range(nM - 1):
s.Add(x[i][p[i][k]] + d[i][k] <= x[i][p[i][k + 1]])
s.Minimize(T)
rc = s.Solve()
return rc, SolVal(T), SolVal(x)
def ss_ret(x, z, nbI, nbSets, nbS, nbPairs, I, S, R, P):
xs = []
for i in range(nbI):
xs.append([i,[[j,(I[i][2][S[j][1]],\
sum(I[i][3][r] for r in range(nbSets) if j in R[r][1]),
sum(SolVal(z[i][p][k])*I[i][4][p]/2
for p in range(nbPairs) for k in range(len(P[p][1]))
if j in P[p][1][k]))] for j in range(nbS) \
if SolVal(x[i][j])>0]])
return xs
def main():
bounds = []
s = pywraplp.Solver('', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
a = [[2], [-2]]
b = [3, -12]
x = s.NumVar(2, 5, 'x')
z, l = maximax(s, a, [x], b)
rc = s.Solve()
print('x = ', SolVal(x))
print('z = ', SolVal(z))
print('delta = ', SolVal(l))
def minimize_piecewise_linear(Points,B,convex=True):
s,n = newSolver('Piecewise', True),len(Points)
x = s.NumVar(Points[0][0],Points[n-1][0],'x')
l = [s.NumVar(0,1,'l[%i]' % (i,)) for i in range(n)]
s.Add(1 == sum(l[i] for i in range(n)))
d = sosn(s, 2, l)
s.Add(x == sum(l[i]*Points[i][0] for i in range(n)))
s.Add(x >= B)
Cost = s.Sum(l[i]*Points[i][1] for i in range(n))
s.Minimize(Cost)
rc = s.Solve()
return rc,SolVal(l),SolVal(d[1])
def solve_model(D):
s = newSolver('Project management')
n = len(D)
max = sum(D[i][1] for i in range(n))
t = [s.NumVar(0, max, 't[%i]' % i) for i in range(n)]
Total = s.NumVar(0, max, 'Total')
for i in range(n):
s.Add(t[i] + D[i][1] <= Total)
for j in D[i][2]:
s.Add(t[j] + D[j][1] <= t[i])
s.Minimize(Total)
rc = s.Solve()
return rc, SolVal(Total), SolVal(t)
def solve_model_clp(D):
t = 'Project management'
s = pywraplp.Solver(t, pywraplp.Solver.CLP_LINEAR_PROGRAMMING)
n = len(D)
max = sum(D[i][1] for i in range(n))
t = [s.NumVar(0, max, 't[%i]' % i) for i in range(n)]
Total = s.NumVar(0, max, 'Total')
for i in range(n):
s.Add(t[i] + D[i][1] <= Total)
for j in D[i][2]:
s.Add(t[j] + D[j][1] <= t[i])
s.Minimize(Total)
rc = s.Solve()
return rc, SolVal(Total), SolVal(t)
def solve_model(D, C=None):
t = 'Set Cover'
s = pywraplp.Solver(t, pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
nbSup = len(D)
nbParts = max([e for d in D for e in d]) + 1
S = [s.IntVar(0, 1, '') for i in range(nbSup)]
for j in range(nbParts):
s.Add(1 <= sum(S[i] for i in range(nbSup) if j in D[i]))
s.Minimize(s.Sum(S[i] * (1 if C is None else C[i]) for i in range(nbSup)))
rc = s.Solve()
Suppliers = [i for i in range(nbSup) if SolVal(S[i]) > 0]
Parts = [[i for i in range(nbSup) if j in D[i] and SolVal(S[i]) > 0]
for j in range(nbParts)]
return rc, ObjVal(s), Suppliers, Parts
def solve_model(C,S,T,unique=True):
s,n = newSolver('Maximum flow problem'),len(C)
x=[[s.NumVar(0,C[i][j],'')for j in range(n)]for i in range(n)]
B=sum(C[i][j] for i in range(n) for j in range(n))
Flowout,Flowin = s.NumVar(0,B,''),s.NumVar(0,B,'')
for i in range(n):
if i not in S and i not in T:
s.Add(sum(x[i][j] for j in range(n)) == \
sum(x[j][i] for j in range(n)))
s.Add(Flowout == s.Sum(x[i][j] for i in S for j in range(n)))
s.Add(Flowin == s.Sum(x[j][i] for i in S for j in range(n)))
s.Maximize(Flowout-2*Flowin if unique else Flowout-Flowin)
rc = s.Solve()
return rc,SolVal(Flowout),SolVal(Flowin),SolVal(x)
def main():
s = newSolver('Test reify force', True)
x = [s.NumVar(0, 10, ''), s.NumVar(0, 10, '')]
delta_1 = reify_force(s, [1, 1], x, 3, None, '==')
delta_2 = reify_force(s, [1, 1], x, 5, None, '==')
s.Add(delta_1 + delta_2 == 1)
s.Maximize(2 * x[0] + 3 * x[1])
s.Solve()
print([
SolVal(delta_1) == 0,
SolVal(delta_2) == 1,
abs(SolVal(x[0])) < 0.0001,
abs(SolVal(x[1]) - 5) < 0.0001
])
s = newSolver('Test reify force', True)
x = [s.NumVar(0, 10, ''), s.NumVar(0, 10, '')]
delta_1 = reify_force(s, [1, 1], x, 3, None, '==')
delta_2 = reify_force(s, [1, 1], x, 5, None, '==')
s.Add(delta_1 + delta_2 == 1)
s.Minimize(2 * x[0] + 3 * x[1])
s.Solve()
print([
SolVal(delta_1) == 1,
SolVal(delta_2) == 0,
abs(SolVal(x[0]) - 3) < 0.0001,
abs(SolVal(x[1])) < 0.0001
])
def solve_model(S, I, R, P):
s = newSolver('Staff Scheduling', True)
nbS, nbI, nbSets, nbPairs = len(S), len(I), len(R), len(P)
nbC, nbT = S[-1][1] + 1, 1 + max(e[2] for e in S)
x = [[s.IntVar(0, 1, '') for _ in range(nbS)] for _ in range(nbI)]
z=[[[s.IntVar(0,1,'') for _ in range(len(P[p][1]))] \
for p in range(nbPairs)] for _ in range(nbI)]
for j in range(nbS):
k_out_of_n(s, 1, [x[i][j] for i in range(nbI)], '<=')
for i in range(nbI):
s.Add(sum(x[i][j] for j in range(nbS)) >= I[i][1][0])
s.Add(sum(x[i][j] for j in range(nbS)) <= I[i][1][1])
for t in range(nbT):
k_out_of_n(s, 1, [x[i][j] for j in range(nbS) if S[j][2] == t],
'<=')
WC=sum(x[i][j] * I[i][2][c] for i in range(nbI) \
for j in range(nbS) for c in range(nbC) if S[j][1] == c)
WR=sum(I[i][3][r] * sum(x[i][j] for j in R[r][1]) \
for r in range(nbSets) for i in range(nbI))
for i in range(nbI):
for p in range(nbPairs):
if I[i][4][p] != 0:
for k in range(len(P[p][1])):
xip1k0, xip1k1 = x[i][P[p][1][k][0]], x[i][P[p][1][k][1]]
reify(s, [1, 1], [xip1k0, xip1k1], 2, z[i][p][k], '>=')
WP = sum(z[i][p][k]*I[i][4][p] for i in range(nbI) \
for p in range(nbPairs) for k in range(len(P[p][1])) \
if I[i][4][p] != 0)
s.Maximize(WC + WR + WP)
rc, xs = s.Solve(), ss_ret(x, z, nbI, nbSets, nbS, nbPairs, I, S, R, P)
return rc, SolVal(x), xs, ObjVal(s)
def solve_model(Teams, params):
(nbIntra, nbInter, nbPerWeek, nbWeeks) = params
nbTeams = sum([1 for sub in Teams for e in sub])
nbDiv, Cal = len(Teams), []
s = newSolver('Sports schedule', True)
x = [[[s.IntVar(0, 1, '') if i < j else None for _ in range(nbWeeks)]
for j in range(nbTeams)] for i in range(nbTeams - 1)]
for Div in Teams:
for i in Div:
for j in Div:
if i < j:
s.Add(sum(x[i][j][w] for w in range(nbWeeks)) == nbIntra)
for d in range(nbDiv - 1):
for e in range(d + 1, nbDiv):
for i in Teams[d]:
for j in Teams[e]:
s.Add(sum(x[i][j][w] for w in range(nbWeeks)) == nbInter)
for w in range(nbWeeks):
for i in range(nbTeams):
s.Add(sum(x[i][j][w] for j in range(nbTeams) if i<j) +
sum(x[j][i][w] for j in range(nbTeams) if j<i )\
<=nbPerWeek)
Value=[x[i][j][w] for Div in Teams for i in Div for j in Div \
for w in range(nbWeeks-len(Div)*nbIntra//nbPerWeek,nbWeeks)\
if i<j]
s.Maximize(sum(Value))
rc = s.Solve()
if rc == 0:
Cal=[[(i,j) \
for i in range(nbTeams-1) for j in range(i+1,nbTeams)\
if SolVal(x[i][j][w])>0] for w in range(nbWeeks)]
return rc, ObjVal(s), Cal
def solve_model(D,Start=None, End=None):
s,n = newSolver('Shortest path problem'),len(D)
if Start is None:
Start,End = 0,len(D)-1
G = [[s.NumVar(0,1 if D[i][j] else 0,'') for j in range(n)] for i in range(n)]
for i in range(n):
if i == Start:
s.Add(1 == sum(G[Start][j] for j in range(n)))
s.Add(0 == sum(G[j][Start] for j in range(n)))
elif i == End:
s.Add(1 == sum(G[j][End] for j in range(n)))
s.Add(0 == sum(G[End][j] for j in range(n)))
else:
s.Add(sum(G[i][j] for j in range(n))==sum(G[j][i] for j in range(n)))
Distance = s.Sum(G[i][j]*D[i][j] for i in range(n) for j in range(n))
s.Minimize(Distance)
rc = s.Solve()
Path,Cost,Cumul,node=[Start],[0],[0],Start
while rc == 0 and node != End and len(Path)<n:
next = [i for i in range(n) if SolVal(G[node][i]) == 1][0]
Path.append(next)
Cost.append(D[node][next])
Cumul.append(Cumul[-1]+Cost[-1])
node = next
return rc,ObjVal(s),Path,Cost,Cumul
def solve_model_big(Teams,params):
(nbIntra,nbInter,nbPerWeek,nbWeeks) = params
nbTeams = sum([1 for sub in Teams for e in sub])
nbDiv,cuts = len(Teams),[]
for iter in range(2):
s = newSolver('Sports schedule', False)
x = [[[s.NumVar(0,1,'') if i<j else None
for _ in range(nbWeeks)]
for j in range(nbTeams)] for i in range(nbTeams-1)]
basic_model(s,Teams,nbTeams,nbWeeks,nbPerWeek,nbIntra,\
nbDiv,nbInter,cuts,x)
rc = s.Solve()
bounds = {(3,1):1, (4,1):2, (5,1):2, (5,3):7}
if nbPerWeek <= 3:
for w in range(nbWeeks):
for i in range(nbTeams-2):
for j in range(i+1,nbTeams-1):
for k in range(j+1,nbTeams):
b = bounds.get((3,nbPerWeek),1000)
if sum([SolVal(x[p[0]][p[1]][w]) \
for p in pairs([i,j,k],[])])>b:
cuts.append([[i,j,k],[w,b]])
for l in range(k+1,nbTeams):
b = bounds.get((4,nbPerWeek),1000)
if sum([SolVal(x[p[0]][p[1]][w]) \
for p in pairs([i,j,k,l],[])])>b:
cuts.append([[i,j,k,l],[w,b]])
for m in range(l+1, nbTeams):
b = bounds.get((5,nbPerWeek),1000)
if sum([SolVal(x[p[0]][p[1]][w]) \
for p in pairs([i,j,k,l,m],[])])>b:
cuts.append([[i,j,k,l,m],[w,b]])
else:
break
s = newSolver('Sports schedule', True)
x = [[[s.IntVar(0,1,'') if i<j else None
for _ in range(nbWeeks)]
for j in range(nbTeams)] for i in range(nbTeams-1)]
basic_model(s,Teams,nbTeams,nbWeeks,nbPerWeek,nbIntra,\
nbDiv,nbInter,cuts,x)
rc,Cal = s.Solve(),[]
if rc == 0:
Cal=[[(i,j) \
for i in range(nbTeams-1) for j in range(i+1,nbTeams)\
if SolVal(x[i][j][w])>0] for w in range(nbWeeks)]
return rc,ObjVal(s),Cal
def SolVal(x):
if type(x) is not list:
return 0 if x is None \
else x if isinstance(x,(int,float)) \
else x.SolutionValue() if x.Integer() is False \
else int(x.SolutionValue())
elif type(x) is list:
return [SolVal(e) for e in x]
def solve_model(Part, Target, Cost, Inventory, D, SC, SL):
s = newSolver('Multi-period soap blending problem')
Oils = range(len(Part))
Periods, Acids = range(len(Cost[0])), range(len(Part[0]))
Buy = [[s.NumVar(0, D, '') for _ in Periods] for _ in Oils]
Blnd = [[s.NumVar(0, D, '') for _ in Periods] for _ in Oils]
Hold = [[s.NumVar(0, D, '') for _ in Periods] for _ in Oils]
Prod = [s.NumVar(0, D, '') for _ in Periods]
CostP = [s.NumVar(0, D * 1000, '') for _ in Periods]
CostS = [s.NumVar(0, D * 1000, '') for _ in Periods]
Acid = [[s.NumVar(0, D * D, '') for _ in Periods] for _ in Acids]
for i in Oils:
s.Add(Hold[i][0] == Inventory[i][0])
for j in Periods:
s.Add(Prod[j] == sum(Blnd[i][j] for i in Oils))
s.Add(Prod[j] >= D)
if j < Periods[-1]:
for i in Oils:
s.Add(Hold[i][j] + Buy[i][j] - Blnd[i][j] == Hold[i][j + 1])
s.Add(sum(Hold[i][j] for i in Oils) >= SL[0])
s.Add(sum(Hold[i][j] for i in Oils) <= SL[1])
for k in Acids:
s.Add(Acid[k][j] == sum(Blnd[i][j] * Part[i][k] for i in Oils))
s.Add(Acid[k][j] >= Target[0][k] * Prod[j])
s.Add(Acid[k][j] <= Target[1][k] * Prod[j])
s.Add(CostP[j] == sum(Buy[i][j] * Cost[i][j] for i in Oils))
s.Add(CostS[j] == sum(Hold[i][j] * SC for i in Oils))
Cost_product = s.Sum(CostP[j] for j in Periods)
Cost_storage = s.Sum(CostS[j] for j in Periods)
s.Minimize(Cost_product + Cost_storage)
rc = s.Solve()
B, L, H, A = SolVal(Buy), SolVal(Blnd), SolVal(Hold), SolVal(Acid)
CP, CS, P = SolVal(CostP), SolVal(CostS), SolVal(Prod)
return rc, ObjVal(s), B, L, H, P, A, CP, CS
def get_new_pattern(l, w):
s = newSolver('Cutting stock slave', True)
n = len(l)
a = [s.IntVar(0, 100, '') for i in range(n)]
Cost = sum(l[i] * a[i] for i in range(n))
s.Maximize(Cost)
s.Add(sum(w[i] * a[i] for i in range(n)) <= 100)
rc = s.Solve()
return SolVal(a), ObjVal(s)
def solve_model(D, W, symmetry_break=False, knapsack=True):
s = newSolver('Bin Packing', True)
nbC, nbP = len(D), sum([P[0] for P in D])
w = [e for sub in [[d[1]] * d[0] for d in D] for e in sub]
nbT, nbTmin = bound_trucks(w, W)
x = [[[s.IntVar(0,1,'') for _ in range(nbT)] \
for _ in range(d[0])] for d in D]
y = [s.IntVar(0, 1, '') for _ in range(nbT)]
for k in range(nbT):
sxk = sum(D[i][1]*x[i][j][k] \
for i in range(nbC) for j in range(D[i][0]))
s.Add(sxk <= W * y[k])
for i in range(nbC):
for j in range(D[i][0]):
s.Add(sum([x[i][j][k] for k in range(nbT)]) == 1)
if symmetry_break:
for k in range(nbT - 1):
s.Add(y[k] >= y[k + 1])
for i in range(nbC):
for j in range(D[i][0]):
for k in range(nbT):
for jj in range(max(0, j - 1), j):
s.Add(sum(x[i][jj][kk] \
for kk in range(k+1)) >= x[i][j][k])
for jj in range(j + 1, min(j + 2, D[i][0])):
s.Add(sum(x[i][jj][kk] \
for kk in range(k,nbT))>=x[i][j][k])
if knapsack:
s.Add(sum(W * y[i] for i in range(nbT)) >= sum(w))
s.Add(sum(y[k] for k in range(nbT)) >= nbTmin)
s.Minimize(sum(y[k] for k in range(nbT)))
rc = s.Solve()
P2T = [[
D[i][1],
[
k for j in range(D[i][0]) for k in range(nbT)
if SolVal(x[i][j][k]) > 0
]
] for i in range(nbC)]
T2P=[[k, [(i,j,D[i][1]) \
for i in range(nbC) for j in range(D[i][0])\
if SolVal(x[i][j][k])>0]] for k in range(nbT)]
return rc, ObjVal(s), P2T, T2P
def solve_model(D, F):
s = newSolver('Facility location problem', True)
m, n = len(D) - 1, len(D[0]) - 1
B = sum(D[-1][j]*max(D[i][j] \
for i in range(m)) for j in range(n))
x = [[s.NumVar(0,D[i][-1],'') for j in range(n)] \
for i in range(m)]
y = [s.IntVar(0, 1, '') for i in range(m)]
Fcost, Dcost = s.NumVar(0, B, ''), s.NumVar(0, B, '')
for i in range(m):
s.Add(D[i][-1] * y[i] >= sum(x[i][j] for j in range(n)))
for j in range(n):
s.Add(D[-1][j] == sum(x[i][j] for i in range(m)))
s.Add(sum(y[i] * F[i] for i in range(m)) == Fcost)
s.Add(sum(x[i][j]*D[i][j] \
for i in range(m) for j in range(n)) == Dcost)
s.Minimize(Dcost + Fcost)
rc = s.Solve()
return rc,ObjVal(s),SolVal(x),SolVal(y),\
SolVal(Fcost),SolVal(Dcost)
def solve_diet(N):
s = newSolver('Diet')
nbF,nbN = len(N)-2, len(N[0])-3
FMin,FMax,FCost,NMin,NMax = nbN,nbN+1,nbN+2,nbF,nbF+1
f = [s.NumVar(N[i][FMin], N[i][FMax],'') for i in range(nbF)]
for j in range(nbN):
s.Add(N[NMin][j]<=s.Sum([f[i]*N[i][j] for i in range(nbF)]))
s.Add(s.Sum([f[i]*N[i][j] for i in range(nbF)])<=N[NMax][j])
s.Minimize(s.Sum([f[i]*N[i][FCost] for i in range(nbF)]))
rc = s.Solve()
return rc,ObjVal(s),SolVal(f)
def solve_smm():
s = newSolver('Send more money', True)
ALL = [S, E, N, D, M, O, R, Y] = [newIntVar(s, 0, 9) for k in range(8)]
s.Add(1000 * S[0] + 100 * E[0] + 10 * N[0] + D[0] + 1000 * M[0] +
100 * O[0] + 10 * R[0] + E[0] == 10000 * M[0] + 1000 * O[0] +
100 * N[0] + 10 * E[0] + Y[0])
all_different(s, ALL)
neq(s, S, 0)
neq(s, M, 0)
rc = s.Solve()
return rc, SolVal([a[0] for a in ALL])
def solve_lady_or_tiger():
s = newSolver('Lady or tider', True)
Rooms = range(1, 10)
R = [None] + [newIntVar(s, 0, 2) for _ in Rooms]
S = [None] + [s.IntVar(0, 1, '') for _ in Rooms]
i_empty, i_lady, i_tiger = 1, 2, 3
k_out_of_n(s, 1, [R[i][i_lady] for i in Rooms])
for i in Rooms:
reify_force(s, [1], [R[i][i_tiger]], 0, S[i], '<=')
reify_raise(s, [1], [R[i][i_lady]], 1, S[i], '>=')
reify(s, [1] * 5, [R[i][i_lady] for i in range(1, 10, 2)], 1, S[1], '>=')
reify(s, [1], [R[2][i_empty]], 1, S[2], '>=')
reify(s, [1, -1], [S[5], S[7]], 0, S[3], '>=')
reify(s, [1], [S[1]], 0, S[4], '<=')
reify(s, [1, 1], [S[2], S[4]], 1, S[5], '>=')
reify(s, [1], [S[3]], 0, S[6], '<=')
reify(s, [1], [R[1][i_lady]], 0, S[7], '<=')
reify(s, [1, 1], [R[8][i_tiger], R[9][i_empty]], 2, S[8], '>=')
reify(s, [1, -1], [R[9][i_tiger], S[6]], 1, S[9], '>=')
rc = s.Solve()
return rc, [SolVal(S[i]) for i in Rooms], [SolVal(R[i]) for i in Rooms]
def solve_maxrook(n):
s = newSolver('Maxrook', True)
x = [[s.IntVar(0, 1, '') for _ in range(n)] for _ in range(n)]
for i in range(n):
k_out_of_n(s, 1, get_row(x, i), '<=')
k_out_of_n(s, 1, get_column(x, i), '<=')
Count = s.Sum(x[i][j] for i in range(n) for j in range(n))
s.Maximize(Count)
rc = s.Solve()
xx = [[[' ', 'R'][int(SolVal(x[i][j]))] for j in range(n)]
for i in range(n)]
return rc, xx
def solve_model(D):
s = newSolver('Transshipment problem')
n = len(D[0]) - 1
B = sum([D[-1][j] for j in range(n)])
G = [[s.NumVar(0,B if D[i][j] else 0,'') \
for j in range(n)] for i in range(n)]
for i in range(n):
s.Add(D[i][-1] - D[-1][i] == \
sum(G[i][j] for j in range(n))-sum(G[j][i]for j in range(n)))
Cost = s.Sum(G[i][j] * D[i][j] for i in range(n) for j in range(n))
s.Minimize(Cost)
rc = s.Solve()
return rc, ObjVal(s), SolVal(G)
def solve_model(D):
s, n = newSolver('Cutting Stock', True), len(D)
k, b = bounds(D)
y = [s.IntVar(0, 1, '') for i in range(k[1])]
x = [[s.IntVar(0,b[i],'') for j in range(k[1])] \
for i in range(n)]
w = [s.NumVar(0, 100, '') for j in range(k[1])]
nb = s.IntVar(k[0], k[1], '')
for i in range(n):
s.Add(sum(x[i][j] for j in range(k[1])) >= D[i][0])
for j in range(k[1]):
s.Add(sum(D[i][1] * x[i][j] for i in range(n)) <= 100 * y[j])
s.Add(100 * y[j] - sum(D[i][1] * x[i][j] for i in range(n)) == w[j])
if j < k[1] - 1:
s.Add(sum(x[i][j] for i in range(n)) >= \
sum(x[i][j+1] for i in range(n)))
Cost = s.Sum((j + 1) * y[j] for j in range(k[1]))
s.Add(nb == s.Sum(y[j] for j in range(k[1])))
s.Minimize(Cost)
rc = s.Solve()
rnb = SolVal(nb)
return rc, rnb, rolls(rnb, SolVal(x), SolVal(w), D), SolVal(w)
def solve_model(D):
s = newSolver('Mincost flow problem')
m, n = len(D) - 1, len(D[0]) - 1
B = sum([D[-1][j] for j in range(n)])
G = [[s.NumVar(0,B if D[i][j] else 0,'') for j in range(n)] \
for i in range(m)]
for i in range(m):
s.Add(D[i][-1] >= sum(G[i][j] for j in range(n)))
for j in range(n):
s.Add(D[-1][j] == sum(G[i][j] for i in range(m)))
Cost = s.Sum(G[i][j] * D[i][j] for i in range(m) for j in range(n))
s.Minimize(Cost)
rc = s.Solve()
return rc, ObjVal(s), SolVal(G)
def solve_classification(A,B):
n,ma,mb=len(A[0]),len(A),len(B)
s = newSolver('Classification')
ya = [s.NumVar(0,99,'') for _ in range(ma)]
yb = [s.NumVar(0,99,'') for _ in range(mb)]
a = [s.NumVar(-99,99,'') for _ in range(n+1)]
for i in range(ma):
s.Add(ya[i] >= a[n]+1-s.Sum(a[j]*A[i][j] for j in range(n)))
for i in range(mb):
s.Add(yb[i] >= s.Sum(a[j]*B[i][j] for j in range(n))-a[n]+1 )
Agap = s.Sum(ya[i] for i in range(ma))
Bgap = s.Sum(yb[i] for i in range(mb))
s.Minimize(Agap+Bgap)
rc = s.Solve()
return rc,ObjVal(s),SolVal(a)
def solve_tree_model(D,Start=None):
s,n = newSolver('Shortest paths tree problem'),len(D)
Start = 0 if Start is None else Start
G = [[s.NumVar(0,min(n,D[i][j]),'') for j in range(n)] for i in range(n)]
for i in range(n):
if i == Start:
s.Add(n-1 == sum(G[Start][j] for j in range(n)))
s.Add(0 == sum(G[j][Start] for j in range(n)))
else:
s.Add(sum(G[j][i] for j in range(n))-sum(G[i][j] for j in range(n))==1)
Distance = s.Sum(G[i][j]*D[i][j] for i in range(n) for j in range(n))
s.Minimize(Distance)
rc = s.Solve()
Tree = [[i,j, D[i][j]] for i in range(n) for j in range(n) if SolVal(G[i][j])>0]
return rc,ObjVal(s),Tree
def solve_model_eliminate(D, Subtours=[]):
s, n = newSolver('TSP', True), len(D)
x = [[s.IntVar(0,0 if D[i][j] is None else 1,'') \
for j in range(n)] for i in range(n)]
for i in range(n):
s.Add(1 == sum(x[i][j] for j in range(n)))
s.Add(1 == sum(x[j][i] for j in range(n)))
s.Add(0 == x[i][i])
for sub in Subtours:
K = [x[sub[i]][sub[j]]+x[sub[j]][sub[i]]\
for i in range(len(sub)-1) for j in range(i+1,len(sub))]
s.Add(len(sub) - 1 >= sum(K))
s.Minimize(s.Sum(x[i][j]*(0 if D[i][j] is None else D[i][j]) \
for i in range(n) for j in range(n)))
rc = s.Solve()
tours = extract_tours(SolVal(x), n)
return rc, ObjVal(s), tours
def solve_maxpiece(n, piece):
s = newSolver('Maxpiece', True)
x = [[s.IntVar(0, 1, '') for _ in range(n)] for _ in range(n)]
for i in range(n):
if piece in ['R', 'Q']:
k_out_of_n(s, 1, get_row(x, i), '<=')
k_out_of_n(s, 1, get_column(x, i), '<=')
if piece in ['B', 'Q']:
for j in range(n):
if i in [0, n - 1] or j in [0, n - 1]:
k_out_of_n(s, 1, get_ne(x, i, j, n), '<=')
k_out_of_n(s, 1, get_se(x, i, j, n), '<=')
Count = s.Sum(x[i][j] for i in range(n) for j in range(n))
s.Maximize(Count)
rc = s.Solve()
xx = [[[' ', piece][int(SolVal(x[i][j]))] for j in range(n)]
for i in range(n)]
return rc, xx
