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
