def compute_sol():
intVars = range(N_vars)
lb = zeros(N_vars)
ub = ones(N_vars)
def denseRow(r):
row = zeros(N_vars)
for i, v in r.items():
row[i] = v
return row
A = map(denseRow, A_lt)
Aeq = map(denseRow, A_eq)
ff = denseRow(f)
p = MILP(f=ff,
lb=lb,
ub=ub,
A=A,
b=b_lt,
Aeq=Aeq,
beq=b_eq,
intVars=intVars,
goal='min')
r = p.solve('glpk', iprint=-1)
return r.xf
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
y: 25,
z: 80
} # however, using numpy.arrays is more recommended than Python lists
# Define some constraints
cons = [
x + 5 * y < 15, x[0] < -5,
f1 < [25, 35], f1 > -100, 2 * f1 + 4 * z < [80, 800], 5 * f2 + 4 * z < 100,
[-5.5, -4.5] < x, x < 1, -17 < y, y < 20, -4000 < z, z < 4
]
# Create prob
# old-style:
#p = MILP(obj, startPoint, intVars = [y, z], constraints=cons)
# new (OpenOpt v 0.37+):
p = MILP(obj, startPoint, constraints=cons)
# Solve
r = p.minimize(
'lpSolve', iprint=-1
) # glpk is name of the solver involved, see OOF doc for more arguments
# Decode solution
s = r.xf
print('Solution: x = %s y = %f z = %f' % (str(s[x]), s[y], s[z]))
# Solution: x = [-5.25 -4.5 ] y = 3.000000 z = -33.000000
# OPTIONAL: you can export the problem into MPS format file
# (lpsolve and its Python binding should be properly installed,
# you may take a look at the instructions from openopt.org/LP)
# if file name not ends with '.MPS' or '.mps'
# first trip is free
b = b + [NUMDRIFTERS]
for pidx in range(0, len(boattrips[0])):
A[optlabs, pidx] = 1
# [mask of paths starting at bidx] * x_paths <= [mask of paths ending for bidx] * x_paths
for bidx in range(1, TIME / BOATTIME / 2):
for pidx in range(0, len(boattrips[bidx])):
A[optlabs + bidx, boatoptstart[bidx] + pidx] = 1
for pidx in boatends[bidx]:
A[optlabs + bidx, pidx] = -1
b = b + [0] * (TIME / BOATTIME / 2 - 1)
p = MILP(f=f, lb=lb, ub=ub, A=A, b=b, intVars=intVars, goal='max')
#r = p.solve('lpSolve')
curtime = time_module.time()
r = p.solve('cplex')
print "Solver done. Took %.5f real time." % (time_module.time() - curtime)
optlabels_hit = r.ff
# Decode solution
labs_got = []
if (optlabs > 0):
for lidx in range(0, optlabs):
if (r.xf[lidx + numpaths] == 1):
labs_got.append(rlmap[lidx])
paths_taken = []
boat_carrying = [0] * (TIME / BOATTIME / 2)
f = [1, 2, 3, 4, 5, 4, 2, 1]
# indexing starts from ZERO!
# while in native lpsolve-python wrapper from 1
# so if you used [5,8] for native lp_solve python binding
# you should use [4,7] instead
intVars = [4, 7]
lb = -1.5 * ones(8)
ub = 15 * ones(8)
A = zeros((5, 8))
b = zeros(5)
for i in xrange(5):
for j in xrange(8):
A[i, j] = -8 + sin(8 * i) + cos(15 * j)
b[i] = -150 + 80 * sin(80 * i)
p = MILP(f=f, lb=lb, ub=ub, A=A, b=b, intVars=intVars)
# if file name not ends with '.MPS' or '.mps'
# then '.mps' will be appended
success = p.exportToMPS('/home/dmitrey/PyTest/milp_1')
# or write into current dir:
# success = p.exportToMPS('milp')
# success is False if a error occurred (read-only file system, no write access, etc)
# elseware success is True
# f_opt is 25.801450769161505
# x_opt is [ 15. 10.15072538 -1.5 -1.5 -1. -1.5 -1.5 15.]
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)
