def solve_approx(self,g_corr=None,tol=1e-4,quiet=False,samples=500,init_data=None):
"""
Solves certainty equivalent problem
with slope correction.
Parameters
----------
g_corr : slope correction
tol : optimality tolerance
quiet : flag
samples : number of samples
Returns
-------
p : generator powers
"""
# Constants
num_p = self.num_p
num_w = self.num_w
num_r = self.num_r
num_bus = self.num_bus
num_br = self.num_br
Ow = coo_matrix((num_w,num_w))
Os = coo_matrix((num_r,num_r))
Oz = coo_matrix((num_br,num_br))
Onp = coo_matrix((num_bus,num_p))
Onz = coo_matrix((num_bus,num_br))
ow = np.zeros(num_w)
os = np.zeros(num_r)
oz = np.zeros(num_br)
Iz = eye(num_br,format='coo')
# Slope correction
if g_corr is None:
g_corr = np.zeros(num_p)
# Problem construction
H = bmat([[self.H0+self.H1,-self.H1,None,None,None], # p
[-self.H1,self.H1,None,None,None], # y = p + q
[None,None,Ow,None,None], # w
[None,None,None,Os,None], # s
[None,None,None,None,Oz]], # z
format='coo')
g = np.hstack((self.g0-self.g1+g_corr,self.g1,ow,os,oz))
A = bmat([[Onp,self.G,-self.A,self.R,Onz],
[None,None,self.J,None,-Iz]],format='coo')
b = np.hstack((self.b,oz))
l = np.hstack((self.p_min, # p
self.p_min, # y
self.w_min, # w
os, # s
self.z_min)) # z
u = np.hstack((self.p_max,
self.p_max,
self.w_max,
self.Er,
self.z_max))
# Problem
if init_data is None:
problem = QuadProblem(H,g,A,b,l,u)
else:
problem = QuadProblem(H,g,A,b,l,u,
x=init_data['x'],
lam=init_data['lam'],
mu=init_data['mu'],
pi=init_data['pi'])
# Solve
solver = OptSolverIQP()
solver.set_parameters({'quiet':quiet,
'tol':tol})
solver.solve(problem)
results = solver.get_results()
x = results['x']
lam = results['lam']
mu = results['mu']
pi = results['pi']
# Check
problem.eval(x)
gphi = problem.gphi
assert(norm(gphi-A.T*lam+mu-pi) < (1e-6)*(norm(gphi)+norm(lam)+norm(mu)+norm(pi)))
assert(norm(mu*(u-x)) < (1e-6)*(norm(mu)+norm(u-x)))
assert(norm(pi*(x-l)) < (1e-6)*(norm(pi)+norm(x-l)))
assert(np.all(x < u))
assert(np.all(x > l))
assert(norm(A*x-b) < (1e-6)*norm(b))
# Return
return x[:num_p],results
import sys
sys.path.append('.')
import numpy as np
from optalg.opt_solver import OptSolverIQP, QuadProblem
g = np.array([3., -6.])
H = np.array([[10., -2], [-2., 10]])
A = np.array([[1., 1.]])
b = np.array([1.])
u = np.array([0.8, 0.8])
l = np.array([0.2, 0.2])
problem = QuadProblem(H, g, A, b, l, u)
solver = OptSolverIQP()
solver.set_parameters({'quiet': True, 'tol': 1e-6})
solver.solve(problem)
print solver.get_status()
x = solver.get_primal_variables()
lam, nu, mu, pi = solver.get_dual_variables()
print x
print x[0] + x[1]
