def abs_canon(expr, real_args, imag_args, real2imag): # Imaginary. if real_args[0] is None: output = abs(imag_args[0]) elif imag_args[0] is None: # Real output = abs(real_args[0]) else: # Complex. real = real_args[0].flatten() imag = imag_args[0].flatten() norms = pnorm(vstack([real, imag]), p=2, axis=0) output = reshape(norms, real_args[0].shape) return output, None
def abs(self, solver): u = Variable(2) constr = [] constr += [abs(u[1] - u[0]) <= 100] prob = Problem(Minimize(sum_squares(u)), constr) print(("The problem is QP: ", prob.is_qp())) self.assertEqual(prob.is_qp(), True) result = prob.solve(solver=solver) self.assertAlmostEqual(result, 0)
def test_square_param(self): """Test issue arising with square plus parameter. """ a = Parameter(value=1) b = Variable() obj = Minimize(b**2 + abs(a)) prob = Problem(obj) prob.solve() self.assertAlmostEqual(obj.value, 1.0)
def quad_over_lin(self, solver): p = Problem(Minimize(0.5 * quad_over_lin(abs(self.x-1), 1)), [self.x <= -1]) self.solve_QP(p, solver) for var in p.variables(): self.assertItemsAlmostEqual(np.array([-1., -1.]), var.value, places=4) for con in p.constraints: self.assertItemsAlmostEqual(np.array([2., 2.]), con.dual_value, places=4)
def quad_over_lin(self, solver): p = Problem(Minimize(0.5 * quad_over_lin(abs(self.x - 1), 1)), [self.x <= -1]) s = self.solve_QP(p, solver) for var in p.variables(): self.assertItemsAlmostEqual(numpy.array([-1., -1.]), s.primal_vars[var.id]) for con in p.constraints: self.assertItemsAlmostEqual(numpy.array([2., 2.]), s.dual_vars[con.id])
def scp(p,bad_constr,sol): """ Description: Sequential convex programming algorithm. Solve program p and try to enforce equality on the bad constraints. Argument p: cvxpy_program is assumed to be in expanded and equivalent format. Argument bad_constr: List of nonconvex constraints, also in expanded and equivalent format. Argument sol: Solution of relaxation. """ # Quit if program is linear if(len(bad_constr) == 0): if(not p.options['quiet']): print 'Tightening not needed' return True # Get parameters tight_tol = p.options['SCP_ALG']['tight tol'] starting_lambda = p.options['SCP_ALG']['starting lambda'] max_scp_iter = p.options['SCP_ALG']['max scp iter'] lambda_multiplier = p.options['SCP_ALG']['lambda multiplier'] max_lambda = p.options['SCP_ALG']['max lambda'] top_residual = p.options['SCP_ALG']['top residual'] # Construct slacks slacks = [abs(c.left-c.right) for c in bad_constr] # Print header if(not p.options['quiet']): print 'Iter\t:', print 'Max Slack\t:', print 'Objective\t:', print 'Solver Status\t:', print 'Pres\t\t:', print 'Dres\t\t:', print 'Lambda Max/Min' # SCP Loop lam = starting_lambda*np.ones(len(slacks)) for i in range(0,max_scp_iter,1): # Calculate max slack max_slack = max(map(lambda x:x.get_value(), slacks)) # Quit if status is primal infeasible if(sol['status'] == 'primal infeasible'): if(not p.options['quiet']): print 'Unable to tighten: Problem became infeasible' return False # Check if dual infeasible if(sol['status'] == 'dual infeasible'): sol['status'] = 'dual inf' sol['primal infeasibility'] = np.NaN sol['dual infeasibility'] = np.NaN # Print values if(not p.options['quiet']): print '%d\t:' %i, print '%.3e\t:' %max_slack, print '%.3e\t:' %p.obj.get_value(), print ' '+sol['status']+'\t:', if(sol['primal infeasibility'] is not np.NaN): print '%.3e\t:' %sol['primal infeasibility'], else: print '%.3e\t\t:' %sol['primal infeasibility'], if(sol['dual infeasibility'] is not np.NaN): print '%.3e\t:' %sol['dual infeasibility'], else: print '%.3e\t\t:' %sol['dual infeasibility'], print '(%.1e,%.1e)' %(np.max(lam),np.min(lam)) # Quit if max slack is small if(max_slack < tight_tol and sol['status'] == 'optimal'): if(not p.options['quiet']): print 'Tightening successful' return True # Quit if residual is too large if(sol['primal infeasibility'] >= top_residual or sol['dual infeasibility'] >= top_residual): if(not p.options['quiet']): print 'Unable to tighten: Residuals are too large' return False # Linearize slacks linear_slacks = [] for c in bad_constr: fn = c.left.item args = c.left.children right = c.right line = fn._linearize(args,right) linear_slacks += [line] # Add linearized slacks to objective sum_lin_slacks = 0.0 for j in range(0,len(slacks),1): sum_lin_slacks += lam[j]*linear_slacks[j] if(p.action == MINIMIZE): new_obj = p.obj + sum_lin_slacks else: new_obj = p.obj - sum_lin_slacks new_t0, obj_constr = expand(new_obj) new_p = prog((p.action,new_t0), obj_constr+p.constr,[],p.options) # Solve new problem sol = solve_convex(new_p,'scp') # Update lambdas for j in range(0,len(slacks),1): if(slacks[j].get_value() >= tight_tol): if(lam[j] < max_lambda): lam[j] = lam[j]*lambda_multiplier # Maxiters reached if(not p.options['quiet']): print 'Unable to tighten: Maximum iterations reached' if(sol['status'] == 'optimal'): return True else: return False