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