def Model_Test():
n = 4
Cd = 10
Cr = 6
P = 0.5
budget =23
K = 0
d_monitor={ (0,0):1, (0,1): 1, (0,2): 0, (0,3): 0,
(1,0):0, (1,1): 1, (1,2): 0, (1,3): 0,
(2,0):0, (2,1): 0, (2,2): 1, (2,3): 1,
(3,0):0, (3,1): 0, (3,2): 1, (3,3): 0}
v_commu ={ (0,0):1, (0,1): 0, (0,2): 0, (0,3): 0,#无线通讯
(1,0):0, (1,1): 1, (1,2): 1, (1,3): 0,
(2,0):0, (2,1): 0, (2,2): 1, (2,3): 1,
(3,0):0, (3,1): 1, (3,2): 0, (3,3): 1}
edges = [(1,2)] #无线通讯的矩阵中的边
edges = tuplelist(edges)
#print "edges:", edges
#print "d_monitor: ", d_monitor
#print "v_commu: ", v_commu
Min_pollution(P,n,Cd,Cr,budget,d_monitor,v_commu,edges)
My_algo(P,n,Cd,Cr,budget,d_monitor,v_commu,edges)
def __Simulate(self, d_r):
# define the model
model = Model('evaluation_problem')
model.setParam('OutputFlag', 0)
model.modelSense = GRB.MINIMIZE
# decision variables
X = model.addVars(tuplelist(self.roads_Z), vtype=GRB.CONTINUOUS, lb=0.0, name='X')
# objective function
objFunc_penal = sum(d_r) - X.sum()
model.setObjective(objFunc_penal)
# constraints
model.addConstrs(X.sum('*', j) <= d_r[j] for j in range(self.n))
model.addConstrs(X.sum(i, '*') <= self.I[i] for i in range(self.m))
# solve
model.optimize()
# record
return {'d_r': d_r, 'X': {f'{r}': X[r].X for r in self.roads_Z}}
1: 200,
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 300,
8: 0,
9: 0,
10: 500,
11: 0,
12: 200,
13: 0,
14: 0,
15: 0,
16: 0,
17: 1000,
18: 1200
}
precedences = tuplelist([(9, 1), (9, 2), (9, 3), (10, 2), (10, 3), (10, 4),
(11, 3), (11, 4), (11, 5), (12, 4), (12, 5), (12, 6),
(13, 5), (13, 6), (13, 7), (14, 6), (14, 7), (14, 8),
(15, 9), (15, 10), (15, 11), (16, 10), (16, 11),
(16, 12), (17, 11), (17, 12), (17, 13), (18, 12),
(18, 13), (18, 14)])
p = UraniumMineProblem(blocks, costs, values, precedences)
m = UraniumMineModel(p)
m.solve()
m.printSolution()
def _optimize(
families: Iterable[Family],
days: Iterable[Day],
family_index: Mapping[FamilyID, Family],
mip_start: Optional[Assignments],
) -> Solution:
with gurobi.model("santa-19") as model:
assignment_vars = model.addVars(
tuplelist((family.id, family_choice) for family in families
for family_choice in family.choices),
name="x",
vtype=GRB.BINARY,
)
occupancy_vars = model.addVars(
tuplelist((occupancy, day) for day in days
for occupancy in _FEASIBLE_OCCUPANCIES),
name="delta",
vtype=GRB.BINARY,
)
occupancy_pairs = {(o, o_p, d): accounting_cost(o, o_p)
for o in _FEASIBLE_OCCUPANCIES
for o_p in _FEASIBLE_OCCUPANCIES for d in days}
occupancy_pair_vars = model.addVars(occupancy_pairs.keys(),
name="phi",
lb=0,
ub=1)
logger.info("Created variables")
model.addConstrs(
(quicksum(assignment_vars[(family_id, family_choice)]
for family_choice in family_index[family_id].choices)
== 1 for family_id in family_index.keys()),
name="assg",
)
model.addConstrs((occupancy_vars.sum("*", day) == 1 for day in days),
name="occ_c")
model.addConstrs(
(quicksum(
assignment_vars.get((family.id, day), 0) *
family.number_of_members for family in families) == quicksum(
occupancy_vars[(occupancy, day)] * occupancy
for occupancy in _FEASIBLE_OCCUPANCIES) for day in days),
name="occ",
)
n_days = len(list(days))
model.addConstrs(
(occupancy_pair_vars.sum(occupancy, "*", d)
== occupancy_vars[(occupancy, d)]
for occupancy in _FEASIBLE_OCCUPANCIES for d in days),
name="occ_l_1",
)
model.addConstrs(
(occupancy_pair_vars.sum("*", occupancy, d + 1)
== occupancy_vars[(occupancy, d + 1)]
for occupancy in _FEASIBLE_OCCUPANCIES
for d in days if d + 1 < n_days),
name="occ_l_2",
)
logger.info("Set constraints")
pref_cost_expr = quicksum(
assignment_vars[(family.id, family_choice)] * preference_cost(
family_choice, family.choice_index, family.number_of_members)
for family in families for family_choice in family.choices)
accounting_cost_expr = quicksum(
occupancy_vars.sum(pair[0], pair[1], "*") * cost
for pair, cost in occupancy_pairs.items())
model.setObjective(pref_cost_expr + accounting_cost_expr,
sense=GRB.MINIMIZE)
logger.info("Set objective")
if mip_start:
for family_id, assigned_day in mip_start.items():
v = assignment_vars.get((family_id, assigned_day), None)
if v:
v.start = 1
model.optimize()
if model.status == GRB.INFEASIBLE:
model.computeIIS()
model.write("conflict.lp")
raise Exception("Infeasible model.")
else:
assignments = {
k[0]: k[1]
for k, v in assignment_vars.items() if v.X > 0.5
}
model.write("sol.sol")
return Solution.from_assignments(assignments, days, family_index)
def SensingRange(nodeNum, len, wid, Cost_List, CalcTime_List, Budget, K ,pop_size, max_gen):
Cd = 10
Cr = 6
P = 1
length = len
width = wid
Nodes = generateNodes(length, width, nodeNum) # 随机添加结点
####初始化d_monitor,即dij; 具体地通过设定时间阈值Time，随机生成i->j和j->i之间的传染时间，time_ij和time_ji,#####
# 比较它们j与Time, 进而初始化d_monitor
d_monitor = {}
# Velocity = 4 # 米/秒 直接初始化时间，不用“距离/速度”来求得，因为那样既复杂也不不满足实际情况（i到j和j到i的传染时间应该不同）
Time = 30 # 秒
num = 0 #测试用
for i in range(nodeNum):
for j in range(nodeNum):
if(i==j):
d_monitor[i,j] = 1
else:
time_ij = random.uniform(1, 120) #在threshold_Time取range(10,120,10),随机生成的时间time_ij则要在（1,120）之间随机选一个数
if(time_ij<=Time):
d_monitor[i,j] = 1
num += 1
else:
d_monitor[i,j] = 0
# print "d_monitor==1的数目(除<i,i>):", num
print "d_monitor:", d_monitor
#####初始化水管网的边，即结点间的水管#####
edges = []
Comm_Dist = length / math.sqrt(nodeNum)#米，即Communication_Distance，表示sensor间通讯距离限制
for i in range(nodeNum):
for j in range(nodeNum):
distance_ij = Nodes[i].calDistance(Nodes[j])
if(distance_ij<=Comm_Dist and i != j):
edges.append((i,j))
# print "edges:", edges
tupl_edges = tuplelist(edges)
#####根据edges矩阵生成v_commu的值，v_commu[i,j]表示i与j的物理可达，即i一定可以通讯到j，只要它们之间的结点布置了sensor，因为这些结点都能在通讯范围内#####
#例如，v_commu[0,3]=1代表0能通讯到3；注意v_commu[a,a]=0，除非存在b使（a,b）在edges中 v_commu[a,a]才=1,此时a->b->a通讯
v_commu = {}
# v_commu = {(0,0):1, (1,1):1, (2,2):1, (3,3):1, (0,1):0, (1,0):0, (0,2):1, (2,0):1, (0,3):0, (3,0):0, (1,2):0,
# (2,1):0, (1,3):0, (3,1):0, (2,3):0, (3,2):0}
# for i,j in v_commu:
# if v_commu[i,j]==1:
# print "v_commu[i,j]", (i,j)
allLink_edges = edges #先得到任意两点间可否通讯的图，存在一个list中；然后再转换成v_commu字典形式
for i in range(nodeNum):
for j in range(nodeNum):
if (i,j) in allLink_edges: #即表示i到j有通讯
for k in range(nodeNum):
if (k,j) in allLink_edges and k!=i:
allLink_edges.append((i,k))
for i in range(nodeNum): #判断一下对角线是否设为1
for j in range(nodeNum):
if (i,j) in allLink_edges: #说明表示i到有向外的通讯，不是孤立点，则自己能回到自己
allLink_edges.append((i,i))
# print "allLink_edges", allLink_edges
allLink_edges = list(set(allLink_edges)) #去除list中重复的
# print "allLink_edges", allLink_edges
for i in range(nodeNum): #列表allLink_edges转换为字典v_commu表示
for j in range(nodeNum):
if (i,j) in allLink_edges:
v_commu[i,j]=1
else:
v_commu[i,j]=0
print "v_commu", v_commu
currentTime_1 = getTime()
#Gurobi_Cost = Min_pollution(P,nodeNum,Cd,Cr,Budget,d_monitor,v_commu,tupl_edges)
Gurobi_Cost = 0
currentTime_2 = getTime()
#TwoPhase_Cost = My_algo(P,nodeNum,Cd,Cr,Budget,d_monitor,v_commu,edges)
TwoPhase_Cost = 0
currentTime_3 = getTime()
Genetic_Cost = Genetic_Algo_V(P,nodeNum,Cd,Cr,Budget,d_monitor,v_commu,edges, pop_size, max_gen)
currentTime_4 = getTime()
Time_Gurobi_Cost = currentTime_2 - currentTime_1
Time_MyAlgo_Cost = currentTime_3 - currentTime_2
Time_Genetic_Cost = currentTime_4 - currentTime_3
Cost_List[0] = Gurobi_Cost
Cost_List[1] = TwoPhase_Cost
Cost_List[2] = Genetic_Cost
CalcTime_List[0] = Time_Gurobi_Cost
CalcTime_List[1] = Time_MyAlgo_Cost
CalcTime_List[2] = Time_Genetic_Cost
from solutions.stadium.stadium_problem import StadiumConstructionProblem
from solutions.stadium.stadium_model import StadiumConstructionModel
# PROBLEM DATA
tasks = [i for i in range(1,18+1)]
durations = {1: 2,
2: 16,
3: 9,
4: 8,
5: 10,
6: 6,
7: 2,
8: 2,
9: 9,
10: 5,
11: 3,
12: 2,
13: 1,
14: 7,
15: 4,
16: 3,
17: 9,
18: 1}
precedences = tuplelist([(2,1),(3,2),(4,2),(5,3),(6,4),(6,5),(7,4),(8,6),(9,4),(9,6),(10,4),(11,6),(12,9),(13,7),(14,2),
(15,4),(15,14),(16,8), (16,11),(16,14),(15,11),(17,12),(18,17)])
p = StadiumConstructionProblem(tasks,durations,precedences)
m = StadiumConstructionModel(p)
m.solve()
m.printSolution()