def optimize(
self, solver="ralg", plot=0, maxIter=1e5, maxCPUTime=3600, maxFunEvals=1e12
):
if self.mtype == "LP" or self.mtype == "MILP":
p = MILP(
self.objective,
self.init,
constraints=self.constraints,
maxIter=maxIter,
maxCPUTime=maxCPUTime,
maxFunEvals=maxFunEvals,
)
elif self.mtype == "NLP":
p = NLP(
self.objective,
self.init,
constraints=self.constraints,
maxIter=maxIter,
maxCPUTime=maxCPUTime,
maxFunEvals=maxFunEvals,
)
else:
print("Model Type Error")
raise TypeError
if self.sense == GRB.MAXIMIZE:
self.Results = p.maximize(solver, plot=plot)
else:
self.Results = p.minimize(solver, plot=plot)
# print(self.Results)
self.ObjVal = self.Results.ff
if self.Results.isFeasible:
self.Status = GRB.OPTIMAL
else:
self.Status = GRB.INFEASIBLE
for v in self.variables:
v.VarName = v.name
v.X = self.Results.xf[v]
return self.Status
obj = p*m+sum([ov[corr2[i,j]]*loss[j] for i in range(m) for j in range(int(sum(con[i])))])
# Start point - currently matters only size of variables
startPoint = {d:[0]*m,bef:[0]*lyc ,ov:[0]*xtt} # however, using numpy.arrays is more recommended than Python lists
# Define some constraints
cons = [bef[corr[i,j]]+bef[corr[j,i]]==1 for i in range(m) for j in range(i+1,m) if con[i,j]>0.5]+\
[d[i]==sum([bef[corr[j,i]] for j in range(m) if con[i,j]>0.5]+[0]) for i in range(m)]+\
[d[i]<=j+ov[corr2[i,j]]*100 for i in range(m) for j in range(int(sum(con[i])))]
# Create prob
# old-style:
#p = MILP(obj, startPoint, intVars = [y, z], constraints=cons)
# new (OpenOpt v 0.37+):
pp = MILP(obj, startPoint, constraints=cons,maxIter=5000)
# Solve
r = pp.maximize('cplex') # glpk is name of the solver involved, see OOF doc for more arguments
# Decode solution
s = r.xf
tmp=[[i,s[d][i]]for i in range(m)]
order=[i[0] for i in sorted(tmp,key=lambda x:x[1])]
t2=time.time()
def payoff(a,p=0.7):
m=len(a)
ans=0
for i in range(m):
tmp=p
for j in range(i):
if con[a[i],a[j]]>0.5:
tmp*=(1-p)
ans+=tmp
def schedule_all(self, timelimit=None):
if not self.reservation_list:
return self.schedule_dict
self.build_data_structures()
# allocate A & b
# find the row size of A:
# first find the number of reservations participating in oneofs
oneof_reservation_num = 0
for c in self.oneof_constraints:
oneof_reservation_num += len(c)
A_numrows = len(self.reservation_list) + len(self.aikt) + len(
self.oneof_constraints) - oneof_reservation_num
A_rows = []
A_cols = []
A_data = []
# try:
# A = numpy.zeros((A_numrows, len(self.Yik)), dtype=numpy.int)
# except ValueError:
# print("Number of A rows: {}".format(A_numrows)
b = numpy.zeros(A_numrows, dtype=numpy.int16)
# build A & b
row = 0
# constraint 5: oneof
for c in self.oneof_constraints:
for r in c:
for entry in r.Yik_entries:
A_rows.append(row)
A_cols.append(entry)
A_data.append(1)
# A[row,entry] = 1
r.skip_constraint2 = True
b[row] = 1
row += 1
# constraint 2: each res should have one start:
# optimization:
# if the reservation participates in a oneof, then this is
# redundant with the oneof constraint added above, so don't add it.
for r in self.reservation_list:
if hasattr(r, 'skip_constraint2'):
continue
for entry in r.Yik_entries:
A_rows.append(row)
A_cols.append(entry)
A_data.append(1)
# A[row,entry] = 1
b[row] = 1
row += 1
# constraint 3: each slice should only have one sched. reservation:
for s in self.aikt.keys():
for entry in self.aikt[s]:
A_rows.append(row)
A_cols.append(entry)
A_data.append(1)
# A[row,entry] = 1
b[row] = 1
row += 1
A = coo_matrix((A_data, (A_rows, A_cols)),
shape=(A_numrows, len(self.Yik)))
# constraint 6: and
# figure out size of constraint matrix
if not self.and_constraints:
Aeq = []
beq = []
else:
Aeq_numrows = 0
for c in self.and_constraints:
Aeq_numrows += len(c) - 1
# allocate Aeq and beq
# Aeq = numpy.zeros((Aeq_numrows, len(self.Yik)), dtype=numpy.int)
Aeq_rows = []
Aeq_cols = []
Aeq_data = []
beq = numpy.zeros(Aeq_numrows, dtype=numpy.int16)
row = 0
for c in self.and_constraints:
constraint_size = len(c)
left_idx = 0
right_idx = 1
while right_idx < constraint_size:
left_r = c[left_idx]
right_r = c[right_idx]
for entry in left_r.Yik_entries:
# Aeq[row, entry] = 1
Aeq_rows.append(row)
Aeq_cols.append(entry)
Aeq_data.append(1)
for entry in right_r.Yik_entries:
Aeq_rows.append(row)
Aeq_cols.append(entry)
Aeq_data.append(-1)
# Aeq[row, entry] = -1
left_idx += 1
right_idx += 1
row += 1
# print(Aeq_numrows)
Aeq = coo_matrix((Aeq_data, (Aeq_rows, Aeq_cols)),
shape=(Aeq_numrows, len(self.Yik)))
# bounds:
lb = numpy.zeros(len(self.Yik))
ub = numpy.ones(len(self.Yik))
# objective function:
f = numpy.zeros(len(self.Yik))
row = 0
for entry in self.Yik:
f[row] = entry[2] # priority
row += 1
dump_matrix_sizes(f, A, Aeq, b, beq, lb, ub,
len(self.compound_reservation_list))
p = MILP(f=f,
A=A,
Aeq=Aeq,
b=b,
beq=beq,
lb=lb,
ub=ub,
intVars=list(range(len(self.Yik))),
binVars=list(range(len(self.Yik))))
r = p.maximize('glpk', iprint=-1)
# r = p.maximize('bintprog')
# r = p.maximize('lpsolve')
return self.unpack_result(r)
