class Data:
obj = [3.0, -1.0, 3.0, 2.0, 1.0, 2.0, 4.0]
lb = [
0.0, -cplex.infinity, 0.0, -cplex.infinity, -cplex.infinity, 0.0,
-cplex.infinity
]
ub = [
3, cplex.infinity, 0.5, cplex.infinity, cplex.infinity, cplex.infinity,
cplex.infinity
]
cname = ["x1", "x2", "x3", "x4", "x5", "x6", "x7"]
rhs = [4.0, 3.0, 5.0, -2.0]
sense = "EGLG"
rows = [[["x1", "x2"], [1.0, 1.0]], [["x1", "x3"], [1.0, 1.0]],
[["x6", "x7"], [1.0, 1.0]], [["x1", "x7"], [-1.0, 1.0]]]
rname = ["c1", "c2", "c3", "c4"]
qlin = [
cplex.SparsePair(),
cplex.SparsePair(["x1"], [2.0]),
cplex.SparsePair()
]
quad = [
cplex.SparseTriple(["x1", "x2"], ["x1", "x2"], [-1.0, 1.0]),
cplex.SparseTriple(["x3", "x3", "x4", "x4", "x5"],
["x3", "x4", "x4", "x5", "x5"],
[4.25, -2.0, 4.25, -2.0, 4.0]),
cplex.SparseTriple(["x6", "x7"], ["x6", "x7"], [1.0, -1.0])
]
qsense = ['L', 'L', 'G']
qrhs = [0.0, 9.0, 4.0]
qname = ["q1", "q2", "q3"]
def _quadexp_pic2cpl(self, picosExpression):
"""
Tranforms the quadratic part of a PICOS quadratic expression to a CPLEX
quadratic expression.
:returns: :class:`SparseTriple <cplex.SparseTriple>` mapping a pair of
CPLEX variable indices to scalar constants.
"""
import cplex
if not isinstance(picosExpression, QuadExp):
raise ValueError("Expression must be a quadratic expression.")
cplexI, cplexJ, cplexV = [], [], []
for (picosVar1, picosVar2), picosCoefficients \
in picosExpression.quad.items():
for sparseIndex in range(len(picosCoefficients)):
localVar1Index = picosCoefficients.I[sparseIndex]
localVar2Index = picosCoefficients.J[sparseIndex]
localCoefficient = picosCoefficients.V[sparseIndex]
cplexI.append(self._cplexVarName[picosVar1.startIndex +
localVar1Index])
cplexJ.append(self._cplexVarName[picosVar2.startIndex +
localVar2Index])
cplexV.append(localCoefficient)
return cplex.SparseTriple(ind1=cplexI, ind2=cplexJ, val=cplexV)
def quard_con(self, Q_con, multiple):
if self.q1num > 0:
self.c.quadratic_constraints.delete("st_11_1")
Q3 = cplex.SparseTriple(ind1=Q_con[0], ind2=Q_con[1], val=Q_con[2])
self.c.quadratic_constraints.add(rhs=0.01 * multiple,
quad_expr=Q3,
name="st_11_1",
sense="L")
self.q1num += 1
def QPClause(Q, c, b, rVars, sense="L"):
# x = rVars
# sense = "L" (less than), "G" (greater than), "E" (equal) for
#x^T Q x + c^T x {sense} b
# TODO: add a dimension check
# Put the constraint in CPLEX format, example below:
# l = cplex.SparsePair(ind = ['x'], val = [1.0])
# q = cplex.SparseTriple(ind1 = ['x'], ind2 = ['y'], val = [1.0])
# c.quadratic_constraints.add(name = "my_quad",
# lin_expr = l,
# quad_expr = q,
# rhs = 1.0,
# sense = "G")
ind1 = list()
ind2 = list()
val = list()
matrixSize = len(rVars)
for counter in range(0, matrixSize):
for counter2 in range(0, matrixSize):
ind1.append(rVars[counter])
ind2.append(rVars[counter2])
val.append(Q[counter, counter2])
lin_expr = cplex.SparsePair(ind=rVars, val=c)
quad_expr = cplex.SparseTriple(ind1=ind1, ind2=ind2, val=val)
rhs = b
constraint = {
'type': 'QP',
'quad_expr': quad_expr,
'lin_expr': lin_expr,
'rhs': rhs,
'x': rVars,
'sense': sense,
'Q': Q,
'c': c
}
return constraint
def setproblemdata(p):
p.objective.set_sense(p.objective.sense.maximize)
p.linear_constraints.add(rhs=[20.0, 30.0], senses="LL")
obj = [1.0, 2.0, 3.0]
ub = [40.0, cplex.infinity, cplex.infinity]
cols = [[[0, 1], [-1.0, 1.0]], [[0, 1], [1.0, -3.0]], [[0, 1], [1.0, 1.0]]]
p.variables.add(obj=obj,
ub=ub,
columns=cols,
names=["one", "two", "three"])
qmat = [[[0, 1], [-33.0, 6.0]], [[0, 1, 2], [6.0, -22.0, 11.5]],
[[1, 2], [11.5, -11.0]]]
p.objective.set_quadratic(qmat)
Q = cplex.SparseTriple(ind1=["one", "two", "three"],
ind2=[0, 1, 2],
val=[1.0] * 3)
p.quadratic_constraints.add(rhs=1.0, quad_expr=Q, name="Q")
def setProblemData(p, current, data, direction, r):
#Set to maximization problem
p.objective.set_sense(p.objective.sense.maximize)
#Linear Constraints
indices = p.variables.add(names = [str(k) for k in range(len(current))])
for j in range(len(data)):
#if(np.asarray(current) != np.asarray(data[j]))
#if not all(x in current for x in data[j]):
#print('CURRENT' + str(current))
#print('DATA{J}' + str(data[j]))
my_rhs = np.dot(np.asarray(data[j]),np.asarray(data[j])) - np.dot(np.asarray(current),np.asarray(current))
lin_coeff =[]
for k in range(len(current)):
lin_coeff.append(2.0*(data[j][k]-current[k]))
p.linear_constraints.add(lin_expr = [cplex.SparsePair(ind = indices, val = lin_coeff)],
rhs = [my_rhs], senses = ["L"])
#print('indices: ' + str(indices))
#print('lin_coeff: ' + str(lin_coeff))
#print('rhs: '+ str(my_rhs))
#print('number of linear contraints: '+ str(p.linear_constraints.get_rows()))
#Quadartic Constraint
sumData = [sum(x) for x in zip(*data)]
sumDataSquare = sum( j*j for j in sumData)
q_rhs = r*r-(1./(len(data)*len(data)))*sumDataSquare
q_lin_coeff = [x * -(2./len(data)) for x in sumData]
q_quad_coeff = [1.]*len(current)
p.quadratic_constraints.add(lin_expr = cplex.SparsePair(ind = indices, val = q_lin_coeff),
quad_expr = cplex.SparseTriple(ind1=indices, ind2=indices, val=q_quad_coeff),
rhs=q_rhs, sense = 'L')
#Objective function
for k in range(len(current)):
p.objective.set_linear(k,direction[k])
offset = -np.dot(np.asarray(current),direction)
p.objective.set_offset(offset)
def add_model_soc_constr(self, model, variables, rows, mat, vec):
"""Adds SOC constraint to the model using the data from mat and vec.
Parameters
----------
model : CPLEX model
The problem model.
variables : list
The problem variables.
rows : range
The rows to be constrained.
mat : SciPy COO matrix
The matrix representing the constraints.
vec : NDArray
The RHS part of the constraints.
Returns
-------
tuple
A tuple of (a new quadratic constraint index, a list of new
supporting linear constr indices, and a list of new
supporting variable indices).
"""
import cplex
# Assume first expression (i.e. t) is nonzero.
lin_expr_list, soc_vars, lin_rhs = [], [], []
csr = mat.tocsr()
for i in rows:
ind = [variables[x] for x in csr[i].indices]
val = [x for x in csr[i].data]
# Ignore empty constraints.
if ind:
lin_expr_list.append((ind, val))
lin_rhs.append(vec[i])
else:
lin_expr_list.append(None)
lin_rhs.append(0.0)
# Make a variable and equality constraint for each term.
soc_vars, is_first = [], True
for i in rows:
if is_first:
lb = [0.0]
names = ["soc_t_%d" % i]
is_first = False
else:
lb = [-cplex.infinity]
names = ["soc_x_%d" % i]
soc_vars.extend(
list(
model.variables.add(obj=[0],
lb=lb,
ub=[cplex.infinity],
types="",
names=names)))
new_lin_constrs = []
for i, expr in enumerate(lin_expr_list):
if expr is None:
ind = [soc_vars[i]]
val = [1.0]
else:
ind, val = expr
ind.append(soc_vars[i])
val.append(1.0)
new_lin_constrs.extend(
list(
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=ind, val=val)],
senses="E",
rhs=[lin_rhs[i]])))
assert len(soc_vars) > 0
qconstr = model.quadratic_constraints.add(
lin_expr=cplex.SparsePair(ind=[], val=[]),
quad_expr=cplex.SparseTriple(ind1=soc_vars,
ind2=soc_vars,
val=[-1.0] + [1.0] *
(len(soc_vars) - 1)),
sense="L",
rhs=0.0,
name="")
return (qconstr, new_lin_constrs, soc_vars)
def run(inputPHI, alpha, matlab_input_data, matlab_input_data1,
matlab_input_data2, matlab_input_data3, savefile):
# read data from Matlab .mat file
mat_data = sio.loadmat(os.getcwd() + "/mat_data/" + matlab_input_data)
fourth1 = sio.loadmat(os.getcwd() + "/mat_data/" + matlab_input_data1)
fourth2 = sio.loadmat(os.getcwd() + "/mat_data/" + matlab_input_data2)
fourth3 = sio.loadmat(os.getcwd() + "/mat_data/" + matlab_input_data3)
# set lp data
lp = lp_reader.set(mat_data, fourth1, fourth2, fourth3)
start1 = time.clock()
# assumption: 1,2,3 stages have the same Phi-divergence
inPhi = PhiDivergence.set(inputPHI)
# set: Phi-lp2
philp = PhiLP_root.set(lp.first, inPhi, lp.first['obs'],
inPhi.Rho(alpha, lp.first['obs']))
philp1 = [
PhiLP_child.set(lp.second[i], inPhi, lp.second[i]['obs'],
inPhi.Rho(alpha, lp.second[i]['obs']))
for i in range(lp.first['numScenarios'])
]
philp2 = [[
PhiLP_child.set(lp.third[i][j], inPhi, lp.third[i][j]['obs'],
inPhi.Rho(alpha, lp.third[i][j]['obs']))
for j in range(lp.second[i]['numScenarios'])
] for i in range(lp.first['numScenarios'])]
philp3 = [[[
PhiLP_leaf.set(lp.fourth[i][j][k])
for k in range(lp.third[i][j]['numScenarios'])
] for j in range(lp.second[i]['numScenarios'])]
for i in range(lp.first['numScenarios'])]
# OBJ
obj = np.append(philp.lpModel['obj'], [1, (philp.rho - 1)])
q2 = philp.numObsPerScen / philp.numObsTotal
for i in range(lp.first['numScenarios']):
tmp = np.append(np.zeros_like(philp1[i].lpModel['obj']),
[0, 0, 0, q2[i] / 4])
obj = np.append(obj, tmp)
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
tmp = np.append(np.zeros_like(philp2[i][j].lpModel['obj']),
[0, 0, 0, 0])
obj = np.append(obj, tmp)
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
tmp = np.append(np.zeros_like(philp3[i][j][k].lpModel['obj']),
[0, 0])
obj = np.append(obj, tmp)
# lb
lb = np.append(philp.lpModel['lb'], [-cplex.infinity, 0])
for i in range(lp.first['numScenarios']):
tmp = np.append(philp1[i].lpModel['lb'], [-cplex.infinity, 0, 0, 0])
lb = np.append(lb, tmp)
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
tmp = np.append(philp2[i][j].lpModel['lb'],
[-cplex.infinity, 0, 0, 0])
lb = np.append(lb, tmp)
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
tmp = np.append(philp3[i][j][k].lpModel['lb'], [0, 0])
lb = np.append(lb, tmp)
# ub
ub = np.append(philp.lpModel['ub'], [cplex.infinity, cplex.infinity])
for i in range(lp.first['numScenarios']):
tmp = np.append(
philp1[i].lpModel['ub'],
[cplex.infinity, cplex.infinity, cplex.infinity, cplex.infinity])
ub = np.append(ub, tmp)
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
tmp = np.append(philp2[i][j].lpModel['ub'], [
cplex.infinity, cplex.infinity, cplex.infinity, cplex.infinity
])
ub = np.append(ub, tmp)
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
tmp = np.append(philp3[i][j][k].lpModel['ub'],
[cplex.infinity, cplex.infinity])
ub = np.append(ub, tmp)
# sense
sense_linear = philp.lpModel['sense']
for i in range(lp.first['numScenarios']):
sense_linear = np.append(sense_linear, philp1[i].lpModel['sense'])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
sense_linear = np.append(sense_linear,
philp2[i][j].lpModel['sense'])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
sense_linear = np.append(sense_linear,
philp3[i][j][k].lpModel['sense'])
sense_linear1 = []
for i in range(lp.first['numScenarios']):
sense_linear1 = np.append(sense_linear1, ['L'])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
sense_linear1 = np.append(sense_linear1, ['L'])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
sense_linear1 = np.append(sense_linear1, ['L'])
# RHS
rhs_linear = philp.lpModel['rhs']
for i in range(lp.first['numScenarios']):
rhs_linear = np.append(rhs_linear, philp1[i].lpModel['rhs'])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
rhs_linear = np.append(rhs_linear, philp2[i][j].lpModel['rhs'])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
rhs_linear = np.append(rhs_linear,
philp3[i][j][k].lpModel['rhs'])
rhs_linear1 = []
for i in range(lp.first['numScenarios']):
rhs_linear1 = np.append(rhs_linear1, [0])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
rhs_linear1 = np.append(rhs_linear1, [0])
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
rhs_linear1 = np.append(rhs_linear1, [0])
col_num = obj.shape[0]
# Linear A1
A1 = lil_matrix((philp.lpModel['A'].shape[0], col_num), dtype=np.float)
row_A1 = np.arange(philp.lpModel['A'].shape[0])
col_A1 = np.arange(philp.lpModel['A'].shape[1])
A1[row_A1[0]:row_A1[-1] + 1, col_A1[0]:col_A1[-1] + 1] = philp.lpModel['A']
# Linear A2
A2 = lil_matrix(
(philp1[0].lpModel['A'].shape[0] * lp.first['numScenarios'], col_num),
dtype=np.float)
row_B2 = np.zeros_like(
np.tile(np.arange(philp1[0].lpModel['B'].shape[0]),
(lp.first['numScenarios'], 1)))
col_A2 = np.zeros_like(
np.tile(np.arange(philp1[0].lpModel['A'].shape[1]),
(lp.first['numScenarios'], 1)))
for i in range(lp.first['numScenarios']):
row_B2[i] = np.arange(philp1[i].lpModel['B'].shape[0] * i,
philp1[i].lpModel['B'].shape[0] * (i + 1))
col_A2[i] = np.arange(
(philp.lpModel['A'].shape[1] + 2) +
philp1[i].lpModel['A'].shape[1] * i + 4 * i,
(philp.lpModel['A'].shape[1] + 2) +
philp1[i].lpModel['A'].shape[1] * (i + 1) + 4 * i)
A2[row_B2[i][0]:row_B2[i][-1] + 1,
col_A1[0]:col_A1[-1] + 1] = -philp1[i].lpModel['B']
A2[row_B2[i][0]:row_B2[i][-1] + 1,
col_A2[i][0]:col_A2[i][-1] + 1] = philp1[i].lpModel['A']
# Linear A3
A3 = lil_matrix(
(philp2[0][0].lpModel['A'].shape[0] * lp.first['numScenarios'] *
lp.second[0]['numScenarios'], col_num),
dtype=np.float)
row_B3 = np.zeros_like(
np.tile(np.arange(philp2[0][0].lpModel['B'].shape[0]),
(lp.first['numScenarios'] * lp.second[0]['numScenarios'], 1)))
for t in range(lp.first['numScenarios'] * lp.second[0]['numScenarios']):
row_B3[t] = np.arange(philp2[0][0].lpModel['B'].shape[0] * t,
philp2[0][0].lpModel['B'].shape[0] * (t + 1))
row_B3 = row_B3.reshape((lp.first['numScenarios'],
lp.second[0]['numScenarios'], row_B3[0].size))
col_A3 = np.zeros_like(
np.tile(np.arange(philp2[0][0].lpModel['A'].shape[1]),
(lp.first['numScenarios'] * lp.second[0]['numScenarios'], 1)))
for t in range(lp.first['numScenarios'] * lp.second[0]['numScenarios']):
col_A3[t] = np.arange(
(philp.lpModel['A'].shape[1] + 2 +
(philp1[0].lpModel['A'].shape[1] + 4) * lp.first['numScenarios'])
+ philp2[0][0].lpModel['A'].shape[1] * t + 4 * t,
(philp.lpModel['A'].shape[1] + 2 +
(philp1[0].lpModel['A'].shape[1] + 4) * lp.first['numScenarios'])
+ philp2[0][0].lpModel['A'].shape[1] * (t + 1) + 4 * t)
col_A3 = col_A3.reshape((lp.first['numScenarios'],
lp.second[0]['numScenarios'], col_A3[0].size))
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
A3[row_B3[i][j][0]:row_B3[i][j][-1] + 1,
col_A2[i][0]:col_A2[i][-1] + 1] = -philp2[i][j].lpModel['B']
A3[row_B3[i][j][0]:row_B3[i][j][-1] + 1,
col_A3[i][j][0]:col_A3[i][j][-1] +
1] = philp2[i][j].lpModel['A']
# Linear A3
A4 = lil_matrix(
(philp3[0][0][0].lpModel['A'].shape[0] * lp.first['numScenarios'] *
lp.second[0]['numScenarios'] * lp.third[0][0]['numScenarios'],
col_num),
dtype=np.float)
row_B4 = np.zeros_like(
np.tile(np.arange(philp3[0][0][0].lpModel['B'].shape[0]),
(lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios'], 1)))
for t in range(lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios']):
row_B4[t] = np.arange(philp3[0][0][0].lpModel['B'].shape[0] * t,
philp3[0][0][0].lpModel['B'].shape[0] * (t + 1))
row_B4 = row_B4.reshape(
(lp.first['numScenarios'], lp.second[0]['numScenarios'],
lp.third[0][0]['numScenarios'], row_B4[0].size))
col_A4 = np.zeros_like(
np.tile(np.arange(philp3[0][0][0].lpModel['A'].shape[1]),
(lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios'], 1)))
for t in range(lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios']):
col_A4[t] = np.arange(
(philp.lpModel['A'].shape[1] + 2 +
(philp1[0].lpModel['A'].shape[1] + 4) * lp.first['numScenarios'] +
(philp2[0][0].lpModel['A'].shape[1] + 4) *
lp.first['numScenarios'] * lp.second[0]['numScenarios']) +
philp3[0][0][0].lpModel['A'].shape[1] * t + 2 * t,
(philp.lpModel['A'].shape[1] + 2 +
(philp1[0].lpModel['A'].shape[1] + 4) * lp.first['numScenarios'] +
(philp2[0][0].lpModel['A'].shape[1] + 4) *
lp.first['numScenarios'] * lp.second[0]['numScenarios']) +
philp3[0][0][0].lpModel['A'].shape[1] * (t + 1) + 2 * t)
col_A4 = col_A4.reshape(
(lp.first['numScenarios'], lp.second[0]['numScenarios'],
lp.third[0][0]['numScenarios'], col_A4[0].size))
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
A4[row_B4[i][j][k][0]:row_B4[i][j][k][-1] + 1,
col_A3[i][j][0]:col_A3[i][j][-1] +
1] = -philp3[i][j][k].lpModel['B']
A4[row_B4[i][j][k][0]:row_B4[i][j][k][-1] + 1,
col_A4[i][j][k][0]:col_A4[i][j][k][-1] +
1] = philp3[i][j][k].lpModel['A']
A = vstack([vstack([vstack([A1, A2]), A3]), A4])
# linear_cqp
A_lc2 = lil_matrix((lp.first['numScenarios'], col_num), dtype=np.float)
row_lc2 = np.arange(lp.first['numScenarios'])
for i in range(lp.first['numScenarios']):
A_lc2[row_lc2[i], col_A1[-1] + 1:col_A1[-1] + 3] = np.array([-1, 2])
A_lc2[row_lc2[i], col_A2[i]] = philp1[i].lpModel['obj']
A_lc2[row_lc2[i], col_A2[i][-1] + 1:col_A2[i][-1] + 4] = np.array(
[1, (philp1[i].rho - 1), -1])
q3 = philp1[i].numObsPerScen / philp1[i].numObsTotal
for j in range(lp.second[i]['numScenarios']):
A_lc2[row_lc2[i], col_A3[i][j][-1] + 4] = q3[j] / 4
A_lc3 = lil_matrix(
(lp.first['numScenarios'] * lp.second[0]['numScenarios'], col_num),
dtype=np.float)
row_lc3 = np.zeros_like(
np.tile(1,
(lp.first['numScenarios'] * lp.second[0]['numScenarios'], 1)))
for t in range(lp.first['numScenarios'] * lp.second[0]['numScenarios']):
row_lc3[t] = np.arange(t, t + 1)
row_lc3 = row_lc3.reshape((lp.first['numScenarios'],
lp.second[0]['numScenarios'], row_lc3[0].size))
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
A_lc3[row_lc3[i][j],
col_A2[i][-1] + 1:col_A2[i][-1] + 3] = np.array([-1, 2])
A_lc3[row_lc3[i][j], col_A3[i][j]] = philp2[i][j].lpModel['obj']
A_lc3[row_lc3[i][j], col_A3[i][j][-1] + 1:col_A3[i][j][-1] +
4] = np.array([1, (philp2[i][j].rho - 1), -1])
q4 = philp2[i][j].numObsPerScen / philp2[i][j].numObsTotal
for k in range(lp.third[i][j]['numScenarios']):
A_lc3[row_lc3[i][j], col_A4[i][j][k][-1] + 2] = q4[k] / 4
A_lc4 = lil_matrix(
(lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios'], col_num),
dtype=np.float)
row_lc4 = np.zeros_like(
np.tile(1, (lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios'], 1)))
for t in range(lp.first['numScenarios'] * lp.second[0]['numScenarios'] *
lp.third[0][0]['numScenarios']):
row_lc4[t] = np.arange(t, t + 1)
row_lc4 = row_lc4.reshape(
(lp.first['numScenarios'], lp.second[0]['numScenarios'],
lp.third[0][0]['numScenarios'], row_lc4[0].size))
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
A_lc4[row_lc4[i][j][k], col_A3[i][j][-1] + 1:col_A3[i][j][-1] +
3] = np.array([-1, 2])
A_lc4[row_lc4[i][j][k],
col_A4[i][j][k]] = philp3[i][j][k].lpModel['obj']
A_lc4[row_lc4[i][j][k], col_A4[i][j][k][-1] +
1:col_A4[i][j][k][-1] + 2] = np.array([-1])
A_lc = vstack([vstack([A_lc2, A_lc3]), A_lc4])
extensive_A = vstack([A, A_lc])
A_rows = find(extensive_A)[0].tolist()
A_cols = find(extensive_A)[1].tolist()
A_vals = find(extensive_A)[2].tolist()
extensive_A_coefficients = zip(A_rows, A_cols, A_vals)
mdl = cplex.Cplex()
mdl.set_problem_name("mdl")
mdl.parameters.lpmethod.set(mdl.parameters.lpmethod.values.auto)
mdl.objective.set_sense(mdl.objective.sense.minimize)
mdl.variables.add(obj=obj, lb=lb, ub=ub)
mdl.linear_constraints.add(senses=sense_linear, rhs=rhs_linear)
mdl.linear_constraints.add(senses=sense_linear1, rhs=rhs_linear1)
mdl.linear_constraints.set_coefficients(extensive_A_coefficients)
# A_q
for i in range(lp.first['numScenarios']):
A_q2_id1 = [int(col_A1[-1]) + 2, int(col_A2[i][-1]) + 3]
A_q2_id2 = [int(col_A2[i][-1]) + 4, int(col_A2[i][-1]) + 3]
A_q2_coef = [-1, 1]
q = cplex.SparseTriple(ind1=A_q2_id1, ind2=A_q2_id2, val=A_q2_coef)
mdl.quadratic_constraints.add(quad_expr=q, rhs=0, sense="L")
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
A_q3_id1 = [int(col_A2[i][-1]) + 2, int(col_A3[i][j][-1]) + 3]
A_q3_id2 = [int(col_A3[i][j][-1]) + 4, int(col_A3[i][j][-1]) + 3]
A_q3_coef = [-1, 1]
q = cplex.SparseTriple(ind1=A_q3_id1, ind2=A_q3_id2, val=A_q3_coef)
mdl.quadratic_constraints.add(quad_expr=q, rhs=0, sense="L")
for i in range(lp.first['numScenarios']):
for j in range(lp.second[i]['numScenarios']):
for k in range(lp.third[i][j]['numScenarios']):
A_q4_id1 = [
int(col_A3[i][j][-1]) + 2,
int(col_A4[i][j][k][-1]) + 1
]
A_q4_id2 = [
int(col_A4[i][j][k][-1]) + 2,
int(col_A4[i][j][k][-1]) + 1
]
A_q4_coef = [-1, 1]
q = cplex.SparseTriple(ind1=A_q4_id1,
ind2=A_q4_id2,
val=A_q4_coef)
mdl.quadratic_constraints.add(quad_expr=q, rhs=0, sense="L")
# sys.stdout is the default output stream for log and results
# so these lines may be omitted
mdl.set_log_stream(sys.stdout)
mdl.set_results_stream(sys.stdout)
# Apply parameter settings.
mdl.parameters.barrier.qcpconvergetol.set(CONVTOL)
# Solve the problem. If we cannot find an _optimal_ solution then
# there is no point in checking the KKT conditions and we throw an
# exception.
timeRuns1 = time.clock() - start1
start = time.clock()
mdl.solve()
timeRuns = time.clock() - start
solution = mdl.solution
if not mdl.solution.get_status() == mdl.solution.status.optimal:
raise Exception("Failed to solve problem to optimality")
# mdl.write("test.lp")
fval = np.float64(solution.get_objective_value())
X = solution.get_values()
with open(savefile, "w") as att_file:
att_file.write("Time make extensive form (seconds) = " +
str(timeRuns1) + '\n\n')
att_file.write("Time (seconds) = " + str(timeRuns) + '\n\n')
att_file.write("fval = " + str(fval) + "\n\n")
att_file.write("X = " + str(X[0:300]) + '\n\n')
problem.objective.set_sense(problem.objective.sense.minimize)
pairs = zip(names, objective)
problem.objective.set_linear(pairs)
p = 0.9
phi_p = norm.ppf(p)
# print(t)
lin_constraint = [["x_1", "x_2", "x_3", "c"], [1, 2, 3, -phi_p]]
v = -1
problem.linear_constraints.add(lin_expr=[lin_constraint], rhs=[v], senses='G')
constraint_senses = ["G"]
quad_constraint = cplex.SparseTriple(ind1=["x_1", "x_2", "x_3", "c"],
ind2=["x_1", "x_2", "x_3", "c"],
val=[1, 1, 1, -1])
problem.quadratic_constraints.add(rhs=0.0,
quad_expr=quad_constraint,
name="Q",
sense='L')
problem.solve()
print(problem.solution.get_values())
print(problem.solution.get_objective_value())
def __solver__(self, p):
for key in (SMALL_DELTA_X, SMALL_DELTA_F, IS_NAN_IN_X):
if key in p.kernelIterFuncs:
p.kernelIterFuncs.pop(key)
# reduce text output
# try:
# os.close(1); os.close(2) # may not work for non-Unix OS
# except:
# pass
n = p.n
P = CPLEX.Cplex()
P.set_results_stream(None)
if np.isfinite(p.maxTime):
P.parameters.timelimit.set(p.maxTime)
kwargs = {}
if hasattr(p, 'intVars') and len(p.intVars) != 0:
tmp = np.asarray(['C'] * n, dtype=object)
for v in p.intVars:
tmp[v] = 'I'
kwargs['types'] = ''.join(tmp.tolist())
lb, ub = np.copy(p.lb), np.copy(p.ub)
lb[lb == -np.inf] = -1e308
ub[ub == np.inf] = 1e308
P.variables.add(obj=p.f.tolist(),
ub=ub.tolist(),
lb=lb.tolist(),
**kwargs)
P.objective.set_sense(P.objective.sense.minimize)
LinConst2WholeRepr(p)
if p.Awhole is not None:
senses = ''.join(where(p.dwhole == -1, 'L', 'E').tolist())
P.linear_constraints.add(rhs=np.asarray(p.bwhole).tolist(),
senses=senses)
if p.Awhole.size != 0:
P.linear_constraints.set_coefficients(zip(*Find(p.Awhole)))
if p.probType.endswith('QP') or p.probType == 'SOCP':
# assert p.probType in ('QP', 'QCQP','SOCP')
P.objective.set_quadratic_coefficients(zip(*Find(p.H)))
for q, u, v in p.QC:
rows, cols, vals = Find(q)
quad_expr = CPLEX.SparseTriple(ind1=rows, ind2=cols, val=vals)
lin_expr = CPLEX.SparsePair(ind=np.arange(
np.atleast_1d(u).size),
val=u)
P.quadratic_constraints.add(
quad_expr=quad_expr,
lin_expr=lin_expr,
rhs=-v if isscalar(v) else -asscalar(v))
X = np.nan * np.ones(p.n)
if p.intVars in ([], (), None):
class ooContinuousCallback(CPLEX.callbacks.ContinuousCallback):
def __call__(self):
p.iterfcn(X, self.get_objective_value(),
self.get_primal_infeasibility())
if p.istop != 0:
self.abort()
P.register_callback(ooContinuousCallback)
else:
class ooMIPCallback(CPLEX.callbacks.MIPInfoCallback):
def __call__(self):
#if not self.aborted:
p.iterfcn(X, self.get_best_objective_value(), 0.0)
if p.istop != 0:
self.abort()
P.register_callback(ooMIPCallback)
#get_incumbent_values
# Temporary walkaround Cplex 12.2.0.0 bug with integers in QP/QCQP
P.SOS.get_num()
self.preprocessor(P, p)
p.extras['CplexProb'] = P
P.solve()
s = P.solution.get_status()
p.msg = 'Cplex status: "%s"; exit code: %d' % (
P.solution.get_status_string(), s)
try:
p.xf = p.xk = np.asfarray(P.solution.get_values())
p.istop = 1000
except CPLEX.exceptions.CplexError:
p.xf = p.x0 * np.nan
p.istop = -1
# TODO: replace by normal OOP solution
if s == P.solution.status.abort_iteration_limit:
p.istop = IS_MAX_ITER_REACHED
p.msg = 'Max Iter has been reached'
elif s == P.solution.status.abort_obj_limit:
p.istop = IS_MAX_FUN_EVALS_REACHED
p.msg = 'max objfunc evals limit has been reached'
elif s == P.solution.status.abort_time_limit or s == P.solution.status.conflict_abort_time_limit:
p.istop = IS_MAX_TIME_REACHED
p.msg = 'max time limit has been reached'
def solve_exact_cplex(mean, std_deviation, v, p):
problem = cplex.Cplex()
#Data Declaration
ti_mu = mean
ti_sigma = std_deviation
num_decision_var = len(ti_mu)
decision_variables = range(num_decision_var)
c = num_decision_var
#names = ["x_1", "x_2", "x_3", "c"]
# names = [int(i) for i in range(num_decision_var+1)] #num_decision_var+1 is for the 'c' continuous decision variable
# problem.variables.add(names=names)
problem.variables.add(types=[problem.variables.type.binary] *
num_decision_var)
problem.variables.add(types=[problem.variables.type.continuous])
# for i in range(len(names)-1):
# problem.variables.set_types(i, problem.variables.type.binary)
# problem.variables.set_types(len(names)-1, problem.variables.type.continuous)
#Objective
problem.objective.set_sense(problem.objective.sense.minimize)
objective = ti_mu #[ 1, 2, 3, 0]
#objective.append(0)
pairs = zip(decision_variables, objective)
problem.objective.set_linear(pairs)
#Linear Constraint
phi_p = norm.ppf(p)
lin_val = ti_mu
lin_val.append(-phi_p)
# print(t)
#lin_constraint = [["x_1", "x_2", "x_3", "c" ], [1, 2, 3, -phi_p]]
lin_constraint = [decision_variables, lin_val]
#v = -1
problem.linear_constraints.add(lin_expr=[lin_constraint],
rhs=[v],
senses='G')
# linear constraint to limit the number of 1s in the objective
cons = np.ones(num_decision_var).tolist()
lin_constraint2 = [decision_variables, cons]
problem.linear_constraints.add(lin_expr=[lin_constraint2],
rhs=[10],
senses='L')
#Quadratic Constraint
#quad_constraint = cplex.SparseTriple(ind1 = ["x_1", "x_2", "x_3", "c" ], ind2= ["x_1", "x_2", "x_3", "c" ], val = [1,1,1,-1])
quad_val = ti_sigma
quad_val.append(-1)
quad_constraint = cplex.SparseTriple(ind1=list(decision_variables) + [c],
ind2=list(decision_variables) + [c],
val=quad_val)
problem.quadratic_constraints.add(rhs=0.0,
quad_expr=quad_constraint,
name="Q",
sense='L')
#Solve
problem.solve()
#print(problem.solution.get_values())
#print(problem.solution.get_objective_value())
var_vals = problem.solution.get_values()
obj_vals = problem.solution.get_objective_value()
return var_vals, obj_vals
def solving():
# variables - vector w
#w = cvx.Variable(shape=(N, 1), complex=True)
xk = genRandomMatrix(2 * N, 6)
zk = xk[:, 0]
tk = 1
tk_next = tk
k = 0
while (1):
vk = zk
#print(k)
tk_next = np.sqrt(1 + 4 * tk * tk) / 2
if (k >= 1):
zk = xk[:, k] + (xk[:, k] - xk[:, k - 1]) * (tk - 1) / (tk_next)
check = False
F_zk = compute_F(zk)
for i in range(max(0, k - 5), k):
if (compute_F(xk[:, i - max(k - 5, 0)]) > F_zk):
check = True
break
if (check):
vk = zk
else:
vk = xk[:, min(5, k)]
############
k = k + 1
tk = tk_next
############Duy
problem_model = def_model(vk)
#reset constrain
problem_model.quadratic_constraints.delete()
problem_model.linear_constraints.delete()
#power constraint
list1 = []
list2 = []
list3 = []
quadratic_cs = P1 * D1_hat + P2 * D2_hat + np.identity(2 * N)
#print(quadratic_cs)
for i in range(0, 2 * N):
for j in range(0, i + 1):
if (quadratic_cs.item(i * (2 * N) + j) +
quadratic_cs.item(j * (2 * N) + i) > 0):
list1.append(list_var_name[i])
list2.append(list_var_name[j])
if (i == j):
list3.append(quadratic_cs.item(i * (2 * N) + j))
else:
list3.append(
quadratic_cs.item(i * (2 * N) + j) +
quadratic_cs.item(j * (2 * N) + i))
quad = cplex.SparseTriple(list1, list2, list3)
qsense = "L"
qrhs = Pt - P1 - P2
problem_model.quadratic_constraints.add(rhs=float(qrhs),
quad_expr=quad,
sense=qsense)
#Z_hat. x = 0 constraint
lin_expr = []
lin_senses = []
lin_rhs = []
for i in range(0, 4):
lin_list1 = []
lin_list2 = []
for j in range(2 * N):
lin_list1.append(list_var_name[j])
lin_list2.append(ZH_hat.item(i * (2 * N) + j))
lin_expr.append(cplex.SparsePair(lin_list1, lin_list2))
lin_rhs.append(0)
lin_senses.append("E")
problem_model.linear_constraints.add(lin_expr=lin_expr,
senses=lin_senses,
rhs=lin_rhs)
problem_model.solve()
if (problem_model.solution.status.infeasible):
print("Infeasible")
break
xk_next = problem_model.solution.get_values()
if (k <= 5):
for i in range(2 * N):
xk[i, k] = xk_next[i]
else:
for i in range(0, 5):
xk[:, i] = xk[:, i + 1]
xk[:, 5] = xk_next
if (abs(compute_F(xk_next) - compute_F(xk[:, min(4, k)])) /
(1 + compute_F(xk[:, min(4, k)])) < e):
print("Stop at 2nd condional loop")
print("Result: " + str(compute_F(xk_next)))
break
if (np.linalg.norm(xk_next - xk[:, min(4, k)]) /
(1 + np.linalg.norm(xk[:, min(4, k)]) *
np.linalg.norm(xk[:, min(4, k)])) < e):
print("Stop at 1st condional loop")
print("Result: " + str(compute_F(xk_next)))
break
def _import_rscone_constraint(self, picosConstraint):
import cplex
assert isinstance(picosConstraint, RSOCConstraint)
picosLHS = picosConstraint.ne
picosRHS1 = picosConstraint.ub1
picosRHS2 = picosConstraint.ub2
picosLHSLen = len(picosLHS)
# Make identifying names for the auxiliary variables and constraints.
conID = self._get_unique_constraint_id()
cplexLHSVars = ["{}:V{}".format(conID, i) for i in range(picosLHSLen)]
cplexRHSVars = [
"{}:V{}".format(conID, picosLHSLen + i) for i in (0, 1)
]
cplexLHSCons = ["{}:C{}".format(conID, i) for i in range(picosLHSLen)]
cplexRHSCons = [
"{}:C{}".format(conID, picosLHSLen + i) for i in (0, 1)
]
cplexQuadCon = "{}:C{}".format(conID, picosLHSLen + 2)
# Add auxiliary variables: One for every dimension of the left hand side
# of the PICOS constraint and two for its right hand side.
self.int.variables.add(names=cplexLHSVars,
lb=[-cplex.infinity] * picosLHSLen,
ub=[+cplex.infinity] * picosLHSLen,
types=self.int.variables.type.continuous *
picosLHSLen)
self.int.variables.add(names=cplexRHSVars,
lb=[0.0, 0.0],
ub=[+cplex.infinity] * 2,
types=self.int.variables.type.continuous * 2)
# Add constraints that identify the left hand side CPLEX auxiliary
# variables with their slice of the PICOS left hand side expression.
cplexLHSConsLHSs = []
cplexLHSConsRHSs = []
for localConIndex, (localLinExp, localConstant) in \
enumerate(self._affinexp_pic2cpl(picosLHS)):
localLinExp.ind.append(cplexLHSVars[localConIndex])
localLinExp.val.append(-1.0)
localConstant = -localConstant
cplexLHSConsLHSs.append(localLinExp)
cplexLHSConsRHSs.append(localConstant)
self.int.linear_constraints.add(names=cplexLHSCons,
lin_expr=cplexLHSConsLHSs,
senses="E" * picosLHSLen,
rhs=cplexLHSConsRHSs)
# Add two constraints that identify the right hand side CPLEX auxiliary
# variables with the PICOS right hand side scalar expressions.
cplexRHSConsLHSs = []
cplexRHSConsRHSs = []
for picosRHS, cplexRHSVar in zip((picosRHS1, picosRHS2), cplexRHSVars):
linExp, constant = self._scalar_affinexp_pic2cpl(-picosRHS)
linExp.ind.append(cplexRHSVar)
linExp.val.append(1.0)
constant = -constant
cplexRHSConsLHSs.append(linExp)
cplexRHSConsRHSs.append(constant)
self.int.linear_constraints.add(names=cplexRHSCons,
lin_expr=cplexRHSConsLHSs,
senses="E" * 2,
rhs=cplexRHSConsRHSs)
# Add a quadratic constraint over the auxiliary variables that
# represents the PICOS rotated second order cone constraint itself.
quadExpr = cplex.SparseTriple(
ind1=[cplexRHSVars[0]] + list(cplexLHSVars),
ind2=[cplexRHSVars[1]] + list(cplexLHSVars),
val=[-1.0] + [1.0] * picosLHSLen)
self.int.quadratic_constraints.add(name=cplexQuadCon,
quad_expr=quadExpr,
sense="L",
rhs=0.0)
cplexMetaCon = self.CplexRSOCC(LHSVars=cplexLHSVars,
RHSVars=cplexRHSVars,
LHSCons=cplexLHSCons,
RHSCons=cplexRHSCons,
quadCon=cplexQuadCon)
if self._debug():
cplexCons = {
"LHSs of LHS auxiliary equalities": cplexLHSConsLHSs,
"RHSs of LHS auxiliary equalities": cplexLHSConsRHSs,
"LHSs of RHS auxiliary equalities": cplexRHSConsLHSs,
"RHSs of RHS auxiliary equalities": cplexRHSConsRHSs,
"Non-positive quadratic term": quadExpr
}
self._debug("RScone constraint imported: {} → {}, {}".format(
picosConstraint, cplexMetaCon, cplexCons))
return cplexMetaCon
def portfolio(sector,bench,asset,MCAPQ,beta,alpha,qmat,Q_con,multiple,time_init):
c = cplex.Cplex()
t = c.variables.type
c.variables.add(names=["d"+str(i) for i in asset],obj=alpha,lb=[-1*bench[j] for j in asset])
c.variables.add(names=["q"+ str(j) for j in asset ], types=[t.binary for i in asset])
c.variables.add(names=["assum"], lb=[-99999])
c.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in asset], val=alpha)], senses=["E"],
rhs=[0.0], names=["sum"])
c.linear_constraints.set_linear_components("sum" , [["assum"], [-1.0]])
for i in asset:
c.linear_constraints.add(lin_expr = [cplex.SparsePair(ind = ["d"+str(i)], val = [1.0])],senses=["G"],rhs=[-1*bench[i]],names=[str(i)+"di_wi"])
# c.linear_constraints.set_linear_components(str(i)+"di_wi", [["w" + str(i)], [1.0]])
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i)], val=[1.0])], senses=["L"],
rhs=[0.05], names=["st_5_1"])
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i)], val=[1.0])], senses=["G"],
rhs=[-0.05], names=["st_5_2"])
c.linear_constraints.add(lin_expr = [cplex.SparsePair(ind = ["d"+str(i) for i in asset], val = [1.0]*len(asset))],senses=["E"],rhs=[0],names=["st_4"])
for j in sector:
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in sector[j]], val=[1.0]*len(sector[j]))], senses=["L"],
rhs=[0.1], names=["st_6_1"])
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in sector[j]], val=[1.0]*len(sector[j]))], senses=["G"],
rhs=[-0.1], names=["st_6_2"])
for j in MCAPQ:
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in MCAPQ[j]], val=[1.0]*len(MCAPQ[j]))], senses=["L"],
rhs=[0.1], names=["st_7_1"])
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in MCAPQ[j]], val=[1.0]*len(MCAPQ[j]))], senses=["G"],
rhs=[-0.1], names=["st_7_2"])
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in asset], val=[beta[i] for i in asset])], senses=["L"],
rhs=[0.1], names=["st_8_1"])
c.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=["d" + str(i) for i in asset], val=[beta[i] for i in asset])], senses=["G"],
rhs=[-0.1], names=["st_8_2"])
for i in asset:
c.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=["q" + str(i)], val=[1.0])], senses=["G"],
rhs=[bench[i]], names=["st_q"+str(i)])
c.linear_constraints.set_linear_components("st_q"+str(i), [["d" + str(i)], [-1.0]])
c.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=["q" + str(i)], val=[1.0])], senses=["L"],
rhs=[0.999+bench[i]], names=["st_qq" + str(i)])
c.linear_constraints.set_linear_components("st_qq" + str(i), [["d" + str(i)], [-1.0]])
c.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=["q" + str(i) for i in asset], val=[1.0]*len(asset))], senses=["G"],
rhs=[60], names=["st_9_1"])
c.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=["q" + str(i) for i in asset], val=[1.0]*len(asset))], senses=["L"],
rhs=[70], names=["st_9_2"])
Q3 = cplex.SparseTriple(ind1=Q_con[0], ind2=Q_con[1], val=Q_con[2])
c.quadratic_constraints.add(rhs=0.01*multiple, quad_expr=Q3, name="st_11_1", sense="L")
c.objective.set_quadratic(qmat)
c.objective.set_sense(c.objective.sense.minimize)
c.parameters.threads.set(1)
c.parameters.timelimit.set(time_init)
c.solve()
total0=[]
total1=[]
total2=[]
total3=[]
w_dics0={}
d_dics0={}
w_dics1={}
d_dics1={}
w_dics2={}
d_dics2={}
w_dics3={}
d_dics3={}
numa = 0
print(c.solution.get_status())
pool_list = []
for i in asset:
w_dics0.update({str(i):bench[i] + c.solution.pool.get_values(0, "d" + str(i))})
d_dics0.update({str(i):c.solution.pool.get_values(0, "d" + str(i))})
w_dics1.update({str(i):bench[i] + c.solution.pool.get_values(1, "d" + str(i))})
d_dics1.update({str(i):c.solution.pool.get_values(1, "d" + str(i))})
#w_dics2.update({str(i):bench[i] + c.solution.pool.get_values(2, "d" + str(i))})
#d_dics2.update({str(i):c.solution.pool.get_values(2, "d" + str(i))})
#w_dics3.update({str(i):bench[i] + c.solution.pool.get_values(3, "d" + str(i))})
#d_dics3.update({str(i):c.solution.pool.get_values(7, "d" + str(i))})
numa += 1
total0.append(w_dics0)
total0.append(d_dics0)
total0.append(c.solution.pool.get_objective_value(0))
total1.append(w_dics1)
total1.append(d_dics3)
#total1.append(c.solution.pool.get_objective_value(1))
#total2.append(w_dics2)
#total2.append(d_dics2)
#total2.append(c.solution.pool.get_objective_value(2))
#total3.append(w_dics3)
#total3.append(d_dics3)
#total3.append(c.solution.pool.get_objective_value(3))
pool_list.append(total0)
pool_list.append(total1)
# pool_list.append(total2)
# pool_list.append(total3)
return pool_list
