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 # シフト数(甲番、乙番、丙番の3つ) 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を同じシフトに割り当てたときに1となる行列 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