def get_lineup(ds, players, locked, ban, max_point, min_salary, max_salary,
team_match):
'''
:param: locked: list of list. e.g) [['432-WR', '432-TE'], ['634-TE']]
:param: ban: list of ids. e.g) [243, 643]
'''
solver = pywraplp.Solver('nfl-lineup',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
variables = {}
for player in players:
key = f'{player.id}-{player.position}'
if player.id in ban:
variables[key] = solver.IntVar(0, 0, key)
else:
variables[key] = solver.IntVar(0, 1, key)
objective = solver.Objective()
objective.SetMaximization()
for player in players:
key = f'{player.id}-{player.position}'
objective.SetCoefficient(variables[key], player.proj_points)
salary_cap = solver.Constraint(min_salary, max_salary)
for player in players:
key = f'{player.id}-{player.position}'
salary_cap.SetCoefficient(variables[key], player.salary)
point_cap = solver.Constraint(0, max_point)
for player in players:
key = f'{player.id}-{player.position}'
point_cap.SetCoefficient(variables[key], player.proj_points)
for position, min_limit, max_limit in POSITION_LIMITS:
position_cap = solver.Constraint(min_limit, max_limit)
for player in players:
key = f'{player.id}-{player.position}'
if player.position in position:
position_cap.SetCoefficient(variables[key], 1)
# QB paired with 1 WR/TE of same team
# team_cap = solver.Constraint(0.999999, 1)
# for ti, team in enumerate(team_match.keys()):
# for player in players:
# key = f'{player.id}-{player.position}'
# if player.team == team:
# if player.position in ['WR', 'TE']:
# team_cap.SetCoefficient(variables[key], 1/(ti+3))
# elif player.position == 'QB':
# team_cap.SetCoefficient(variables[key], (ti+2)/(ti+3))
size_cap = solver.Constraint(ROSTER_SIZE[ds], ROSTER_SIZE[ds])
for player in players:
key = f'{player.id}-{player.position}'
size_cap.SetCoefficient(variables[key], 1)
for ii in locked:
lock_cap = solver.Constraint(1, 1)
for jj in ii:
lock_cap.SetCoefficient(variables[jj], 1)
solution = solver.Solve()
if solution == solver.OPTIMAL:
roster = Roster(ds)
for player in players:
key = f'{player.id}-{player.position}'
if variables[key].solution_value() == 1:
roster.add_player(player)
return roster
def solve(radius, cost, points):
# Parameters
N = len(points)
m_radius = max(radius)
# Solver
solver = pywraplp.Solver('cameras',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
var = {}
# Delaunay triangulation
triangulation = Delaunay(points)
# Construct variables
connected = defaultdict(set)
possible = set()
visited = set()
for triplet in triangulation.simplices:
i, j, k = np.sort(triplet)
center, r = circumcircle(points[i], points[j], points[k])
if r > m_radius:
continue
if (i, j, k) not in visited:
for camera_type, rad in enumerate(radius, start=1):
if r <= rad:
connected[i].add((center, camera_type))
connected[j].add((center, camera_type))
connected[k].add((center, camera_type))
possible.add((center, camera_type))
visited.add((i, j, k))
for u, v in ((i, j), (i, k), (j, k)):
if (u, v) in visited:
continue
d = dist(points[u], points[v])
center = middle(points[u], points[v])
if d > m_radius:
continue
for camera_type, rad in enumerate(radius, start=1):
if rad <= d:
connected[u].add((center, camera_type))
connected[v].add((center, camera_type))
possible.add((center, camera_type))
visited.add((u, v))
for u, (x, y) in enumerate(points):
camera_type = 1
center = x + 1, y + 1
possible.add((center, camera_type))
connected[u].add((center, camera_type))
def is_in_camera_square(center, r, point):
return -r <= center[0] - point[0] <= r and -r <= center[1] - point[
1] <= r
for i, (center, camera_type) in enumerate(possible):
for u, (x, y) in enumerate(points):
if is_in_camera_square(center, r, (x, y)) and dist(center,
(x, y)) <= r:
connected[u].add((center, camera_type))
print(f"\r processed {100*(i+1)/len(possible):8.2f}%",
file=sys.stderr,
end='')
print(file=sys.stderr)
for center, camera_type in possible:
var[(center,
camera_type)] = solver.IntVar(0, 1,
f'camera_{camera_type}_{center}')
print(len(var), "variables", file=sys.stderr)
# Construct constraints
constraints = 0
for u in range(N):
possible_cameras = []
for center, camera_type in connected[u]:
possible_cameras.append(var[(center, camera_type)])
solver.Add(solver.Sum(possible_cameras) >= 1)
constraints += 1
keys = sorted(var, key=itemgetter(0))
obj_expr = solver.Sum([cost[key[1] - 1] * var[key] for key in keys])
solver.Minimize(obj_expr)
solver.Solve()
solution = set()
for (center, camera_type), value in var.items():
if value.SolutionValue() == 1:
solution.add((camera_type, round(center[0],
2), round(center[1], 2)))
return solution
from ortools.linear_solver import pywraplp
MAX_AD = 250
BUDGET = 1000000
labels = ["Television","Radio", "Newspaper"]
#custo de cada ad
custos = [4000,500,1000]
#custo de produção de ad para determinada mídia
pCustos = [500000,50000,100000]
alcance = [500000, 50000, 200000]
p = pywraplp.Solver("", pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
infinity = p.infinity()
x = [p.IntVar(0, infinity,labels[i]) for i in range(3)]
b = [p.BoolVar(labels[i]+" produziu") for i in range(3)]
for i in range(3):
p.Add(x[i]<=MAX_AD*b[i])
p.Add(p.Sum([x[i]*custos[i]+b[i]*pCustos[i] for i in range(3)])<=BUDGET)
p.Maximize(p.Sum([x[i]*alcance[i] for i in range(3)]))
p.Solve()
for i in range(3):
print("Número de ADs em ", x[i]," = ",x[i].solution_value())
def main(sol='CBC'):
# Create the solver.
print('Solver: ', sol)
# using GLPK
if sol == 'GLPK':
solver = pywraplp.Solver(
'CoinsGridGLPK', pywraplp.Solver.GLPK_MIXED_INTEGER_PROGRAMMING)
else:
# Using CBC
solver = pywraplp.Solver('CoinsGridCBC',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
#
# data
#
nb_items = 12
nb_resources = 7
items = list(range(nb_items))
resources = list(range(nb_resources))
capacity = [18209, 7692, 1333, 924, 26638, 61188, 13360]
value = [96, 76, 56, 11, 86, 10, 66, 86, 83, 12, 9, 81]
use = [[19, 1, 10, 1, 1, 14, 152, 11, 1, 1, 1, 1],
[0, 4, 53, 0, 0, 80, 0, 4, 5, 0, 0, 0],
[4, 660, 3, 0, 30, 0, 3, 0, 4, 90, 0, 0],
[7, 0, 18, 6, 770, 330, 7, 0, 0, 6, 0, 0],
[0, 20, 0, 4, 52, 3, 0, 0, 0, 5, 4, 0],
[0, 0, 40, 70, 4, 63, 0, 0, 60, 0, 4, 0],
[0, 32, 0, 0, 0, 5, 0, 3, 0, 660, 0, 9]]
max_value = max(capacity)
#
# variables
#
take = [solver.IntVar(0, max_value, 'take[%i]' % j) for j in items]
# total cost, to be maximized
z = solver.Sum([value[i] * take[i] for i in items])
#
# constraints
#
for r in resources:
solver.Add(
solver.Sum([use[r][i] * take[i] for i in items]) <= capacity[r])
# objective
objective = solver.Maximize(z)
#
# solution and search
#
solver.Solve()
print()
print('z: ', int(solver.Objective().Value()))
print('take:', end=' ')
for i in items:
print(int(take[i].SolutionValue()), end=' ')
print()
print()
print('walltime :', solver.WallTime(), 'ms')
if sol == 'CBC':
print('iterations:', solver.Iterations())
def main(sol="CBC"):
# Create the solver.
print("Solver: ", sol)
# using GLPK
if sol == "GLPK":
solver = pywraplp.Solver(
"CoinsGridGLPK", pywraplp.Solver.GLPK_MIXED_INTEGER_PROGRAMMING)
else:
# Using CLP
solver = pywraplp.Solver("CoinsGridCLP",
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
#
# data
#
# commodities
num_commodities = 77
C = list(range(num_commodities))
# days in a year
days = 365.25
# nutrients
num_nutrients = 9
N = list(range(num_nutrients))
nutrients = [
"calories", # Calories, unit = 1000
"protein", # Protein, unit = grams
"calcium", # Calcium, unit = grams
"iron", # Iron, unit = milligrams
"vitaminA", # Vitamin A, unit = 1000 International Units
"thiamine", # Thiamine, Vit. B1, unit = milligrams
"riboflavin", # Riboflavin, Vit. B2, unit = milligrams
"niacin", # Niacin (Nicotinic Acid), unit = milligrams
"ascorbicAcid" # Ascorbic Acid, Vit. C, unit = milligrams
]
commodities = [["Wheat Flour (Enriched)", "10 lb."], ["Macaroni", "1 lb."],
["Wheat Cereal (Enriched)", "28 oz."],
["Corn Flakes", "8 oz."], ["Corn Meal", "1 lb."],
["Hominy Grits", "24 oz."], ["Rice", "1 lb."],
["Rolled Oats",
"1 lb."], ["White Bread (Enriched)", "1 lb."],
["Whole Wheat Bread", "1 lb."], ["Rye Bread", "1 lb."],
["Pound Cake", "1 lb."], ["Soda Crackers", "1 lb."],
["Milk", "1 qt."], ["Evaporated Milk (can)", "14.5 oz."],
["Butter", "1 lb."], ["Oleomargarine", "1 lb."],
["Eggs", "1 doz."], ["Cheese (Cheddar)", "1 lb."],
["Cream", "1/2 pt."], ["Peanut Butter", "1 lb."],
["Mayonnaise", "1/2 pt."], ["Crisco", "1 lb."],
["Lard", "1 lb."], ["Sirloin Steak", "1 lb."],
["Round Steak", "1 lb."], ["Rib Roast", "1 lb."],
["Chuck Roast", "1 lb."], ["Plate", "1 lb."],
["Liver (Beef)", "1 lb."], ["Leg of Lamb", "1 lb."],
["Lamb Chops (Rib)", "1 lb."], ["Pork Chops", "1 lb."],
["Pork Loin Roast", "1 lb."], ["Bacon", "1 lb."],
["Ham - smoked", "1 lb."], ["Salt Pork", "1 lb."],
["Roasting Chicken", "1 lb."], ["Veal Cutlets", "1 lb."],
["Salmon, Pink (can)", "16 oz."], ["Apples", "1 lb."],
["Bananas", "1 lb."], ["Lemons", "1 doz."],
["Oranges", "1 doz."], ["Green Beans", "1 lb."],
["Cabbage", "1 lb."], ["Carrots", "1 bunch"],
["Celery", "1 stalk"], ["Lettuce", "1 head"],
["Onions", "1 lb."], ["Potatoes", "15 lb."],
["Spinach", "1 lb."], ["Sweet Potatoes", "1 lb."],
["Peaches (can)",
"No. 2 1/2"], ["Pears (can)", "No. 2 1/2,"],
["Pineapple (can)", "No. 2 1/2"],
["Asparagus (can)", "No. 2"],
["Grean Beans (can)", "No. 2"],
["Pork and Beans (can)", "16 oz."], ["Corn (can)", "No. 2"],
["Peas (can)", "No. 2"], ["Tomatoes (can)", "No. 2"],
["Tomato Soup (can)", "10 1/2 oz."],
["Peaches, Dried", "1 lb."], ["Prunes, Dried", "1 lb."],
["Raisins, Dried", "15 oz."], ["Peas, Dried", "1 lb."],
["Lima Beans, Dried", "1 lb."],
["Navy Beans, Dried", "1 lb."], ["Coffee", "1 lb."],
["Tea", "1/4 lb."], ["Cocoa", "8 oz."],
["Chocolate", "8 oz."], ["Sugar", "10 lb."],
["Corn Sirup", "24 oz."], ["Molasses", "18 oz."],
["Strawberry Preserve", "1 lb."]]
# price and weight are the two first columns
data = [
[36.0, 12600.0, 44.7, 1411.0, 2.0, 365.0, 0.0, 55.4, 33.3, 441.0, 0.0],
[14.1, 3217.0, 11.6, 418.0, 0.7, 54.0, 0.0, 3.2, 1.9, 68.0, 0.0],
[24.2, 3280.0, 11.8, 377.0, 14.4, 175.0, 0.0, 14.4, 8.8, 114.0, 0.0],
[7.1, 3194.0, 11.4, 252.0, 0.1, 56.0, 0.0, 13.5, 2.3, 68.0, 0.0],
[4.6, 9861.0, 36.0, 897.0, 1.7, 99.0, 30.9, 17.4, 7.9, 106.0, 0.0],
[8.5, 8005.0, 28.6, 680.0, 0.8, 80.0, 0.0, 10.6, 1.6, 110.0, 0.0],
[7.5, 6048.0, 21.2, 460.0, 0.6, 41.0, 0.0, 2.0, 4.8, 60.0, 0.0],
[7.1, 6389.0, 25.3, 907.0, 5.1, 341.0, 0.0, 37.1, 8.9, 64.0, 0.0],
[7.9, 5742.0, 15.6, 488.0, 2.5, 115.0, 0.0, 13.8, 8.5, 126.0, 0.0],
[9.1, 4985.0, 12.2, 484.0, 2.7, 125.0, 0.0, 13.9, 6.4, 160.0, 0.0],
[9.2, 4930.0, 12.4, 439.0, 1.1, 82.0, 0.0, 9.9, 3.0, 66.0, 0.0],
[24.8, 1829.0, 8.0, 130.0, 0.4, 31.0, 18.9, 2.8, 3.0, 17.0, 0.0],
[15.1, 3004.0, 12.5, 288.0, 0.5, 50.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[11.0, 8867.0, 6.1, 310.0, 10.5, 18.0, 16.8, 4.0, 16.0, 7.0, 177.0],
[6.7, 6035.0, 8.4, 422.0, 15.1, 9.0, 26.0, 3.0, 23.5, 11.0, 60.0],
[20.8, 1473.0, 10.8, 9.0, 0.2, 3.0, 44.2, 0.0, 0.2, 2.0, 0.0],
[16.1, 2817.0, 20.6, 17.0, 0.6, 6.0, 55.8, 0.2, 0.0, 0.0, 0.0],
[32.6, 1857.0, 2.9, 238.0, 1.0, 52.0, 18.6, 2.8, 6.5, 1.0, 0.0],
[24.2, 1874.0, 7.4, 448.0, 16.4, 19.0, 28.1, 0.8, 10.3, 4.0, 0.0],
[14.1, 1689.0, 3.5, 49.0, 1.7, 3.0, 16.9, 0.6, 2.5, 0.0, 17.0],
[17.9, 2534.0, 15.7, 661.0, 1.0, 48.0, 0.0, 9.6, 8.1, 471.0, 0.0],
[16.7, 1198.0, 8.6, 18.0, 0.2, 8.0, 2.7, 0.4, 0.5, 0.0, 0.0],
[20.3, 2234.0, 20.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[9.8, 4628.0, 41.7, 0.0, 0.0, 0.0, 0.2, 0.0, 0.5, 5.0, 0.0],
[39.6, 1145.0, 2.9, 166.0, 0.1, 34.0, 0.2, 2.1, 2.9, 69.0, 0.0],
[36.4, 1246.0, 2.2, 214.0, 0.1, 32.0, 0.4, 2.5, 2.4, 87.0, 0.0],
[29.2, 1553.0, 3.4, 213.0, 0.1, 33.0, 0.0, 0.0, 2.0, 0.0, 0.0],
[22.6, 2007.0, 3.6, 309.0, 0.2, 46.0, 0.4, 1.0, 4.0, 120.0, 0.0],
[14.6, 3107.0, 8.5, 404.0, 0.2, 62.0, 0.0, 0.9, 0.0, 0.0, 0.0],
[26.8, 1692.0, 2.2, 333.0, 0.2, 139.0, 169.2, 6.4, 50.8, 316.0, 525.0],
[27.6, 1643.0, 3.1, 245.0, 0.1, 20.0, 0.0, 2.8, 3.0, 86.0, 0.0],
[36.6, 1239.0, 3.3, 140.0, 0.1, 15.0, 0.0, 1.7, 2.7, 54.0, 0.0],
[30.7, 1477.0, 3.5, 196.0, 0.2, 80.0, 0.0, 17.4, 2.7, 60.0, 0.0],
[24.2, 1874.0, 4.4, 249.0, 0.3, 37.0, 0.0, 18.2, 3.6, 79.0, 0.0],
[25.6, 1772.0, 10.4, 152.0, 0.2, 23.0, 0.0, 1.8, 1.8, 71.0, 0.0],
[27.4, 1655.0, 6.7, 212.0, 0.2, 31.0, 0.0, 9.9, 3.3, 50.0, 0.0],
[16.0, 2835.0, 18.8, 164.0, 0.1, 26.0, 0.0, 1.4, 1.8, 0.0, 0.0],
[30.3, 1497.0, 1.8, 184.0, 0.1, 30.0, 0.1, 0.9, 1.8, 68.0, 46.0],
[42.3, 1072.0, 1.7, 156.0, 0.1, 24.0, 0.0, 1.4, 2.4, 57.0, 0.0],
[13.0, 3489.0, 5.8, 705.0, 6.8, 45.0, 3.5, 1.0, 4.9, 209.0, 0.0],
[4.4, 9072.0, 5.8, 27.0, 0.5, 36.0, 7.3, 3.6, 2.7, 5.0, 544.0],
[6.1, 4982.0, 4.9, 60.0, 0.4, 30.0, 17.4, 2.5, 3.5, 28.0, 498.0],
[26.0, 2380.0, 1.0, 21.0, 0.5, 14.0, 0.0, 0.5, 0.0, 4.0, 952.0],
[30.9, 4439.0, 2.2, 40.0, 1.1, 18.0, 11.1, 3.6, 1.3, 10.0, 1993.0],
[7.1, 5750.0, 2.4, 138.0, 3.7, 80.0, 69.0, 4.3, 5.8, 37.0, 862.0],
[3.7, 8949.0, 2.6, 125.0, 4.0, 36.0, 7.2, 9.0, 4.5, 26.0, 5369.0],
[4.7, 6080.0, 2.7, 73.0, 2.8, 43.0, 188.5, 6.1, 4.3, 89.0, 608.0],
[7.3, 3915.0, 0.9, 51.0, 3.0, 23.0, 0.9, 1.4, 1.4, 9.0, 313.0],
[8.2, 2247.0, 0.4, 27.0, 1.1, 22.0, 112.4, 1.8, 3.4, 11.0, 449.0],
[3.6, 11844.0, 5.8, 166.0, 3.8, 59.0, 16.6, 4.7, 5.9, 21.0, 1184.0],
[
34.0, 16810.0, 14.3, 336.0, 1.8, 118.0, 6.7, 29.4, 7.1, 198.0,
2522.0
],
[8.1, 4592.0, 1.1, 106.0, 0.0, 138.0, 918.4, 5.7, 13.8, 33.0, 2755.0],
[5.1, 7649.0, 9.6, 138.0, 2.7, 54.0, 290.7, 8.4, 5.4, 83.0, 1912.0],
[16.8, 4894.0, 3.7, 20.0, 0.4, 10.0, 21.5, 0.5, 1.0, 31.0, 196.0],
[20.4, 4030.0, 3.0, 8.0, 0.3, 8.0, 0.8, 0.8, 0.8, 5.0, 81.0],
[21.3, 3993.0, 2.4, 16.0, 0.4, 8.0, 2.0, 2.8, 0.8, 7.0, 399.0],
[27.7, 1945.0, 0.4, 33.0, 0.3, 12.0, 16.3, 1.4, 2.1, 17.0, 272.0],
[10.0, 5386.0, 1.0, 54.0, 2.0, 65.0, 53.9, 1.6, 4.3, 32.0, 431.0],
[7.1, 6389.0, 7.5, 364.0, 4.0, 134.0, 3.5, 8.3, 7.7, 56.0, 0.0],
[10.4, 5452.0, 5.2, 136.0, 0.2, 16.0, 12.0, 1.6, 2.7, 42.0, 218.0],
[13.8, 4109.0, 2.3, 136.0, 0.6, 45.0, 34.9, 4.9, 2.5, 37.0, 370.0],
[8.6, 6263.0, 1.3, 63.0, 0.7, 38.0, 53.2, 3.4, 2.5, 36.0, 1253.0],
[7.6, 3917.0, 1.6, 71.0, 0.6, 43.0, 57.9, 3.5, 2.4, 67.0, 862.0],
[15.7, 2889.0, 8.5, 87.0, 1.7, 173.0, 86.8, 1.2, 4.3, 55.0, 57.0],
[9.0, 4284.0, 12.8, 99.0, 2.5, 154.0, 85.7, 3.9, 4.3, 65.0, 257.0],
[9.4, 4524.0, 13.5, 104.0, 2.5, 136.0, 4.5, 6.3, 1.4, 24.0, 136.0],
[7.9, 5742.0, 20.0, 1367.0, 4.2, 345.0, 2.9, 28.7, 18.4, 162.0, 0.0],
[8.9, 5097.0, 17.4, 1055.0, 3.7, 459.0, 5.1, 26.9, 38.2, 93.0, 0.0],
[5.9, 7688.0, 26.9, 1691.0, 11.4, 792.0, 0.0, 38.4, 24.6, 217.0, 0.0],
[22.4, 2025.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 5.1, 50.0, 0.0],
[17.4, 652.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.3, 42.0, 0.0],
[8.6, 2637.0, 8.7, 237.0, 3.0, 72.0, 0.0, 2.0, 11.9, 40.0, 0.0],
[16.2, 1400.0, 8.0, 77.0, 1.3, 39.0, 0.0, 0.9, 3.4, 14.0, 0.0],
[51.7, 8773.0, 34.9, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[13.7, 4996.0, 14.7, 0.0, 0.5, 74.0, 0.0, 0.0, 0.0, 5.0, 0.0],
[13.6, 3752.0, 9.0, 0.0, 10.3, 244.0, 0.0, 1.9, 7.5, 146.0, 0.0],
[20.5, 2213.0, 6.4, 11.0, 0.4, 7.0, 0.2, 0.2, 0.4, 3.0, 0.0]
]
# recommended daily allowance for a moderately active man
allowance = [3.0, 70.0, 0.8, 12.0, 5.0, 1.8, 2.7, 18.0, 75.0]
#
# variables
#
x = [solver.NumVar(0, 1000, "x[%i]" % i) for i in C]
x_cost = [solver.NumVar(0, 1000, "x_cost[%i]" % i) for i in C]
quant = [solver.NumVar(0, 1000, "quant[%i]" % i) for i in C]
# total food bill
total_cost = solver.NumVar(0, 1000, "total_cost")
# cost per day, to minimize
cost = solver.Sum(x)
#
# constraints
#
solver.Add(total_cost == days * cost) # cost per year
for c in C:
solver.Add(x_cost[c] == days * x[c])
solver.Add(quant[c] == 100.0 * days * x[c] / data[c][0])
# nutrient balance
for n in range(2, num_nutrients + 2):
solver.Add(
solver.Sum([data[c][n] * x[c] for c in C]) >= allowance[n - 2])
objective = solver.Minimize(cost)
#
# solution and search
#
solver.Solve()
print()
print("Cost = %0.2f" % solver.Objective().Value())
# print 'Cost:', cost.SolutionValue()
print("Total cost: %0.2f" % total_cost.SolutionValue())
print()
for i in C:
if x[i].SolutionValue() > 0:
print("%-21s %-11s %0.2f %0.2f" %
(commodities[i][0], commodities[i][1],
x_cost[i].SolutionValue(), quant[i].SolutionValue()))
print()
print("walltime :", solver.WallTime(), "ms")
if sol == "CBC":
print("iterations:", solver.Iterations())
def ortools_solve(facilities, customers, time_limit=None):
print('Num facilities {}'.format(len(facilities)))
print('Num customers {}'.format(len(customers)))
if time_limit is None:
time_limit = 1000 * 60 # 1 minute
solver = pywraplp.Solver('SolveIntegerProblem',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# x_i = 1 iff facility i is chosen
x = [] # 1xN
# y_ij = 1 iff custome j is assigned to facility i
y = [[] for x in range(len(facilities))] # NxM
for i in range(len(facilities)):
x.append(solver.BoolVar('x{}'.format(i)))
for j in range(len(customers)):
y[i].append(solver.BoolVar('y{},{}'.format(i, j)))
print('x variable with dim {}'.format(len(x)))
print('y variable with dim {}x{}'.format(len(y), len(y[0])))
# total demand to 1 facility <= its capacity
for i in range(len(facilities)):
constraint = solver.Constraint(0.0, facilities[i].capacity)
for j in range(len(customers)):
constraint.SetCoefficient(y[i][j], customers[j].demand)
# exactly one facility per customer
for j in range(len(customers)):
constraint = solver.Constraint(1.0, 1.0)
for i in range(len(facilities)):
constraint.SetCoefficient(y[i][j], 1.0)
# y_ij can be 1 only x_i is 1
for i in range(len(facilities)):
for j in range(len(customers)):
constraint = solver.Constraint(-solver.infinity(), 0.0)
constraint.SetCoefficient(y[i][j], 1.0)
constraint.SetCoefficient(x[i], -1.0)
# objective
objective = solver.Objective()
objective.SetMinimization()
for i in range(len(facilities)):
objective.SetCoefficient(x[i], facilities[i].setup_cost)
for j in range(len(customers)):
objective.SetCoefficient(
y[i][j], length(customers[j].location, facilities[i].location))
print('Number of variables =', solver.NumVariables())
print('Number of constraints =', solver.NumConstraints())
solver.set_time_limit(time_limit)
print('OR-Tools starts at {}'.format(datetime.now().time()))
result_status = solver.Solve()
print(result_status)
# The problem has an optimal solution.
#assert result_status == pywraplp.Solver.OPTIMAL
#assert solver.VerifySolution(1e-7, True)
val = solver.Objective().Value()
y_val = [[] for x in range(len(facilities))] # NxM
assignment = []
for i in range(len(facilities)):
for j in range(len(customers)):
y_val[i].append(int(y[i][j].solution_value()))
y_val = numpy.array(y_val)
for j in range(len(customers)):
assignment.append(numpy.where(y_val[:, j] == 1)[0][0])
return val, assignment
def optimize_shift_mip():
start = time.time()
solver = pywraplp.Solver('schedule_shifts',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# ナース人数
num_nurses = 8
# シフト数（甲番、乙番、丙番の３つ）
num_shifts = 3
# 最適化対象期間
num_days = 3
# ナースどうしの相性 縦軸ナースn1 横軸ナースn2
NerseCompatibility = [[0, 100, 100, 100, 100, 100, 100, 100],
[0, 0, 100, 90, 90, 90, 90, 90],
[0, 0, 0, 110, 80, 95, 92, 92],
[0, 0, 0, 0, 80, 95, 90, 90],
[0, 0, 0, 0, 0, 105, 90, 90],
[0, 0, 0, 0, 0, 0, 90, 90],
[0, 0, 0, 0, 0, 0, 0, 90], [0, 0, 0, 0, 0, 0, 0, 0]]
# 各ナースの入れるシフト
AssignableShifts = [[0, 1], [0, 1], [0, 1], [1, 2], [1, 2], [1, 2], [2],
[2]]
logging.info(['AssignableShifts:', AssignableShifts])
logging.info(['num_nurses:', num_nurses])
logging.info(['NerseCompatibility:', NerseCompatibility])
logging.info(['num_shifts:', num_shifts])
# ナースnを日dのシフトsに割り当てる決定変数
x = {}
for n1 in range(num_nurses):
for d1 in range(num_days):
for s1 in range(num_shifts):
x[n1, d1, s1] = solver.IntVar(0, 1, "x%d,%d,%d" % (n1, d1, s1))
# 各ナースは1週間に5日以上、6日以下働く制約
for n1 in range(num_nurses):
#solver.Add(solver.Sum([x[n1,d1,s1] for d in range(num_days) for s in range(num_shifts)]) >= 1)
solver.Add(
solver.Sum([
x[n1, d1, s1] for d1 in range(num_days)
for s1 in range(num_shifts)
]) <= 6)
pass
# 各日のシフトsには2人のナースがアサインされる
for d1 in range(num_days):
for s1 in range(num_shifts):
#solver.Add(solver.Sum([x[n1,d1,s1] for n1 in range(num_nurses)]) <= 2)
solver.Add(
solver.Sum([x[n1, d1, s1] for n1 in range(num_nurses)]) == 2)
pass
# 各ナースは、一日に1回しかアサインできない
for n in range(num_nurses):
for d in range(num_days):
solver.Add(
solver.Sum([x[n, d, s] for s in range(num_shifts)]) <= 1)
pass
# ナースのアサイン可能なシフトの制約
for n in range(num_nurses):
for d in range(num_days):
for s in range(num_shifts):
if s not in AssignableShifts[n]:
solver.Add(x[n, d, s] == 0)
print('Add Constraint x Complete')
# ナースn1をシフトd1s1に、ナースn2をシフトd2s2に割り当てる変数y[n1,d1s1,n2,d2s2]
y = {}
ctr = 0
for n1 in range(num_nurses):
for d1 in range(num_days):
for s1 in range(num_shifts):
for n2 in range(n1, num_nurses): #if n1 < n2:
for d2 in range(num_days):
for s2 in range(num_shifts):
y[n1, d1, s1, n2, d2,
s2] = solver.IntVar(0, 1, 'y(%d)' % (ctr))
ctr += 1
print('Make Y Complete size:', ctr)
# 制約条件1 xとyの関係
for n1 in range(num_nurses):
for d1 in range(num_days):
for s1 in range(num_shifts):
for n2 in range(n1, num_nurses): #if n1 < n2:
for d2 in range(num_days):
for s2 in range(num_shifts):
# z >= x + y - 1, z <= x, z <= y の 3 本の不等式による x, y, z に関する 0-1 表現
solver.Add(
x[n1, d1, s1] >= y[n1, d1, s1, n2, d2, s2])
solver.Add(
x[n2, d2, s2] >= y[n1, d1, s1, n2, d2, s2])
solver.Add((x[n1, d1, s1] + x[n2, d2, s2] -
1) <= y[n1, d1, s1, n2, d2, s2])
#n1とn2を同じシフトに割り当てたときに１となる行列
IsSameShift = np.zeros(
[num_nurses, num_days, num_shifts, num_nurses, num_days, num_shifts])
for n1 in range(num_nurses):
for d1 in range(num_days):
for s1 in range(num_shifts):
for n2 in range(num_nurses):
for d2 in range(num_days):
for s2 in range(num_shifts):
if n1 < n2 and d1 == d2 and s1 == s2:
IsSameShift[n1, d1, s1, n2, d2, s2] = 1
# iとpが同じグループjqに割り当てられたときの相性を合計する
solver.Maximize(
solver.Sum([
(y[n1, d1, s1, n2, d2, s2] * (NerseCompatibility[n1][n2]) *
IsSameShift[n1, d1, s1, n2, d2, s2]) for n1 in range(num_nurses)
for d1 in range(num_days) for s1 in range(num_shifts)
for n2 in range(n1, num_nurses) #if n1 < n2:
for d2 in range(num_days) for s2 in range(num_shifts)
]))
print("Set Objective Function Complete")
print("Solve Start !!!!")
status = solver.Solve()
x_solval = {}
if status == solver.OPTIMAL or status == solver.FEASIBLE:
print('Solution:')
obj = solver.Objective()
for d1 in range(num_days):
print("Day", d1)
for s1 in range(num_shifts):
for n1 in range(num_nurses):
x_solval[n1, d1, s1] = x[n1, d1, s1].SolutionValue()
if x_solval[n1, d1, s1] > 0.5:
print("shift", s1, "assigned nurse", n1)
logging.info(
["Day", d1, "shift", s1, "assigned nurse", n1])
print('obj value: = ', obj.Value())
logging.info(['obj.Value():', obj.Value()])
# 各ナースの合計アサイン回数
for n1 in range(num_nurses):
print(
'nurse', n1, 'sum_assign',
np.sum([
x_solval[n1, d1, s1] for s1 in range(num_shifts)
for d1 in range(num_days)
]))
else:
print('Infeasible')
elapsed_time = time.time() - start
print("elapsed_time:{0}".format(elapsed_time) + "[sec]")
logging.info(['elapsed_time:', elapsed_time])
return x_solval, NerseCompatibility, IsSameShift
["E", 160, 158, 161, 0, 10, 1, 0.2]]
num_products = len(max_quantities)
all_products = range(num_products)
num_sets = len(chemical_set)
all_sets = range(num_sets)
# Model
max_set = [
min(max_quantities[q][1] / chemical_set[s][q + 1] for q in all_products
if chemical_set[s][q + 1] != 0.0) for s in all_sets
]
solver = pywraplp.Solver("chemical_set_lp",
pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
set_vars = [solver.NumVar(0, max_set[s], "set_%i" % s) for s in all_sets]
epsilon = solver.NumVar(0, 1000, "epsilon")
for p in all_products:
solver.Add(
sum(chemical_set[s][p + 1] * set_vars[s]
for s in all_sets) <= max_quantities[p][1])
solver.Add(
sum(chemical_set[s][p + 1] * set_vars[s]
for s in all_sets) >= max_quantities[p][1] - epsilon)
solver.Minimize(epsilon)
def run():
# Solver
solver = pywraplp.Solver('farm_planning',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# Context
num_cities = 3
num_departments = 5
city_names = ["Bristol", "Brighton", "London"]
benefits = [[10, 15, 10, 20, 5], [10, 20, 15, 15, 15]]
quantities = [[0, 1.0, 1.5, 0], [1.4, 1.2, 0], [0, 2.0], [0.7]]
costs = [[5, 14, 13], [5, 9], [10]]
def get_quantity(a, b):
return quantities[a][b - a - 1]
def get_cost(a, b):
if a > b:
a, b = b, a
return costs[a][b - a]
# Variable
xv = {}
yv = {}
# location
for i in range(num_cities):
for j in range(num_departments):
xv[(i, j)] = solver.BoolVar("x_%d_%d" % (i, j))
# Constraint
# department
for j in range(num_departments):
expr = sum(xv[(i, j)] for i in range(num_cities)) == 1
solver.Add(expr)
# city
for i in range(num_cities - 1):
num = sum(xv[(i, j)] for j in range(num_departments))
solver.Add(num <= 3)
num_london = sum(xv[(2, j)] for j in range(num_departments))
solver.Add(num_london <= 1)
# Object
total_cost = 0
for i in range(num_cities):
for j in range(num_departments - 1):
for k in range(num_cities):
for l in range(j + 1, num_departments):
quant = get_quantity(j, l)
cost = get_cost(i, k)
if quant == 0.0:
continue
var = solver.BoolVar("y_%d_%d_%d_%d" % (i, k, j, l))
expr = var >= xv[(i, j)] + xv[(k, l)] - 1
solver.Add(expr)
solver.Add(var <= xv[(i, j)])
solver.Add(var <= xv[(k, l)])
total_cost += var * quant * cost
yv[(i, j, k, l)] = var
total_benefit = 0
for i in range(num_cities - 1):
for j in range(num_departments):
total_benefit += benefits[i][j] * xv[(i, j)]
solver.Maximize(total_benefit - total_cost)
solver.Solve()
print_solver(solver)
print("Total cost %f benefit %f" % (total_cost.solution_value(), total_benefit.solution_value()))
def print_location():
for i in range(num_cities):
out = "%s: " % city_names[i]
for j in range(num_departments):
out += "\t%d" % xv[(i, j)].solution_value()
print(out)
print_location()
def main(sol='CBC'):
# Create the solver.
# using GLPK
if sol == 'GLPK':
solver = pywraplp.Solver('CoinsGridGLPK',
pywraplp.Solver.GLPK_LINEAR_PROGRAMMING)
else:
# Using CLP
solver = pywraplp.Solver('CoinsGridCLP',
pywraplp.Solver.CLP_LINEAR_PROGRAMMING)
# data
rows = 3
cols = 3
game = [[3.0, -1.0, -3.0], [-2.0, 4.0, -1.0], [-5.0, -6.0, 2.0]]
#
# declare variables
#
#
# row player
#
x1 = [solver.NumVar(0, 1, 'x1[%i]' % i) for i in range(rows)]
v = solver.NumVar(-2, 2, 'v')
for i in range(rows):
solver.Add(v - solver.Sum([x1[j] * game[j][i] for j in range(cols)]) <= 0)
solver.Add(solver.Sum(x1) == 1)
objective = solver.Maximize(v)
solver.Solve()
print()
print('row player:')
print('v = ', solver.Objective().Value())
print('Strategies: ')
for i in range(rows):
print(x1[i].SolutionValue(), end=' ')
print()
print()
#
# For column player:
#
x2 = [solver.NumVar(0, 1, 'x2[%i]' % i) for i in range(cols)]
v2 = solver.NumVar(-2, 2, 'v2')
for i in range(cols):
solver.Add(v2 - solver.Sum([x2[j] * game[i][j] for j in range(rows)]) >= 0)
solver.Add(solver.Sum(x2) == 1)
objective = solver.Minimize(v2)
solver.Solve()
print()
print('column player:')
print('v2 = ', solver.Objective().Value())
print('Strategies: ')
for i in range(rows):
print(x2[i].SolutionValue(), end=' ')
print()
print()
print('walltime :', solver.WallTime(), 'ms')
print('iterations:', solver.Iterations())
print()
def apply(c, Aub, bub, Aeq, beq, parameters=None):
"""
Gets the overall solution of the problem
Parameters
------------
c
c parameter of the algorithm
Aub
A_ub parameter of the algorithm
bub
b_ub parameter of the algorithm
Aeq
A_eq parameter of the algorithm
beq
b_eq parameter of the algorithm
parameters
Possible parameters of the algorithm
Returns
-------------
sol
Solution of the LP problem by the given algorithm
"""
if parameters is None:
parameters = {}
require_ilp = exec_utils.get_param_value(Parameters.REQUIRE_ILP, parameters, False)
solver = pywraplp.Solver('LinearProgrammingExample',
pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
solver.Clear()
solver.SuppressOutput()
x_list = []
for i in range(Aub.shape[1]):
if require_ilp:
x = solver.IntVar(-solver.infinity(), solver.infinity(), "x_" + str(i))
else:
x = solver.NumVar(-solver.infinity(), solver.infinity(), "x_" + str(i))
x_list.append(x)
objective = solver.Objective()
for j in range(len(c)):
if abs(c[j]) > MIN_THRESHOLD:
objective.SetCoefficient(x_list[j], c[j])
for i in range(Aub.shape[0]):
ok = False
for j in range(Aub.shape[1]):
if abs(Aub[i, j]) > MIN_THRESHOLD:
ok = True
break
if ok:
constraint = solver.Constraint(-solver.infinity(), bub[i])
for j in range(Aub.shape[1]):
if abs(Aub[i, j]) > MIN_THRESHOLD:
constraint.SetCoefficient(x_list[j], Aub[i, j])
if Aeq is not None and beq is not None:
for i in range(Aeq.shape[0]):
ok = False
for j in range(Aeq.shape[1]):
if abs(Aeq[i, j]) > MIN_THRESHOLD:
ok = True
break
if ok:
constraint = solver.Constraint(beq[i], beq[i])
for j in range(Aeq.shape[1]):
if abs(Aeq[i, j]) > MIN_THRESHOLD:
constraint.SetCoefficient(x_list[j], Aeq[i, j])
objective.SetMinimization()
status = solver.Solve()
if status == 0:
sol_value = 0.0
for j in range(len(c)):
if abs(c[j]) > MIN_THRESHOLD:
sol_value = sol_value + c[j] * x_list[j].solution_value()
points = [x.solution_value() for x in x_list]
else:
return None
return {"c": c, "x_list": x_list, "sol_value": sol_value, "points": points}
# Shipping Cost from factory to customer
suppliers = set(supplier_stock.index)
customers = set(customer_demand.columns)
factories = set(shipping_costs.index)
products = set(production_capacity.index)
materials = set(supplier_stock.columns)
print(suppliers)
print(customers)
print(products)
print(materials)
## Simple Version with only production cost per factory and consumer need
solver = pywraplp.Solver('LPWrapper',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# Materials sent from supplier to each factory
# simplify problem to Products sent from factories to consumers and shipping costs
# products produced by factories and sent to users
products_sent_from_factories = {}
for factory in factories:
for product in products:
c = None
if not pd.isna(production_capacity[factory][product]):
c = solver.Constraint(0,
float(production_capacity[factory][product]))
for customer in customers:
if not pd.isna(production_capacity[factory][product]):
def solve_by_or_tools(inp, is_adj_matrix, distance_matrix, dict_constant):
solver = pywraplp.Solver('wsn',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
num_all_vertex = len(inp.all_vertex)
connect_matrix = {}
muy = {}
delta = {}
gamma = {}
y = {}
print("num all vertex: ", num_all_vertex)
a = [0 for _ in range(num_all_vertex)]
b = [0 for _ in range(num_all_vertex)]
e = [0 for _ in range(num_all_vertex)]
for i in range(num_all_vertex):
a[i] = solver.BoolVar('a[%i]' % i)
b[i] = solver.BoolVar('b[%i]' % i)
e[i] = solver.BoolVar('e[%i]' % i)
for j in range(num_all_vertex):
connect_matrix[i, j] = solver.BoolVar('C[%i,%i]' % (i, j))
muy[i, j] = solver.BoolVar('muy[%i,%i]' % (i, j))
delta[i, j] = solver.BoolVar('delta[%i,%i]' % (i, j))
gamma[i, j] = solver.IntVar(0, inp.num_of_sensors,
'gamma[%i,%i]' % (i, j))
for k in range(1, num_all_vertex):
for j in range(num_all_vertex):
for i in range(num_all_vertex):
y[i, j, k] = solver.BoolVar('y[%i, %i, %i]' % (i, j, k))
# Objective
solver.Minimize(
solver.Sum(
muy[i, j] *
(dict_constant['E_TX'] +
dict_constant['epsilon_fs'] * distance_matrix[i, j]**2) +
delta[i, j] *
(dict_constant['epsilon_fs'] * distance_matrix[i, j]**2) +
gamma[i, j] * (dict_constant['E_RX'] + dict_constant['E_DA'])
for i in range(num_all_vertex) for j in range(num_all_vertex)))
# Constraints
# r16
solver.Add(
solver.Sum(connect_matrix[0, j]
for j in range(inp.num_of_relay_positions +
1)) <= inp.num_of_relays)
# rang buoc tinh lien thong va chu trinh cua cay
# r17
solver.Add(
solver.Sum(connect_matrix[i, j] for i in range(num_all_vertex)
for j in range(num_all_vertex)) == inp.num_of_relays +
inp.num_of_sensors)
# r20
for j in range(num_all_vertex):
for i in range(num_all_vertex):
solver.Add(connect_matrix[i, j] <= is_adj_matrix[i][j])
for i in range(1, num_all_vertex):
# r3
solver.Add(inp.num_of_sensors * b[i] >= solver.Sum(
connect_matrix[i, j] for j in range(num_all_vertex)))
# r4
solver.Add(b[i] <= solver.Sum(connect_matrix[i, j]
for j in range(num_all_vertex)))
for i in range(inp.num_of_relay_positions + 1, num_all_vertex):
# r1
solver.Add(inp.num_of_sensors *
(1 - a[i]) >= solver.Sum(connect_matrix[i, j]
for j in range(num_all_vertex)))
# r2
solver.Add(1 - a[i] <= solver.Sum(connect_matrix[i, j]
for j in range(num_all_vertex)))
for i in range(1, inp.num_of_relay_positions + 1):
solver.Add(a[i] == 0)
for i in range(num_all_vertex):
# r5
solver.Add(e[i] == a[i] + b[i])
for j in range(1, num_all_vertex):
# r6
solver.Add(e[j] == solver.Sum(connect_matrix[i, j]
for i in range(num_all_vertex)))
for i in range(num_all_vertex):
for j in range(num_all_vertex):
# r7
solver.Add(muy[i, j] <= a[j])
# r8
solver.Add(muy[i, j] <= connect_matrix[i, j])
# r9
solver.Add(muy[i, j] >= a[j] + connect_matrix[i, j] - 1)
for i in range(num_all_vertex):
for j in range(num_all_vertex):
# r10
solver.Add(delta[i, j] <= b[j])
# r11
solver.Add(delta[i, j] <= connect_matrix[i, j])
# r12
solver.Add(delta[i, j] >= b[j] + connect_matrix[i, j] - 1)
for i in range(num_all_vertex):
for j in range(num_all_vertex):
# r13
solver.Add(
gamma[i, j] <= solver.Sum(connect_matrix[j, k]
for k in range(num_all_vertex)))
# r14
solver.Add(gamma[i, j] <= inp.num_of_sensors * delta[i, j])
# r15
solver.Add(
gamma[i, j] >= solver.Sum(connect_matrix[j, k]
for k in range(num_all_vertex)) -
inp.num_of_sensors * (1 - delta[i, j]))
for j in range(num_all_vertex):
# r16
solver.Add(
solver.Sum(connect_matrix[i, j]
for i in range(num_all_vertex)) <= 1)
# hop constrained
# r21
for k in range(1, num_all_vertex):
for j in range(1, num_all_vertex):
if j != k:
solver.Add(
solver.Sum(y[i, j, k] for i in range(num_all_vertex)) -
solver.Sum(y[j, i, k]
for i in range(1, num_all_vertex)) == 0)
# r22
for j in range(1, num_all_vertex):
solver.Add(
solver.Sum(y[i, j, j] for i in range(num_all_vertex)) == e[j])
solver.Add(
solver.Sum(y[0, i, j] for i in range(1, num_all_vertex)) == e[j])
# r23
for k in range(1, num_all_vertex):
solver.Add(
solver.Sum(y[i, j, k] for i in range(num_all_vertex)
for j in range(1, num_all_vertex)) <= inp.max_hop)
# r24
for k in range(1, num_all_vertex):
for i in range(num_all_vertex):
for j in range(1, num_all_vertex):
solver.Add(y[i, j, k] <= connect_matrix[i, j])
print('Number of constraints =', solver.NumConstraints())
result_status = solver.Solve()
assert result_status == pywraplp.Solver.OPTIMAL
connect_matrix_result = {}
for i in range(num_all_vertex):
for j in range(num_all_vertex):
print(connect_matrix[i, j].solution_value(), end='|')
connect_matrix_result[i, j] = connect_matrix[i, j].solution_value()
if j == inp.num_of_relay_positions:
print("|", end='|')
print()
if i == inp.num_of_relay_positions:
print("---" * 20)
print("========")
for i in range(num_all_vertex):
for j in range(num_all_vertex):
print(muy[i, j].solution_value(), end='|')
if j == inp.num_of_relay_positions:
print("|", end='|')
print()
if i == inp.num_of_relay_positions:
print("---" * 20)
print('*******')
for i in range(num_all_vertex):
for j in range(num_all_vertex):
print(delta[i, j].solution_value(), end='|')
if j == inp.num_of_relay_positions:
print("|", end='|')
print()
if i == inp.num_of_relay_positions:
print("---" * 20)
print('*******')
for i in range(num_all_vertex):
for j in range(num_all_vertex):
print(gamma[i, j].solution_value(), end='|')
if j == inp.num_of_relay_positions:
print("|", end='|')
print()
if i == inp.num_of_relay_positions:
print("---" * 20)
print("========")
print('optimal value = ', solver.Objective().Value())
print()
print("Time = ", solver.WallTime(), " milliseconds")
return dict_constant["l"] * solver.Objective().Value(
), connect_matrix_result, solver.WallTime()
def main():
#[start input]
with open('Data_Schedule_Foolball.txt') as f:
N = [int(x) for x in next(f).split()][0]
print(N)
#get value
d = []
for i in range(N):
d.append([int(x) for x in next(f).split()])
print(d)
f.close()
#[end input]
# Create the mip solver with the CBC backend.
solver = pywraplp.Solver('simple_mip_program',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
#Da san nha
x = [[[
solver.IntVar(0, 1, 'x[%i][%i][%i]' % (i, j, t))
for t in range(2 * N - 1)
] for j in range(N)] for i in range(N)]
#Da san khach
y = [[[
solver.IntVar(0, 1, 'y[%i][%i][%i]' % (i, j, t))
for t in range(2 * N - 1)
] for j in range(N)] for i in range(N)]
#Bien xac dinh di chuyen
F = [[[[
solver.IntVar(0, 1, 'F[%i][%i][%i][%i]' % (i, j, k, t))
for t in range(2 * N - 2)
] for k in range(N)] for j in range(N)] for i in range(N)]
#Bien quang duong cua i
D = [solver.IntVar(0, solver.infinity(), 'D[%i]' % (i)) for i in range(N)]
#[Constraints]
for i in range(N):
for j in range(N):
if i != j:
# i vs j 1 lan duy nhat tren san i
solver.Add(sum(x[i][j][t] for t in range(2 * N - 1)) == 1)
#i vs j 1 lan duy nhat tran san j
solver.Add(sum(y[i][j][t] for t in range(2 * N - 1)) == 1)
for t in range(2 * N - 1):
#x[i][i][t] = 0 y[i][i][t] = 0
if i == j:
solver.Add(x[i][j][t] == 0)
solver.Add(y[i][j][t] == 0)
#Rang buoc san khach san nha
solver.Add(x[i][j][t] == y[j][i][t])
for k in range(N):
for t in range(2 * N - 2):
#2 tran lien tiep i da tren san nha
if i == j and i == k:
solver.Add(
2 * F[i][j][k][t] >= sum(x[i][h][t]
for h in range(N)) +
sum(x[i][h][t + 1] for h in range(N)) - 1)
solver.Add(
2 * F[i][j][k][t] <= sum(x[i][h][t]
for h in range(N)) +
sum(x[i][h][t + 1] for h in range(N)))
#tran dau san nha, tran sau san khach
if i == j and i != k:
solver.Add(
2 * F[i][j][k][t] >= sum(x[i][h][t]
for h in range(N)) +
y[i][k][t + 1] - 1)
solver.Add(
2 * F[i][j][k][t] <= sum(x[i][h][t]
for h in range(N)) +
y[i][k][t + 1])
#tran dau san khach, tran sau san nha
if i != j and i == k:
solver.Add(2 * F[i][j][k][t] >= y[i][j][t] +
sum(x[i][h][t + 1] for h in range(N)) - 1)
solver.Add(2 * F[i][j][k][t] <= y[i][j][t] +
sum(x[i][h][t + 1] for h in range(N)))
#2 tran san khach
if i != j and i != k:
solver.Add(2 * F[i][j][k][t] >= y[i][j][t] +
y[i][k][t + 1] - 1)
solver.Add(
2 * F[i][j][k][t] <= y[i][j][t] + y[i][k][t + 1])
for t in range(2 * N - 1):
#moi tuan chi da 1 tran vs moi i
solver.Add(sum((x[i][j][t] + y[i][j][t]) for j in range(N)) == 1)
#Tinh khoang cach
solver.Add(D[i] == sum(F[i][j][k][t] * d[j][k] for j in range(N)
for k in range(N) for t in range(2 * N - 2)))
#Ham muc tieu
solver.Minimize(solver.Sum(D))
status = solver.Solve()
print('status:', status, pywraplp.Solver.OPTIMAL,
pywraplp.Solver.INFEASIBLE)
if status == pywraplp.Solver.OPTIMAL:
print('Objective value =', solver.Objective().Value())
for i in range(N):
for j in range(N):
for t in range(2 * N - 1):
print(x[i][j][t].name(), '=', x[i][j][t].solution_value())
else:
print('problem does not have an optimal solution')
def solve(self):
# uses Mixed Integer Programming assignment algorithm as described here:
# https://developers.google.com/optimization/assignment/assignment_mip
solver = pywraplp.Solver('SolveAssignmentProblemMIP',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
self.solver = solver
x = {}
self.x = x
day_constraints = defaultdict(list)
category_constraints = defaultdict(list)
prep_constraints = defaultdict(list)
def services_left(worker):
return max(worker.services_cap -
self.assignments.get(worker.id, 0) -
self.exceptions.get(worker.id, 0), 0)
t = timeit_inline("Creating worker list")
t.start()
workers = []
worker_indices = defaultdict(set)
worker_set = set()
i = 0
for service in self.services:
for slot in service.serviceslots:
for worker in slot.workers:
if worker in worker_set:
continue
worker_set.add(worker)
workers.append(worker)
try:
for w in worker:
worker_indices[w].add(i)
except TypeError:
worker_indices[worker].add(i)
i += 1
worker_caps = []
for worker in workers:
cap = calculate_worker_value(worker, services_left, min)
worker_caps.append(cap)
num_workers = len(workers)
t.end()
t = timeit_inline("Creating task list")
t.start()
tasks = []
num_tasks = 0
task_size = []
for service in self.services:
for slot in service.serviceslots:
tasks.append((service, slot))
task_size.append(slot.workers_required if slot.gender != 'X' else 1)
day_constraints[service.weekday].append(num_tasks)
category_constraints[service.category].append(num_tasks)
if PREP in service.category.name:
prep_constraints[PREP].append(num_tasks)
num_tasks += 1
t.end()
self.tasks = tasks
def sick_level_func(w):
return float(max(10 - w.health, 1))
cost = []
t = timeit_inline("Creating cost")
t.start()
for i, w in enumerate(workers):
sick_level = calculate_worker_value(w, sick_level_func, sum)
freqs = calculate_worker_value(
w,
lambda w: w.weighted_service_frequency,
lambda s: sum(s, Counter())
)
c = []
for service, slot in tasks:
c.append(freqs.get(service.category, 0) +
sick_level / 10 -
slot.worker_group.assign_priority)
cost.append(c)
t.end()
self.workers = workers
t = timeit_inline("Initializing worker, task grid")
t.start()
for i in range(num_workers):
for j in range(num_tasks):
slot = tasks[j][1]
is_valid_choice = workers[i] in slot.workers
if is_valid_choice:
x[i, j] = solver.BoolVar('Bool %s, %s' % (workers[i], tasks[j][1]))
else:
x[i, j] = solver.IntVar(0, 0, '0: %i, %i' % (i, j))
t.end()
t = timeit_inline("Adding worker workload constraint")
t.start()
for i in range(num_workers):
indices = worker_indices[workers[i]]
solver.Add(solver.Sum(x[ind, j] for j in
range(num_tasks) for ind in indices) <= worker_caps[i])
t.end()
t = timeit_inline("Adding task has correct amount of workers constraint")
t.start()
for j in range(num_tasks):
c = task_size[j]
solver.Add(solver.Sum([x[i, j] for i in range(num_workers)]) <= c)
t.end()
t = timeit_inline("Adding one task per day constraint")
t.start()
for day, constrained_tasks in day_constraints.items():
for i in range(num_workers):
indices = worker_indices[workers[i]]
solver.Add(solver.Sum(x[ind, j] for j in constrained_tasks
for ind in indices) <= MAX_SERVICES_PER_DAY)
t.end()
t = timeit_inline("Adding two task categories per week constraint")
t.start()
for _, constrained_tasks in category_constraints.items():
for i in range(num_workers):
indices = worker_indices[workers[i]]
solver.Add(solver.Sum(x[ind, j] for j in constrained_tasks
for ind in indices) <= MAX_SERVICE_CATEGORY_PER_WEEK)
t.end()
t = timeit_inline("Adding one prep per week constraint")
t.start()
constrained_tasks = prep_constraints[PREP]
for i in range(num_workers):
indices = worker_indices[workers[i]]
solver.Add(solver.Sum(x[ind, j] for j in constrained_tasks
for ind in indices) <= MAX_PREPS_PER_WEEK)
t.end()
t = timeit_inline("Minimizing unfilled services, service uniformity")
t.start()
diffs = []
for j in range(num_tasks):
worker_count = solver.Sum(x[i, j] for i in range(num_workers))
diffs.append(task_size[j] - worker_count)
c = solver.Sum(x[i, j] * cost[i][j]
for i in range(num_workers)
for j in range(num_tasks))
solver.Minimize(1000 * solver.Sum(diffs) + c)
t.end()
t = timeit_inline("Solving MIP")
t.start()
status = solver.Solve()
t.end()
print('Total cost = ', self.solver.Objective().Value())
return status
def solution_function(test_num, test_input, general_input):
data = test_input[test_num]
N = data['N']
amounts = data['amounts']
solver = pywraplp.Solver('SolveQueen',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
placements = {c: [None for _ in range(N)] for c in colors}
objective = solver.Objective()
# init variables and objective
for i in range(N):
for color in colors:
placements[color][i] = solver.IntVar(0, 1, color + ":i" + str(i))
objective.SetCoefficient(placements[color][i], 1)
# one at any place constraint
for i in range(N):
constraint = solver.Constraint(1, 1)
for color in colors:
constraint.SetCoefficient(placements[color][i], 1)
# input constraints
for color in colors:
constraint = solver.Constraint(amounts[color], amounts[color])
for i in range(N):
constraint.SetCoefficient(placements[color][i], 1)
# adjacent similar constraint
for i in range(N):
# R
constraint = solver.Constraint(0, 1)
for color in ['R', 'O', 'V']:
constraint.SetCoefficient(placements[color][i], 1)
constraint.SetCoefficient(placements[color][(i + 1) % N], 1)
# B
constraint = solver.Constraint(0, 1)
for color in ['B', 'G', 'V']:
constraint.SetCoefficient(placements[color][i], 1)
constraint.SetCoefficient(placements[color][(i + 1) % N], 1)
# Y
constraint = solver.Constraint(0, 1)
for color in ['Y', 'O', 'G']:
constraint.SetCoefficient(placements[color][i], 1)
constraint.SetCoefficient(placements[color][(i + 1) % N], 1)
objective.SetMaximization()
# Solve!
status = solver.Solve()
if status == solver.OPTIMAL:
answer = ''
for i in range(N):
for color in colors:
if placements[color][i].solution_value() == 1:
answer += color
else: # No optimal solution was found.
answer = 'IMPOSSIBLE'
print('Case #{}: {}'.format(test_num + 1, answer))
def __init__(self, cacheOptTimes=False, staticOptTimes=False, **specs):
#initialize the prototype survey
SurveySimulation.__init__(self, **specs)
assert isinstance(staticOptTimes, bool), 'staticOptTimes must be boolean.'
self.staticOptTimes = staticOptTimes
self._outspec['staticOptTimes'] = self.staticOptTimes
assert isinstance(cacheOptTimes, bool), 'cacheOptTimes must be boolean.'
self._outspec['cacheOptTimes'] = cacheOptTimes
#some global defs
self.detmode = filter(lambda mode: mode['detectionMode'] == True, self.OpticalSystem.observingModes)[0]
self.ohTimeTot = self.Observatory.settlingTime + self.detmode['syst']['ohTime']
self.maxTime = self.TimeKeeping.missionLife*self.TimeKeeping.missionPortion
self.constraints = {'type':'ineq',
'fun': lambda x: self.maxTime.to(u.d).value - np.sum(x[x*u.d > 0.1*u.s]) -
np.sum(x*u.d > 0.1*u.s).astype(float)*self.ohTimeTot.to(u.d).value,
'jac':lambda x: np.ones(len(x))*-1.}
self.t0 = None
if cacheOptTimes:
#Generate cache Name########################################################################
cachefname = self.cachefname + 't0'
if os.path.isfile(cachefname):
self.vprint("Loading cached t0 from %s"%cachefname)
with open(cachefname, 'rb') as f:
self.t0 = pickle.load(f)
sInds = np.arange(self.TargetList.nStars)
fZ = np.array([self.ZodiacalLight.fZ0.value]*len(sInds))*self.ZodiacalLight.fZ0.unit
self.scomp0 = -self.objfun(self.t0.to(u.d).value,sInds,fZ)
if self.t0 is None:
#find nominal background counts for all targets in list
_, Cbs, Csps = self.OpticalSystem.Cp_Cb_Csp(self.TargetList, range(self.TargetList.nStars),
self.ZodiacalLight.fZ0, self.ZodiacalLight.fEZ0, 25.0, self.WAint, self.detmode)
#find baseline solution with dMagLim-based integration times
self.vprint('Finding baseline fixed-time optimal target set.')
t0 = self.OpticalSystem.calc_intTime(self.TargetList, range(self.TargetList.nStars),
self.ZodiacalLight.fZ0, self.ZodiacalLight.fEZ0, self.dMagint, self.WAint, self.detmode)
comp0 = self.Completeness.comp_per_intTime(t0, self.TargetList, range(self.TargetList.nStars),
self.ZodiacalLight.fZ0, self.ZodiacalLight.fEZ0, self.WAint, self.detmode, C_b=Cbs, C_sp=Csps)
solver = pywraplp.Solver('SolveIntegerProblem',pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
xs = [ solver.IntVar(0.0,1.0, 'x'+str(j)) for j in range(len(comp0)) ]
#constraint is x_i*t_i < maxtime
constraint = solver.Constraint(-solver.infinity(),self.maxTime.to(u.day).value)
for j,x in enumerate(xs):
constraint.SetCoefficient(x, t0[j].to(u.day).value + self.ohTimeTot.to(u.day).value)
#objective is max x_i*comp_i
objective = solver.Objective()
for j,x in enumerate(xs):
objective.SetCoefficient(x, comp0[j])
objective.SetMaximization()
cpres = solver.Solve()
x0 = np.array([x.solution_value() for x in xs])
self.scomp0 = np.sum(comp0*x0)
self.t0 = t0
#now find the optimal eps baseline and use whichever gives you the highest starting completeness
self.vprint('Finding baseline fixed-eps optimal target set.')
def totCompfeps(eps):
compstars,tstars,x = self.inttimesfeps(eps, Cbs.to('1/d').value, Csps.to('1/d').value)
return -np.sum(compstars*x)
epsres = minimize_scalar(totCompfeps,method='bounded',bounds = [0,1],options = {'disp':True})
comp_epsmax,t_epsmax,x_epsmax = self.inttimesfeps(epsres['x'],Cbs.to('1/d').value, Csps.to('1/d').value)
if np.sum(comp_epsmax*x_epsmax) > self.scomp0:
x0 = x_epsmax
self.scomp0 = np.sum(comp_epsmax*x_epsmax)
self.t0 = t_epsmax*u.day
#now optimize the solution
self.vprint('Optimizing baseline integration times.')
sInds = np.arange(self.TargetList.nStars)
fZ = np.array([self.ZodiacalLight.fZ0.value]*len(sInds))*self.ZodiacalLight.fZ0.unit
bounds = [(0,self.maxTime.to(u.d).value) for i in range(len(sInds))]
initguess = x0*self.t0.to(u.d).value
ires = minimize(self.objfun, initguess, jac=self.objfun_deriv, args=(sInds,fZ),
constraints=self.constraints, method='SLSQP', bounds=bounds, options={'maxiter':100,'ftol':1e-4})
assert ires['success'], "Initial time optimization failed."
self.t0 = ires['x']*u.d
self.scomp0 = -ires['fun']
if cacheOptTimes:
with open(cachefname,'wb') as f:
pickle.dump(self.t0, f)
self.vprint("Saved cached optimized t0 to %s"%cachefname)
data = pd.read_csv("../input/santa-workshop-tour-2019/family_data.csv")
columns = data.columns[1:11]
DESIRED = data[columns].values
N_PEOPLE = data["n_people"].values
print("preference data read")
# assignment
submission = pd.read_csv(
"../input/santa-workshop-tour-2019/sample_submission.csv")
assigned_days = submission["assigned_day"].values
print("assignment data read")
# init solver
from ortools.linear_solver import pywraplp
solver = pywraplp.Solver("Optimization preference cost",
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# assign[i][j],
# i in range(5000), j in range(100):
# assign family i to day j
# this would induce the preference cost in object
PCOSTM, B = {}, {}
for fid in range(NUMBER_FAMILIES):
for i in range(NUMBER_DAYS):
B[fid, i] = solver.BoolVar("")
PCOSTM[fid, i] = (COST_PER_FAMILY[-1] +
N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[-1])
for i in range(10):
PCOSTM[fid, DESIRED[fid][i] -
1] = (COST_PER_FAMILY[i] +
def main(sol='CBC'):
# Create the solver.
print('Solver: ', sol)
# using GLPK
if sol == 'GLPK':
solver = pywraplp.Solver(
'CoinsGridGLPK', pywraplp.Solver.GLPK_MIXED_INTEGER_PROGRAMMING)
else:
# Using CBC
solver = pywraplp.Solver('CoinsGridCBC',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
#
# data
#
n = 15
start = 0 # start node
end = 14 # end node
M = 999 # a large number
nodes = [
'8,0,0', # start
'5,0,3',
'5,3,0',
'2,3,3',
'2,5,1',
'7,0,1',
'7,1,0',
'4,1,3',
'3,5,0',
'3,2,3',
'6,2,0',
'6,0,2',
'1,5,2',
'1,4,3',
'4,4,0' # goal!
]
# distance
d = [[M, 1, M, M, M, M, M, M, 1, M, M, M, M, M, M],
[M, M, 1, M, M, M, M, M, M, M, M, M, M, M, M],
[M, M, M, 1, M, M, M, M, 1, M, M, M, M, M, M],
[M, M, M, M, 1, M, M, M, M, M, M, M, M, M, M],
[M, M, M, M, M, 1, M, M, 1, M, M, M, M, M, M],
[M, M, M, M, M, M, 1, M, M, M, M, M, M, M, M],
[M, M, M, M, M, M, M, 1, 1, M, M, M, M, M, M],
[M, M, M, M, M, M, M, M, M, M, M, M, M, M, 1],
[M, M, M, M, M, M, M, M, M, 1, M, M, M, M, M],
[M, 1, M, M, M, M, M, M, M, M, 1, M, M, M, M],
[M, M, M, M, M, M, M, M, M, M, M, 1, M, M, M],
[M, 1, M, M, M, M, M, M, M, M, M, M, 1, M, M],
[M, M, M, M, M, M, M, M, M, M, M, M, M, 1, M],
[M, 1, M, M, M, M, M, M, M, M, M, M, M, M, 1],
[M, M, M, M, M, M, M, M, M, M, M, M, M, M, M]]
#
# variables
#
# requirements (right hand statement)
rhs = [solver.IntVar(-1, 1, 'rhs[%i]' % i) for i in range(n)]
x = {}
for i in range(n):
for j in range(n):
x[i, j] = solver.IntVar(0, 1, 'x[%i,%i]' % (i, j))
out_flow = [solver.IntVar(0, 1, 'out_flow[%i]' % i) for i in range(n)]
in_flow = [solver.IntVar(0, 1, 'in_flow[%i]' % i) for i in range(n)]
# length of path, to be minimized
z = solver.Sum(
[d[i][j] * x[i, j] for i in range(n) for j in range(n) if d[i][j] < M])
#
# constraints
#
for i in range(n):
if i == start:
solver.Add(rhs[i] == 1)
elif i == end:
solver.Add(rhs[i] == -1)
else:
solver.Add(rhs[i] == 0)
# outflow constraint
for i in range(n):
solver.Add(out_flow[i] == solver.Sum(
[x[i, j] for j in range(n) if d[i][j] < M]))
# inflow constraint
for j in range(n):
solver.Add(in_flow[j] == solver.Sum(
[x[i, j] for i in range(n) if d[i][j] < M]))
# inflow = outflow
for i in range(n):
solver.Add(out_flow[i] - in_flow[i] == rhs[i])
# objective
objective = solver.Minimize(z)
#
# solution and search
#
solver.Solve()
print()
print('z: ', int(solver.Objective().Value()))
t = start
while t != end:
print(nodes[t], '->', end=' ')
for j in range(n):
if x[t, j].SolutionValue() == 1:
print(nodes[j])
t = j
break
print()
print('walltime :', solver.WallTime(), 'ms')
if sol == 'CBC':
print('iterations:', solver.Iterations())
def main():
# Commodity, Unit, 1939 price (cents), Calories, Protein (g), Calcium (g), Iron (mg),
# Vitamin A (IU), Thiamine (mg), Riboflavin (mg), Niacin (mg), Ascorbic Acid (mg)
data = [
[
'Wheat Flour (Enriched)', '10 lb.', 36, 44.7, 1411, 2, 365, 0,
55.4, 33.3, 441, 0
], ['Macaroni', '1 lb.', 14.1, 11.6, 418, 0.7, 54, 0, 3.2, 1.9, 68, 0],
[
'Wheat Cereal (Enriched)', '28 oz.', 24.2, 11.8, 377, 14.4, 175, 0,
14.4, 8.8, 114, 0
],
['Corn Flakes', '8 oz.', 7.1, 11.4, 252, 0.1, 56, 0, 13.5, 2.3, 68, 0],
[
'Corn Meal', '1 lb.', 4.6, 36.0, 897, 1.7, 99, 30.9, 17.4, 7.9,
106, 0
],
[
'Hominy Grits', '24 oz.', 8.5, 28.6, 680, 0.8, 80, 0, 10.6, 1.6,
110, 0
], ['Rice', '1 lb.', 7.5, 21.2, 460, 0.6, 41, 0, 2, 4.8, 60, 0],
[
'Rolled Oats', '1 lb.', 7.1, 25.3, 907, 5.1, 341, 0, 37.1, 8.9, 64,
0
],
[
'White Bread (Enriched)', '1 lb.', 7.9, 15.0, 488, 2.5, 115, 0,
13.8, 8.5, 126, 0
],
[
'Whole Wheat Bread', '1 lb.', 9.1, 12.2, 484, 2.7, 125, 0, 13.9,
6.4, 160, 0
], ['Rye Bread', '1 lb.', 9.1, 12.4, 439, 1.1, 82, 0, 9.9, 3, 66, 0],
['Pound Cake', '1 lb.', 24.8, 8.0, 130, 0.4, 31, 18.9, 2.8, 3, 17, 0],
['Soda Crackers', '1 lb.', 15.1, 12.5, 288, 0.5, 50, 0, 0, 0, 0, 0],
['Milk', '1 qt.', 11, 6.1, 310, 10.5, 18, 16.8, 4, 16, 7, 177],
[
'Evaporated Milk (can)', '14.5 oz.', 6.7, 8.4, 422, 15.1, 9, 26, 3,
23.5, 11, 60
], ['Butter', '1 lb.', 30.8, 10.8, 9, 0.2, 3, 44.2, 0, 0.2, 2, 0],
['Oleomargarine', '1 lb.', 16.1, 20.6, 17, 0.6, 6, 55.8, 0.2, 0, 0, 0],
['Eggs', '1 doz.', 32.6, 2.9, 238, 1.0, 52, 18.6, 2.8, 6.5, 1, 0],
[
'Cheese (Cheddar)', '1 lb.', 24.2, 7.4, 448, 16.4, 19, 28.1, 0.8,
10.3, 4, 0
], ['Cream', '1/2 pt.', 14.1, 3.5, 49, 1.7, 3, 16.9, 0.6, 2.5, 0, 17],
[
'Peanut Butter', '1 lb.', 17.9, 15.7, 661, 1.0, 48, 0, 9.6, 8.1,
471, 0
],
['Mayonnaise', '1/2 pt.', 16.7, 8.6, 18, 0.2, 8, 2.7, 0.4, 0.5, 0, 0],
['Crisco', '1 lb.', 20.3, 20.1, 0, 0, 0, 0, 0, 0, 0, 0],
['Lard', '1 lb.', 9.8, 41.7, 0, 0, 0, 0.2, 0, 0.5, 5, 0],
[
'Sirloin Steak', '1 lb.', 39.6, 2.9, 166, 0.1, 34, 0.2, 2.1, 2.9,
69, 0
],
[
'Round Steak', '1 lb.', 36.4, 2.2, 214, 0.1, 32, 0.4, 2.5, 2.4, 87,
0
], ['Rib Roast', '1 lb.', 29.2, 3.4, 213, 0.1, 33, 0, 0, 2, 0, 0],
['Chuck Roast', '1 lb.', 22.6, 3.6, 309, 0.2, 46, 0.4, 1, 4, 120, 0],
['Plate', '1 lb.', 14.6, 8.5, 404, 0.2, 62, 0, 0.9, 0, 0, 0],
[
'Liver (Beef)', '1 lb.', 26.8, 2.2, 333, 0.2, 139, 169.2, 6.4,
50.8, 316, 525
],
['Leg of Lamb', '1 lb.', 27.6, 3.1, 245, 0.1, 20, 0, 2.8, 3.9, 86, 0],
[
'Lamb Chops (Rib)', '1 lb.', 36.6, 3.3, 140, 0.1, 15, 0, 1.7, 2.7,
54, 0
],
['Pork Chops', '1 lb.', 30.7, 3.5, 196, 0.2, 30, 0, 17.4, 2.7, 60, 0],
[
'Pork Loin Roast', '1 lb.', 24.2, 4.4, 249, 0.3, 37, 0, 18.2, 3.6,
79, 0
], ['Bacon', '1 lb.', 25.6, 10.4, 152, 0.2, 23, 0, 1.8, 1.8, 71, 0],
['Ham, smoked', '1 lb.', 27.4, 6.7, 212, 0.2, 31, 0, 9.9, 3.3, 50, 0],
['Salt Pork', '1 lb.', 16, 18.8, 164, 0.1, 26, 0, 1.4, 1.8, 0, 0],
[
'Roasting Chicken', '1 lb.', 30.3, 1.8, 184, 0.1, 30, 0.1, 0.9,
1.8, 68, 46
],
['Veal Cutlets', '1 lb.', 42.3, 1.7, 156, 0.1, 24, 0, 1.4, 2.4, 57, 0],
[
'Salmon, Pink (can)', '16 oz.', 13, 5.8, 705, 6.8, 45, 3.5, 1, 4.9,
209, 0
], ['Apples', '1 lb.', 4.4, 5.8, 27, 0.5, 36, 7.3, 3.6, 2.7, 5, 544],
['Bananas', '1 lb.', 6.1, 4.9, 60, 0.4, 30, 17.4, 2.5, 3.5, 28, 498],
['Lemons', '1 doz.', 26, 1.0, 21, 0.5, 14, 0, 0.5, 0, 4, 952],
[
'Oranges', '1 doz.', 30.9, 2.2, 40, 1.1, 18, 11.1, 3.6, 1.3, 10,
1998
],
[
'Green Beans', '1 lb.', 7.1, 2.4, 138, 3.7, 80, 69, 4.3, 5.8, 37,
862
], ['Cabbage', '1 lb.', 3.7, 2.6, 125, 4.0, 36, 7.2, 9, 4.5, 26, 5369],
[
'Carrots', '1 bunch', 4.7, 2.7, 73, 2.8, 43, 188.5, 6.1, 4.3, 89,
608
], ['Celery', '1 stalk', 7.3, 0.9, 51, 3.0, 23, 0.9, 1.4, 1.4, 9, 313],
['Lettuce', '1 head', 8.2, 0.4, 27, 1.1, 22, 112.4, 1.8, 3.4, 11, 449],
['Onions', '1 lb.', 3.6, 5.8, 166, 3.8, 59, 16.6, 4.7, 5.9, 21, 1184],
[
'Potatoes', '15 lb.', 34, 14.3, 336, 1.8, 118, 6.7, 29.4, 7.1, 198,
2522
],
[
'Spinach', '1 lb.', 8.1, 1.1, 106, 0, 138, 918.4, 5.7, 13.8, 33,
2755
],
[
'Sweet Potatoes', '1 lb.', 5.1, 9.6, 138, 2.7, 54, 290.7, 8.4, 5.4,
83, 1912
],
[
'Peaches (can)', 'No. 2 1/2', 16.8, 3.7, 20, 0.4, 10, 21.5, 0.5, 1,
31, 196
],
[
'Pears (can)', 'No. 2 1/2', 20.4, 3.0, 8, 0.3, 8, 0.8, 0.8, 0.8, 5,
81
],
[
'Pineapple (can)', 'No. 2 1/2', 21.3, 2.4, 16, 0.4, 8, 2, 2.8, 0.8,
7, 399
],
[
'Asparagus (can)', 'No. 2', 27.7, 0.4, 33, 0.3, 12, 16.3, 1.4, 2.1,
17, 272
],
[
'Green Beans (can)', 'No. 2', 10, 1.0, 54, 2, 65, 53.9, 1.6, 4.3,
32, 431
],
[
'Pork and Beans (can)', '16 oz.', 7.1, 7.5, 364, 4, 134, 3.5, 8.3,
7.7, 56, 0
],
[
'Corn (can)', 'No. 2', 10.4, 5.2, 136, 0.2, 16, 12, 1.6, 2.7, 42,
218
],
[
'Peas (can)', 'No. 2', 13.8, 2.3, 136, 0.6, 45, 34.9, 4.9, 2.5, 37,
370
],
[
'Tomatoes (can)', 'No. 2', 8.6, 1.3, 63, 0.7, 38, 53.2, 3.4, 2.5,
36, 1253
],
[
'Tomato Soup (can)', '10 1/2 oz.', 7.6, 1.6, 71, 0.6, 43, 57.9,
3.5, 2.4, 67, 862
],
[
'Peaches, Dried', '1 lb.', 15.7, 8.5, 87, 1.7, 173, 86.8, 1.2, 4.3,
55, 57
],
[
'Prunes, Dried', '1 lb.', 9, 12.8, 99, 2.5, 154, 85.7, 3.9, 4.3,
65, 257
],
[
'Raisins, Dried', '15 oz.', 9.4, 13.5, 104, 2.5, 136, 4.5, 6.3,
1.4, 24, 136
],
[
'Peas, Dried', '1 lb.', 7.9, 20.0, 1367, 4.2, 345, 2.9, 28.7, 18.4,
162, 0
],
[
'Lima Beans, Dried', '1 lb.', 8.9, 17.4, 1055, 3.7, 459, 5.1, 26.9,
38.2, 93, 0
],
[
'Navy Beans, Dried', '1 lb.', 5.9, 26.9, 1691, 11.4, 792, 0, 38.4,
24.6, 217, 0
], ['Coffee', '1 lb.', 22.4, 0, 0, 0, 0, 0, 4, 5.1, 50, 0],
['Tea', '1/4 lb.', 17.4, 0, 0, 0, 0, 0, 0, 2.3, 42, 0],
['Cocoa', '8 oz.', 8.6, 8.7, 237, 3, 72, 0, 2, 11.9, 40, 0],
['Chocolate', '8 oz.', 16.2, 8.0, 77, 1.3, 39, 0, 0.9, 3.4, 14, 0],
['Sugar', '10 lb.', 51.7, 34.9, 0, 0, 0, 0, 0, 0, 0, 0],
['Corn Syrup', '24 oz.', 13.7, 14.7, 0, 0.5, 74, 0, 0, 0, 5, 0],
['Molasses', '18 oz.', 13.6, 9.0, 0, 10.3, 244, 0, 1.9, 7.5, 146, 0],
[
'Strawberry Preserves', '1 lb.', 20.5, 6.4, 11, 0.4, 7, 0.2, 0.2,
0.4, 3, 0
]
]
# 需要的各种营养素最小需求量
nutrients = [['Calories (1000s)', 3], ['Protein (grams)', 70],
['Calcium (grams)', 0.8], ['Iron (mg)', 12],
['Vitamin A (1000 IU)', 5], ['Vitamin B1 (mg)', 1.8],
['Vitamin B2 (mg)', 2.7], ['Niacin (mg)', 18],
['Vitamin C (mg)', 75]]
# 初始化求解器
solver = pywraplp.Solver('SolveStigler',
pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
#
food = [[]] * len(data)
# Objective: minimize the sum of (price-normalized) foods.
objective = solver.Objective()
for i in range(0, len(data)):
food[i] = solver.NumVar(0.0, solver.infinity(),
data[i][0]) # 定义变量：最小值，最大值，名称
objective.SetCoefficient(food[i], 1) # 定义目标函数的变量的系数
# 定义求最大值还是最小值
objective.SetMinimization()
# 定义约束
constraints = [0] * len(nutrients)
for i in range(0, len(nutrients)):
constraints[i] = solver.Constraint(nutrients[i][1], solver.infinity())
for j in range(0, len(data)):
constraints[i].SetCoefficient(food[j], data[j][i + 3])
# 求解
status = solver.Solve()
# 打印结果
if status == solver.OPTIMAL:
# Display the amounts (in dollars) to purchase of each food.
price = 0
num_nutrients = len(data[i]) - 3
nutrients = [0] * (len(data[i]) - 3)
for i in range(0, len(data)):
price += food[i].solution_value()
for nutrient in range(0, num_nutrients):
nutrients[nutrient] += data[i][nutrient +
3] * food[i].solution_value()
if food[i].solution_value() > 0:
print("%s = %f" % (data[i][0], food[i].solution_value()))
print('Optimal annual price: $%.2f' % (365 * price))
else: # No optimal solution was found.
if status == solver.FEASIBLE:
print('A potentially suboptimal solution was found.')
else:
print('The solver could not solve the problem.')
def solve_cutting_stock_with_arc_flow_and_mip():
"""Solve the cutting stock with arc-flow and a MIP solver."""
items = regroup_and_count(DESIRED_LENGTHS)
print('Items:', items)
num_items = len(DESIRED_LENGTHS)
max_capacity = max(POSSIBLE_CAPACITIES)
states, transitions = create_state_graph(items, max_capacity)
print('Dynamic programming has generated', len(states), 'states and',
len(transitions), 'transitions')
incoming_vars = collections.defaultdict(list)
outgoing_vars = collections.defaultdict(list)
incoming_sink_vars = []
item_vars = collections.defaultdict(list)
item_coeffs = collections.defaultdict(list)
start_time = time.time()
solver = pywraplp.Solver('Steel',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
objective_vars = []
objective_coeffs = []
var_index = 0
for outgoing, incoming, item_index, card in transitions:
count = items[item_index][1]
count_var = solver.IntVar(
0, count, 'a%i_i%i_f%i_t%i_c%i' %
(var_index, item_index, incoming, outgoing, card))
var_index += 1
incoming_vars[incoming].append(count_var)
outgoing_vars[outgoing].append(count_var)
item_vars[item_index].append(count_var)
item_coeffs[item_index].append(card)
for state_index, state in enumerate(states):
if state_index == 0:
continue
exit_var = solver.IntVar(0, num_items, 'e%i' % state_index)
outgoing_vars[state_index].append(exit_var)
incoming_sink_vars.append(exit_var)
price = price_usage(state, POSSIBLE_CAPACITIES)
objective_vars.append(exit_var)
objective_coeffs.append(price)
# Flow conservation
for state_index in range(1, len(states)):
solver.Add(
sum(incoming_vars[state_index]) == sum(outgoing_vars[state_index]))
# Flow going out of the source must go in the sink
solver.Add(sum(outgoing_vars[0]) == sum(incoming_sink_vars))
# Items must be placed
for item_index, size_and_count in enumerate(items):
num_arcs = len(item_vars[item_index])
solver.Add(
sum(item_vars[item_index][i] * item_coeffs[item_index][i]
for i in range(num_arcs)) == size_and_count[1])
# Objective is the sum of waste
solver.Minimize(
sum(objective_vars[i] * objective_coeffs[i]
for i in range(len(objective_vars))))
solver.EnableOutput()
status = solver.Solve()
### Output the solution.
if status == pywraplp.Solver.OPTIMAL:
print('Objective value = %f found in %.2f s' %
(solver.Objective().Value(), time.time() - start_time))
else:
print('No solution')
def SteelMillSlabWithMipColumnGeneration(problem):
"""Solves the Steel Mill Slab Problem."""
### Load problem.
(num_slabs, capacities, num_colors, orders) = BuildProblem(problem)
num_orders = len(orders)
num_capacities = len(capacities)
all_slabs = range(num_slabs)
all_colors = range(num_colors)
all_orders = range(len(orders))
print('Solving steel mill with %i orders, %i slabs, and %i capacities' %
(num_orders, num_slabs, num_capacities - 1))
# Compute auxilliary data.
widths = [x[0] for x in orders]
colors = [x[1] for x in orders]
max_capacity = max(capacities)
loss_array = [
min(x for x in capacities if x >= c) - c
for c in range(max_capacity + 1)
]
### Model problem.
# Generate all valid slabs (columns)
start = time.time()
unsorted_valid_slabs = CollectValidSlabs(capacities, colors, widths,
loss_array, all_colors)
# Sort slab by descending load/loss. Remove duplicates.
valid_slabs = sorted(unsorted_valid_slabs,
key=lambda c: 1000 * c[-1] + c[-2])
num_valid_slabs = len(valid_slabs)
all_valid_slabs = range(num_valid_slabs)
generate = time.time()
print(' - %i valid slab combinations generated in %f s' %
(num_valid_slabs, generate - start))
# create model and decision variables.
solver = pywraplp.Solver('Steel', pywraplp.Solver.BOP_INTEGER_PROGRAMMING)
selected = [
solver.IntVar(0.0, 1.0, 'selected_%i' % i) for i in all_valid_slabs
]
for order in all_orders:
solver.Add(
sum(selected[i] for i in all_valid_slabs
if valid_slabs[i][order]) == 1)
# Redundant constraint (sum of loads == sum of widths).
solver.Add(
sum(selected[i] * valid_slabs[i][-1]
for i in all_valid_slabs) == sum(widths))
# Objective.
solver.Minimize(
sum(selected[i] * valid_slabs[i][-2] for i in all_valid_slabs))
status = solver.Solve()
### Output the solution.
if status == pywraplp.Solver.OPTIMAL:
print('Objective value = %f found in %f s' %
(solver.Objective().Value(), time.time() - generate))
else:
print('No solution')
solver.Solve()
print('Solution:')
print('Objective value =', objective.Value())
print('x =', x.solution_value())
print('y =', y.solution_value())
if __name__ == '__main__': #http://azuuun-memorandum.hatenablog.com/entry/2015/05/09/002549
main()
#linear practice
from ortools.linear_solver import pywraplp
solver = pywraplp.Solver('simple_lp_program',
pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
#create variables
x = solver.NumVar(0, solver.infinity(), "x")
y = solver.NumVar(0, solver.infinity(), "y")
#create constraint(制約)
#constraint 1
constraint0 = solver.Constraint(-solver.infinity(), 14)
constraint0.SetCoefficient(x, 1)
constraint0.SetCoefficient(y, 2)
#Constraint 2
constraint1 = solver.Constraint(0, solver.infinity())
constraint1.SetCoefficient(x, 3)
constraint1.SetCoefficient(y, -1)
def main():
a, b = [2, 3], 5
s = pywraplp.Solver('Test Box', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
x = [s.NumVar(-1, 6, ''), s.NumVar(-3, 5, '')]
bounds = bounds_on_box(a, x, b)
print(bounds == [-16, 22])
from ortools.linear_solver import pywraplp
# Initialisiere und definiere den Solver
solver = pywraplp.Solver('MIP Standort',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# PARAMETERDEFINITION
# Fixkosten
f = [10, 20, 10, 30, 12, 17]
# Transportkosten
c = [[10, 5, 10, 16, 9, 16, 14, 15], [16, 13, 14, 11, 7, 15, 19, 8],
[16, 16, 11, 17, 9, 17, 16, 6], [15, 14, 9, 7, 7, 5, 11, 18],
[16, 13, 9, 20, 13, 8, 10, 9], [13, 14, 4, 17, 8, 7, 4, 10]]
# Kapazitäten
b = [100, 70, 110, 90, 120, 75]
# Nachfragen
d = [50, 70, 55, 22, 35, 71, 90, 100]
# Anzahl Standorte
I = len(f)
# Anzahl Kunden
J = len(d)
# VARIABLENDEKLARATION
x = [[]] * I
for i in range(I):
def run(league, remove, args):
solver = pywraplp.Solver('FD',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
all_players = []
with open(args.salary_file, 'rb') as csvfile:
csvdata = csv.DictReader(csvfile)
def generate_player(pos, row):
return Player(pos,
row['Name'],
row['Salary'],
possible_positions=row['Position'],
multi_position=('/' in row['Position']),
team=row['teamAbbrev'],
matchup=row['GameInfo'],
average_score=float(row.get('AvgPointsPerGame', 0)),
lock=(args.locked and row['Name'] in args.locked))
for row in csvdata:
for pos in row['Position'].split('/'):
all_players.append(generate_player(pos, row))
if args.w and args.season and args.historical == _YES:
print('Fetching {} season data for all players...'.format(args.season))
for p in all_players:
p.set_historical(int(args.w), int(args.season))
if args.po_location and args.po:
with open(args.po_location, 'rb') as csvfile:
csvdata = csv.DictReader(csvfile)
for row in csvdata:
player = filter(lambda p: p.name in row['Name'], all_players)
if player:
player[0].projected_ownership_pct = float(row['%'])
with open(args.projection_file, 'rb') as csvfile:
csvdata = csv.DictReader(csvfile)
# hack for weird defensive formatting
def name_match(row):
def match_fn(p):
if p.pos == 'DST':
return p.name.strip() in row['playername']
return p.name in row['playername']
return match_fn
for row in csvdata:
matching_players = filter(name_match(row), all_players)
if len(matching_players) == 0:
continue
for p in matching_players:
p.proj = float(row['points'])
p.marked = 'Y'
_check_missing_players(all_players, args.sp, args.mp)
# filter based on criteria and previously optimized
# do not include DST or TE projections in min point threshold.
all_players = filter(qc.add_constraints(args, remove), all_players)
if args.no_double_te == _YES:
cons.POSITIONS['NFL'] = cons.get_nfl_positions(te_upper=1)
variables, solution = run_solver(solver, all_players, args)
if solution == solver.OPTIMAL:
roster = RosterSelect().roster_gen(args.l)
roster.projection_source = \
scrapers.scrape_dict[args.source]['readable']
for i, player in enumerate(all_players):
if variables[i].solution_value() == 1:
roster.add_player(player)
print "Optimal roster for: %s" % league
print roster
print
return roster
else:
print("No solution found for command line query. " +
"Try adjusting your query by taking away constraints.")
return None
def main():
"""Solving Assignment Problem with MIP"""
# Instantiate a mixed-integer solver.
solver = pywraplp.Solver('SolveAssignmentProblemMIP',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# Number of teams (h and i)
n = 9
# Number of rooms (j)
r = 3
# Number of timeslots (k)
t = 4
# Number of matches
m = 4
# List of teams
teams = [i for i in range(9)]
x = {}
for h in range(n):
for i in range(n):
for j in range(r):
for k in range(t):
if (h == i):
x[h, i, j,
k] = solver.IntVar(0, 0,
'x[%i,%i,%i,%i]' % (h, i, j, k))
else:
x[h, i, j,
k] = solver.IntVar(0, 1,
'x[%i,%i,%i,%i]' % (h, i, j, k))
# # Objective
# solver.Minimize(solver.Sum([cost[i][j] * x[i,j] for i in range(num_workers)
# for j in range(num_tasks)]))
# Constraints
# 2 Ensures that the matrix is the same across the diagonal
for h in range(n):
for j in range(r):
for k in range(t):
solver.Add((x[h, i, j, k] == x[i, h, j, k]))
# 3 No pair plays each other more than once
for h in range(n - 1):
for i in range(h + 1, n):
solver.Add(
solver.Sum([x[h, i, j, k] for j in range(r)
for k in range(t)]) <= 1)
# 4 No team can be in more than one place at a time
for h in range(n):
for k in range(t):
solver.Add(
solver.Sum([x[h, i, j, k] for i in range(n)
for j in range(r)]) <= 2)
# 5 Each team plays exactly m matches
for i in range(n):
solver.Add(
solver.Sum([
x[h, i, j, k] for j in range(r) for k in range(t)
for h in range(n)
]) == 2 * m)
# 6 Need 3 teams in a room at each timeslot
for j in range(r):
for k in range(t - 1):
solver.Add(
solver.Sum([
x[h, i, j, k] for i in range(n - 1)
for h in range(i + 1, n)
]) == 3)
# Need 3 teams in a room at each timeslot
for g in range(n - 2):
for h in range(g + 1, n - 1):
for i in range(h + 1, n):
solver.Add(
solver.Sum([
x[g, h, j, k] + x[h, i, j, k] + x[g, i, j, k]
for j in range(r) for k in range(t)
]) != 2)
sol = solver.Solve()
print('Total cost = ', solver.Objective().Value())
print()
for h in range(n):
for i in range(n):
for j in range(r):
for k in range(t):
if x[h, i, j, k].solution_value() > 0:
print('teams %i,%i assigned to room %i at time %i.' %
(h, i, j, k))
print()
print("Time = ", solver.WallTime(), " milliseconds")
def optim_main(design_conv, N_conv, design_batt, N_batt, design_vess, N_vess,
Psi_solar, Psi_wind, c_H2_industry, c_H2_mobility, N_d,
path_data):
## Characteristics units
# Conversion - Electrolyzer
prod_rate_min = design_conv[0]
prod_rate_max = design_conv[1]
power_nom = N_conv * design_conv[2]
eff_conv = design_conv[3]
var_Psi_conv = design_conv[4]
# Storage capacity I - Electrochemical battery packs
eff_batt = design_batt[0]
C_batt = N_batt * design_batt[1]
load_min = design_batt[2]
load_max = design_batt[3]
power_max = N_batt * design_batt[4]
# Storage capacity II - H2(gas) storage vessels
eff_vess = design_vess[0]
C_vess = N_vess * design_vess[1]
## Inputs
# Electricity market (spot market)
Eps_spot = import_data_csv(path_data[0]) # [$/Mwh]
# contract I - Industry demand & price
Phi_industry = import_data_csv(path_data[1])
# contract II - H2 stations for mobility & price
Phi_mobility_d = import_data_csv(path_data[2])
# Simulation duration
N_t = 24 * N_d # [] number of iterations
dt = 1 # [hr] duration of time step
Eps_spot = Eps_spot[0:N_t, 1] * 1e-3 # [$/kWh]
Phi_industry = Phi_industry[0:N_t, 1]
Phi_mobility_d = Phi_mobility_d[0:N_d, 1]
Psi_solar = Psi_solar[0:N_t]
Psi_wind = Psi_wind[0:N_t]
# Plotting inputs
# Production
plt.figure(1)
plt.plot(np.arange(N_t), Psi_solar, label='solar')
plt.plot(np.arange(N_t), Psi_wind, label='wind')
plt.xlabel('time [hrs]')
plt.ylabel('production [kW]')
plt.xlim([0, N_t])
plt.ylim([0, 1.1 * max(max(Psi_solar), max(Psi_wind))])
plt.grid()
plt.title('Production of the solar and wind farms')
plt.show()
plt.legend()
plt.figure
# hydrogen demand
plt.figure(2)
plt.subplot(2, 1, 1)
plt.bar(np.arange(N_t), Phi_industry, 0.8, align="edge")
plt.xlabel("hour")
plt.xlim([0, N_t])
plt.ylabel("industry [kg/hr]")
plt.ylim([0, 1.2 * max(Phi_industry)])
plt.gca().yaxis.grid(True)
plt.legend()
plt.show()
plt.title("Mobility and Industry hydrogen contracts")
plt.subplot(2, 1, 2)
plt.bar(np.arange(N_d), Phi_mobility_d, 0.95, align="edge")
plt.xlabel("day")
plt.xlim([0, N_d])
plt.ylabel("mobility [kg/day]")
plt.ylim([0, 1.3 * max(Phi_mobility_d)])
plt.gca().yaxis.grid(True)
plt.legend()
plt.show()
## Initialization
load_batt_0 = C_batt * (
load_max + load_min) / 2 # Initial state of load of the battery park
load_vess_0 = C_vess / 2 # Initial state of load of the hydrogen pressure vessel
## Feasibility analysis
H2_max_prod = N_t * dt * power_nom / eff_conv
# [kg] maximum overall production of H2
H2_demand = dt * sum(Phi_industry[:]) + sum(
Phi_mobility_d[:]) # [kg] required H2 overall
print('max production:', np.round(H2_max_prod, 1), 'kg(H2)')
print('demand:', H2_demand, 'kg(H2)')
if H2_demand > H2_max_prod:
print('UNFEASABLE')
## Optimization
# Instantiate a Glop solver, naming it LinearExample.
s = pywraplp.Solver('Solver_H2_management',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
# for MILP
# Decision variables
Psi_batt_in = N_t * [[]]
# [kWh/hr] Net energy stored in battery at iteration i
Phi_vess_in = N_t * [[]]
# [kg(H2)/hr] Net hydrogen stored in vessel at iteration i
Psi_conv = N_t * [[]]
# [kW] production level of electrolyzer
Psi_grid = N_t * [[]]
# [kW] net inflow from the grid (>0 if electricity bought from the grid)
for i in range(N_t):
Psi_batt_in[i] = s.NumVar(-power_max, power_max,
'Psi_batt_in_' + str(i))
Phi_vess_in[i] = s.NumVar(-s.infinity(), s.infinity(),
'Phi_vess_in_' + str(i))
Psi_conv[i] = s.NumVar(0, power_nom, 'Psi_conv_' + str(i))
Psi_grid[i] = s.NumVar(-s.infinity(), s.infinity(),
'Psi_grid_' + str(i))
# Other variables
Psi_node = N_t * 9 * [[]]
# [kW] Power transfer between the nodes 1, 2, 3, 4 and 8
Phi_node = N_t * 5 * [[]]
# [kg(H2)/hr] Hydrogen transfer between the nodes 5, 6, 7 and 8
Eps_batt = N_t * [[]]
# [kWh] energy stored in the battery
M_vess = N_t * [[]]
# [kg(H2)] mass of hydrogen stored in the vessel
y_conv = N_t * [[]]
# [] Binary variable (=1 if electrolizer is on, 0 otherwise)
y1 = N_t * [[]]
# binary used to model eff_conv=eff_conv(Psi_conv)
y2 = N_t * [[]]
# binary used to model eff_conv=eff_conv(Psi_conv)
y3 = N_t * [[]]
# binary used to model eff_conv=eff_conv(Psi_conv)
Phi_conv = N_t * [[]]
# [kg(H2)/hr] Hydrogen produced by electrolizer
Phi_mobility = N_t * [[]]
# [kg(H2)/hr] distribution of prod for mobility
R = N_t * [[]]
# [$] Net revenue at each time step
for i in range(N_t):
Eps_batt[i] = s.NumVar(load_min * C_batt, load_max * C_batt,
'Eps_batt_' + str(i))
M_vess[i] = s.NumVar(0, C_vess, 'M_vess_' + str(i))
y_conv[i] = s.IntVar(0, 1, 'y_conv' + str(i))
y1[i] = s.IntVar(0, 1, 'y1_' + str(i))
y2[i] = s.IntVar(0, 1, 'y2_' + str(i))
y3[i] = s.IntVar(0, 1, 'y3_' + str(i))
Phi_conv[i] = s.NumVar(0, prod_rate_max * power_nom / eff_conv,
'Phi_conv_' + str(i))
Phi_mobility[i] = s.NumVar(0, s.infinity(), 'Phi_mobility_' + str(i))
R[i] = s.NumVar(-s.infinity(), s.infinity(), 'R' + str(i))
for j in range(9):
Psi_node[N_t * j + i] = s.NumVar(-s.infinity(), s.infinity(),
'Psi_node_' + str(i) + str(j))
for j in range(5):
Phi_node[N_t * j + i] = s.NumVar(-s.infinity(), s.infinity(),
'Phi_node_' + str(i) + str(j))
Eps_batt[0] = s.NumVar(load_batt_0, load_batt_0,
'Eps_batt_00') # initialize battery load
M_vess[0] = s.NumVar(load_vess_0, load_vess_0,
'M_vess_00') # initialize vessel load
Eps_batt[-1] = s.NumVar(load_batt_0, load_batt_0,
'Eps_batt_end') # initialize battery load
M_vess[-1] = s.NumVar(load_vess_0, load_vess_0,
'M_vess_end') # initialize vessel load
# Constraints
# (1) Power balance in between nodes 1, 2, 3, 4 and 8
constraint_power = N_t * [5 * [[]]]
for i in range(N_t):
# solar farm
constraint_power[i][0] = s.Constraint(Psi_solar[i], Psi_solar[i])
constraint_power[i][0].SetCoefficient(Psi_node[N_t * 0 + i], 1)
constraint_power[i][0].SetCoefficient(Psi_node[N_t * 1 + i], 1)
constraint_power[i][0].SetCoefficient(Psi_node[N_t * 2 + i], 1)
# wind farm
constraint_power[i][1] = s.Constraint(Psi_wind[i], Psi_wind[i])
constraint_power[i][0].SetCoefficient(Psi_node[N_t * 3 + i], 1)
constraint_power[i][1].SetCoefficient(Psi_node[N_t * 4 + i], 1)
constraint_power[i][1].SetCoefficient(Psi_node[N_t * 5 + i], 1)
# grid node
constraint_power[i][2] = s.Constraint(0, 0)
constraint_power[i][2].SetCoefficient(Psi_grid[i], -1)
constraint_power[i][2].SetCoefficient(Psi_node[N_t * 0 + i], -1)
constraint_power[i][2].SetCoefficient(Psi_node[N_t * 3 + i], -1)
constraint_power[i][2].SetCoefficient(Psi_node[N_t * 6 + i], 1)
constraint_power[i][2].SetCoefficient(Psi_node[N_t * 7 + i], 1)
# battery pack node
constraint_power[i][3] = s.Constraint(0, 0)
constraint_power[i][3].SetCoefficient(Psi_batt_in[i], -1)
constraint_power[i][3].SetCoefficient(Psi_node[N_t * 1 + i], 1)
constraint_power[i][3].SetCoefficient(Psi_node[N_t * 4 + i], 1)
constraint_power[i][3].SetCoefficient(Psi_node[N_t * 6 + i], 1)
constraint_power[i][3].SetCoefficient(Psi_node[N_t * 8 + i], -1)
# Electrolyzer node
constraint_power[i][4] = s.Constraint(0, 0)
constraint_power[i][4].SetCoefficient(Psi_conv[i], -1)
constraint_power[i][4].SetCoefficient(Psi_node[N_t * 2 + i], 1)
constraint_power[i][4].SetCoefficient(Psi_node[N_t * 5 + i], 1)
constraint_power[i][4].SetCoefficient(Psi_node[N_t * 7 + i], 1)
constraint_power[i][4].SetCoefficient(Psi_node[N_t * 8 + i], 1)
# (2) Hydrogen mass balance between nodes 5, 6, 7 and 8
constraint_h2 = N_t * [4 * [[]]]
for i in range(N_t):
# Industry node
constraint_h2[i][0] = s.Constraint(1, 1)
constraint_h2[i][0].SetCoefficient(Phi_node[N_t * 1 + i],
1 / Phi_industry[i])
constraint_h2[i][0].SetCoefficient(Phi_node[N_t * 4 + i],
-1 / Phi_industry[i])
# Mobility node
constraint_h2[i][1] = s.Constraint(0, 0)
constraint_h2[i][1].SetCoefficient(Phi_mobility[i], -1)
constraint_h2[i][1].SetCoefficient(Phi_node[N_t * 0 + i], 1)
constraint_h2[i][1].SetCoefficient(Phi_node[N_t * 3 + i], -1)
# Hydrogen vessel
constraint_h2[i][2] = s.Constraint(0, 0)
constraint_h2[i][2].SetCoefficient(Phi_vess_in[i], 1)
constraint_h2[i][2].SetCoefficient(Phi_node[N_t * 0 + i], 1)
constraint_h2[i][2].SetCoefficient(Phi_node[N_t * 1 + i], 1)
constraint_h2[i][2].SetCoefficient(Phi_node[N_t * 2 + i], 1)
# Electrolyzer node
constraint_h2[i][3] = s.Constraint(0, 0)
constraint_h2[i][3].SetCoefficient(Phi_conv[i], 1)
constraint_h2[i][3].SetCoefficient(Phi_node[N_t * 2 + i], 1)
constraint_h2[i][3].SetCoefficient(Phi_node[N_t * 3 + i], 1)
constraint_h2[i][3].SetCoefficient(Phi_node[N_t * 4 + i], 1)
# (3) Power storage in the battery park
constraint_batt = N_t * [[]]
for i in range(1, N_t):
constraint_batt[i] = s.Constraint(0, 0)
constraint_batt[i].SetCoefficient(Psi_batt_in[i], -eff_batt * dt)
constraint_batt[i].SetCoefficient(Eps_batt[i - 1], -1)
constraint_batt[i].SetCoefficient(Eps_batt[i], 1)
# (4) Hydrogen storage in the vessel park
constraint_vess = N_t * [[]]
for i in range(1, N_t):
constraint_vess[i] = s.Constraint(0, 0)
constraint_vess[i].SetCoefficient(Phi_vess_in[i - 1], -eff_vess * dt)
constraint_vess[i].SetCoefficient(M_vess[i - 1], -1)
constraint_vess[i].SetCoefficient(M_vess[i], 1)
# (5) Power->Hydrogen conversion in the electrolyzer park
constraint_conv1 = N_t * [2 * [[]]]
constraint_conv2 = N_t * [2 * [[]]]
constraint_conv3 = N_t * [2 * [[]]]
constraint_conv4 = N_t * [[]]
M = 2 * power_nom
for i in range(N_t):
# If Psi_conv>3/4*Psi_nom then eff_conv=eff_conv_nom/0.5
constraint_conv1[i][0] = s.Constraint(-s.infinity(), 3 / 4 * power_nom)
constraint_conv1[i][0].SetCoefficient(Psi_conv[i], 1)
constraint_conv1[i][0].SetCoefficient(y1[i], -1 / 4 * power_nom)
constraint_conv1[i][1] = s.Constraint(-M, s.infinity())
constraint_conv1[i][1].SetCoefficient(Phi_conv[i], -eff_conv / 0.65)
constraint_conv1[i][1].SetCoefficient(Psi_conv[i], 1)
constraint_conv1[i][1].SetCoefficient(y1[i], -M)
# If 1/2*Psi_nom<Psi_conv<3/4*Psi_nom then eff_conv=eff_conv_nom/0.65
constraint_conv2[i][0] = s.Constraint(-s.infinity(), 1 / 2 * power_nom)
constraint_conv2[i][0].SetCoefficient(Psi_conv[i], 1)
constraint_conv2[i][0].SetCoefficient(y2[i], -1 / 4 * power_nom)
constraint_conv2[i][1] = s.Constraint(-M, s.infinity())
constraint_conv2[i][1].SetCoefficient(Phi_conv[i], -eff_conv / 0.85)
constraint_conv2[i][1].SetCoefficient(Psi_conv[i], 1)
constraint_conv2[i][1].SetCoefficient(y2[i], -M)
# If 1/4*Psi_nom<Psi_conv<1/2*Psi_nom then eff_conv=eff_conv_nom/0.85
constraint_conv3[i][0] = s.Constraint(-s.infinity(), 1 / 4 * power_nom)
constraint_conv3[i][0].SetCoefficient(Psi_conv[i], 1)
constraint_conv3[i][0].SetCoefficient(y3[i], -1 / 4 * power_nom)
constraint_conv3[i][1] = s.Constraint(-M, s.infinity())
constraint_conv3[i][1].SetCoefficient(Phi_conv[i], -eff_conv / 0.9)
constraint_conv3[i][1].SetCoefficient(Psi_conv[i], 1)
constraint_conv3[i][1].SetCoefficient(y3[i], -M)
# If Psi_conv<1/4*Psi_nom then eff_conv=eff_conv_nom
constraint_conv4[i] = s.Constraint(0, s.infinity())
constraint_conv4[i].SetCoefficient(Phi_conv[i], -eff_conv)
constraint_conv4[i].SetCoefficient(Psi_conv[i], 1)
# for i in range(N_t):
# # If Psi_conv>3/4*Psi_nom then eff_conv=eff_conv_nom
# constraint_conv1[i] = s.Constraint(0,s.infinity())
# constraint_conv1[i].SetCoefficient(Phi_conv[i],-eff_conv)
# constraint_conv1[i].SetCoefficient(Psi_conv[i],1)
# constraint_conv1[i].SetCoefficient(y1[i],M)
# # If 3/4*Psi_nom>Psi_conv>1/2*Psi_nom then eff_conv=0.85*eff_conv_nom
# constraint_conv2[i][0] = s.Constraint(0,s.infinity())
# constraint_conv2[i][0].SetCoefficient(Psi_conv[i],1)
# constraint_conv2[i][0].SetCoefficient(y1[i],-3/4*power_nom)
# constraint_conv2[i][1] = s.Constraint(0,s.infinity())
# constraint_conv2[i][1].SetCoefficient(Phi_conv[i],-eff_conv/0.85)
# constraint_conv2[i][1].SetCoefficient(Psi_conv[i],1)
# constraint_conv2[i][1].SetCoefficient(y1[i],M)
# # If 1/2*Psi_nom>Psi_conv>1/4*Psi_nom then eff_conv=0.65*eff_conv_nom
# constraint_conv3[i][0] = s.Constraint(0,s.infinity())
# constraint_conv3[i][0].SetCoefficient(Psi_conv[i],1)
# constraint_conv3[i][0].SetCoefficient(y2[i],-1/2*power_nom)
# constraint_conv3[i][1] = s.Constraint(0,s.infinity())
# constraint_conv3[i][1].SetCoefficient(Phi_conv[i],-eff_conv/0.65)
# constraint_conv3[i][1].SetCoefficient(Psi_conv[i],1)
# constraint_conv3[i][1].SetCoefficient(y2[i],M)
# # If Psi_conv<1/2*Psi_nom then eff_conv=0.5*eff_conv_nom
# constraint_conv4[i][0] = s.Constraint(0,s.infinity())
# constraint_conv4[i][0].SetCoefficient(Psi_conv[i],1)
# constraint_conv4[i][0].SetCoefficient(y3[i],-2/4*power_nom)
# constraint_conv4[i][1] = s.Constraint(0,s.infinity())
# constraint_conv4[i][1].SetCoefficient(Phi_conv[i],-eff_conv/0.5)
# constraint_conv4[i][1].SetCoefficient(Psi_conv[i],1)
# constraint_conv4[i][1].SetCoefficient(y3[i],M)
# (6) On/Off policy for the electrolyzer fleet
constraint_on = N_t * [3 * [[]]]
for i in range(N_t):
# Electrolizer turned off if Psi_conv<20%.power_nom
constraint_on[i][0] = s.Constraint(0, s.infinity())
constraint_on[i][0].SetCoefficient(Psi_conv[i], 1)
constraint_on[i][0].SetCoefficient(y_conv[i],
-prod_rate_min * power_nom)
constraint_on[i][1] = s.Constraint(0, s.infinity())
constraint_on[i][1].SetCoefficient(y_conv[i], M)
constraint_on[i][1].SetCoefficient(Psi_conv[i], -1)
constraint_on[i][2] = s.Constraint(0, s.infinity())
constraint_on[i][2].SetCoefficient(y_conv[i], M * eff_conv)
constraint_on[i][2].SetCoefficient(Phi_conv[i], -1)
# (7) Mobility hydrogen contract
constraint_mob = N_d * [[]]
for d in range(N_d):
constraint_mob[d] = s.Constraint(1, 1)
for i in range(24):
constraint_mob[d].SetCoefficient(Phi_mobility[24 * d + i],
1 / Phi_mobility_d[d])
# (8) Constraint electrolyzer production fluctuation
constraint_mgt = N_t * [[]]
for i in range(1, N_t):
constraint_mgt[i] = s.Constraint(-var_Psi_conv * power_nom,
var_Psi_conv * power_nom)
constraint_mgt[i].SetCoefficient(Psi_conv[i], 1)
constraint_mgt[i].SetCoefficient(Psi_conv[i - 1], 1)
# Objective function: Electricity cost = purchase(power_grid) - sales(power_grid) - sales(power_industry)
# H2 revenue stream not accounted for in optimization process since this revenue is independent of the actions taken
# Minimize the cost of purchasing electricity to the grid
objective = s.Objective()
for i in range(N_t):
objective.SetCoefficient(
Psi_node[N_t * 7 + i],
Eps_spot[i]) # net purchase from the grid for the elctrolizer
objective.SetCoefficient(
Psi_node[N_t * 6 + i],
Eps_spot[i]) # net purchase from the grid for the battery park
objective.SetCoefficient(
Psi_node[N_t * 0 + i],
-Eps_spot[i]) # net purchase from the grid for the battery park
objective.SetCoefficient(
Psi_node[N_t * 3 + i],
-Eps_spot[i]) # net purchase from the grid for the battery park
objective.SetMinimization()
## Solve the system
s.Solve()
print('Number of variables =', s.NumVariables())
print('Number of constraints =', s.NumConstraints())
result_status = s.Solve() # solve(s)
if result_status == s.INFEASIBLE:
print('No solution found')
sys.exit()
elif result_status == s.OPTIMAL:
print('Successful solve.')
# The problem has an optimal solution.
print(('Problem solved in %f milliseconds' % s.wall_time()))
# The objective value of the solution.
print(('Optimal cost of power purchase from the grid: $ %f' %
s.Objective().Value()))
## Store useful results
y_conv_opt = np.zeros((N_t, ))
Eps_batt_opt = np.zeros((N_t, ))
M_vess_opt = np.zeros((N_t, ))
Psi_conv_opt = np.zeros((N_t, ))
Phi_conv_opt = np.zeros((N_t, ))
Psi_grid_opt = np.zeros((N_t, ))
R_opt = np.zeros((N_t, ))
for i in range(N_t):
y_conv_opt[i] = y_conv[i].solution_value()
Eps_batt_opt[i] = Eps_batt[i].solution_value()
M_vess_opt[i] = M_vess[i].solution_value()
Psi_conv_opt[i] = Psi_conv[i].solution_value()
Phi_conv_opt[i] = Phi_conv[i].solution_value()
Psi_grid_opt[i] = Psi_grid[i].solution_value()
R_opt[i] = R[i].solution_value()
# Efficiency
Eff_conv = np.zeros((N_t, ))
for i in range(N_t):
if Psi_conv_opt[i] > 0:
Eff_conv[i] = Psi_conv_opt[i] / Phi_conv_opt[i]
# Plotting
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
plt.title('Hydrogen production')
plt.xlim([0, N_t])
ax1.bar(np.arange(N_t), Phi_conv_opt, 0.8, align="center")
ax2.plot(np.arange(N_t), Eff_conv, 'r*', label='efficiency')
ax2.plot(np.arange(N_t), eff_conv * np.ones((N_t, )), 'r--', linewidth=0.5)
ax1.set_xlabel('time [hrs]')
ax1.set_ylabel('H2 produced [kg(H2)/hr]')
ax2.set_ylabel('efficiency [kWh/kg(H2)]')
ax1.set_ylim(0, 1.2 * max(Phi_conv_opt))
ax2.set_ylim(0, 1.2 * eff_conv / 0.5)
plt.grid()
plt.legend()
plt.show()
plt.figure(4)
plt.subplot(2, 1, 1)
plt.bar(np.arange(N_t), Psi_grid_opt / 1e3, 0.8, align="edge")
plt.xlabel("time [hrs]")
# plt.xticks([24*7*5*i for i in range(52)], [5*i for i in range(26)])
plt.xlim([0, 24 * N_d])
plt.ylabel("Power in [MWh/hr]")
plt.ylim([1.2 * min(Psi_grid_opt / 1e3), 1.2 * max(Psi_grid_opt / 1e3)])
plt.gca().yaxis.grid(True)
plt.legend()
plt.show()
plt.title("Net Power purchase from the grid")
plt.subplot(2, 1, 2)
plt.bar(np.arange(N_t), Eps_spot, 0.95, align="edge")
plt.xlabel("time [hr]")
# plt.xticks(H2_dc[0::7*5,0], [5*i for i in range(11)])
plt.xlim([0, 24 * N_d])
plt.ylabel("Power cost [$/kWh]")
plt.ylim([0, 1.3 * max(Eps_spot)])
plt.gca().yaxis.grid(True)
plt.show()
plt.figure(5)
plt.subplot(2, 1, 1)
plt.bar(np.arange(N_t), M_vess_opt, 0.8, align="edge")
plt.xlabel("time [hrs]")
# plt.xticks([24*7*5*i for i in range(52)], [5*i for i in range(26)])
plt.xlim([0, 24 * N_d])
plt.ylabel("H2 vessel [kg(H2)]")
plt.ylim([0, 1.2 * max(M_vess_opt)])
plt.gca().yaxis.grid(True)
plt.legend()
plt.show()
plt.title("Storage behavior")
plt.subplot(2, 1, 2)
plt.bar(np.arange(N_t), Eps_batt_opt, 0.95, align="edge")
plt.xlabel("time [hr]")
# plt.xticks(H2_dc[0::7*5,0], [5*i for i in range(11)])
plt.xlim([0, 24 * N_d])
plt.ylabel("battery [kWh]")
plt.ylim([0, 1.3 * max(Eps_batt_opt)])
plt.gca().yaxis.grid(True)
plt.show()
return [
y_conv_opt, Eps_batt_opt, M_vess_opt, Psi_conv_opt, Phi_conv_opt,
Psi_grid_opt, R_opt
]
def setup_solver(self):
self.solver = pywraplp.Solver('Planning', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
self.setup_variables()
self.setup_constraints()
self.setup_objective()
def optimize_tourney(df, opt_var, max_or_min):
'''
Given a dataframe predictions of match ups, returns dataframe of optimal predictions
'''
# adds variables used for constraints
for c in set(df['Slot']):
df.loc[df['Slot']==c, 'Round_Game_'+c] = 1
df['Round_Game_'+c].fillna(0, inplace=True)
teams = set(list(df['TeamID_Strong']) + list(df['TeamID_Weak']))
def set_value(rnd, win_tm, w_tm, s_tm, r, t):
if rnd==r:
if (w_tm==t or s_tm==t):
return r
if rnd<r:
if win_tm==t:
return -1
return 0
set_value_v = np.vectorize(set_value, excluded=['r', 't'])
for r in set(df['Round']):
for t in teams:
df[str(t)+'_'+str(r)] = set_value_v(df['Round'], df['TeamID_Winner'], df['TeamID_Weak'], df['TeamID_Strong'], r, t)
# creates optimizer object
solver = pywraplp.Solver('SolveIntegerProblem', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
x_list = {}
for i in range(len(df)):
x_list[i] = solver.IntVar(0.0, 1.0, 'x'+str(i))
# add game constraints
for rg in set(df['Slot']):
constraint = solver.Constraint(1, 1)
for i in range(len(df)):
constraint.SetCoefficient(x_list[i], int(df.loc[i, 'Round_Game_'+rg]))
# adds constraint for each team/round
teams = set(list(df['TeamID_Strong']) + list(df['TeamID_Weak']))
for r in set(df['Round']):
for t in teams:
col = str(t)+'_'+str(r)
constraint = solver.Constraint(-50, 1)
for i in range(len(df)):
constraint.SetCoefficient(x_list[i], int(df.loc[i, col]))
# sets objective
opt_vars = opt_var
obj = solver.Objective()
for i in range(len(df)):
obj.SetCoefficient(x_list[i], int(df.loc[i, opt_vars]))
if max_or_min=='max':
obj.SetMaximization()
elif max_or_min=='min':
obj.SetMinimization()
result_status = solver.Solve()
assert result_status==0, 'Error in optimization'
# outputs results
opt_results = df.copy()
for i in range(len(df)):
opt_results.loc[i, 'Chosen'] = x_list[i].solution_value()
opt_results = opt_results.loc[opt_results['Chosen']==1]
return opt_results
