# # matrix X
# # A*X is map(A*x, X)
# # X*A
minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
# minimize c'*a
# norm(X*a,Y*a,Z*a, W*a) <= 1
"""
)
# TODO: sum(norms(X))
# A*x
#
p.solve()
pr = cProfile.Profile()
pr.enable()
p.canonicalize()
p.dims = {"n": n, "m": m}
p.codegen("python")
print p.prob2socp.source
socp_data = p.prob2socp(params=locals())
import ecos
sol = ecos.solve(**socp_data)
my_vars = p.socp2prob(sol["x"])
pr.disable()
ps = pstats.Stats(pr)
ps.sort_stats("cumulative").print_stats(0.5)
for i in range(m):
a = np.random.randn(n)
a = a / np.linalg.norm(a)
bi = 1 + np.random.rand(1)
A[i, :] = a
b[i] = bi
q = QCML()
q.parse('''
dimensions m n
variables x(n) r
parameters A(m,n) b(m)
maximize r
A*x + r <= b
''')
q.canonicalize()
q.dims = {'m': m, 'n': n}
q.codegen("python")
socp_data = q.prob2socp(locals())
# stuffed variable size
n = socp_data['G'].shape[1]
ecos_sol = ecos.solve(**socp_data)
socp_sol = ecos_sol['x']
prob_sol_x = q.socp2prob(ecos_sol['x'])['x']
prob_sol_r = q.socp2prob(ecos_sol['x'])['r']
p.canonicalize()
raw_input("press ENTER to generate python code....")
p.dims = {'m': m, 'n': n, 'pb': pb, 'sb': sb}
p.codegen("python")
raw_input("press ENTER to solve with ECOS....")
socp_data = p.prob2socp(params=locals())
import ecos
sol = ecos.solve(**socp_data)
optval = sol.get("info").get("pcost")
print "The minimum attenuation in the stop band is " + str(
10 * log10(optval)) + " dB."
vars = p.socp2prob(sol['x'])
r = transpose(asmatrix(vars['r']))
# Spectral Factorization
jay = complex(0, 1)
mult_factor = 100
m = mult_factor * n
w = 2 * linspace(0, pi - pi / m, m)
A = zeros((m, n))
A[0:m, 0] = 1
for i in range(0, m):
for j in range(1, n):
A[i, j] = 2 * cos(j * w[i])
R = A * r
raw_input("press ENTER to canonicalize....")
p.canonicalize()
raw_input("press ENTER to generate python code....")
p.dims = {'m': m, 'n': n, 'pb': pb, 'sb': sb}
p.codegen("python")
raw_input("press ENTER to solve with ECOS....")
socp_data = p.prob2socp(params=locals())
import ecos
sol = ecos.solve(**socp_data)
optval = sol.get("info").get("pcost")
print "The minimum attenuation in the stop band is " + str(10*log10(optval)) + " dB."
vars = p.socp2prob(sol['x'])
r = transpose(asmatrix(vars['r']))
# Spectral Factorization
jay = complex(0,1)
mult_factor = 100
m = mult_factor*n
w = 2*linspace(0,pi-pi/m,m)
A = zeros((m,n))
A[0:m, 0] = 1
for i in range(0, m) :
for j in range(1, n) :
A[i,j] = 2*cos(j*w[i])
R = A*r
p.canonicalize()
dims = {'mn':rows*cols, 'two_mn':D.shape[0]}
p.codegen("python") # this creates a solver in Python calling CVXOPT
socp_data = p.prob2socp({'blurmat':blurmat,
'g':blurred,
'D':D,
'mu':25}, dims)
# sol = ecos.solve(**socp_data)
print socp_data
A = socp_data['G']
c = socp_data['c']
b = socp_data['h']
data = {'A':A, 'c':c, 'b':b}
cone = socp_data['dims']
sol = scs.solve(data, cone, opts = None, USE_INDIRECT = False)
my_vars = p.socp2prob(sol['x'], {'mn': rows*cols})
print my_vars
x = my_vars['x'].reshape(rows,cols)
#sol = ecos.solve(**socp_data)
#my_vars = p.socp2prob(sol['x'], dims)
# print my_vars
# x = my_vars['x']
# print np.around(x)
# x = x.reshape(urows, ucols)
# # objective = cp.Minimize(
# # cp.square(cp.norm(unblurred.__rmul__(blurmat) - imgvec, 2))
# # + 1./sigma**2 * (
# # cp.square(cp.norm(unblurred.__rmul__(blurmat), 2))
# # + cp.square(cp.norm(unblurred.__rmul__(blurmat), 2))))
raw_input("press ENTER to canonicalize....")
p.canonicalize()
raw_input("press ENTER to generate python code....")
p.dims = {'m': m, 'n': n, 'pb': pb, 'sb': sb}
p.codegen("python")
raw_input("press ENTER to solve with ECOS....")
socp_data = p.prob2socp(params=locals())
import ecos
sol = ecos.solve(**socp_data)
optval = sol.get("info").get("pcost")
print "The minimum attenuation in the stop band is " + str(10*log10(optval)) + " dB."
vars = p.socp2prob(sol['x'], sol['y'], sol['z'])
r = transpose(asmatrix(vars['r']))
# Spectral Factorization
jay = complex(0,1)
mult_factor = 100
m = mult_factor*n
w = 2*linspace(0,pi-pi/m,m)
A = zeros((m,n))
A[0:m, 0] = 1
for i in range(0, m) :
for j in range(1, n) :
A[i,j] = 2*cos(j*w[i])
R = A*r
parameter X(m,n) # positive samples
parameter Y(m,n) # negative samples
parameter gamma positive
minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
"""
p = QCML()
p.parse(s)
p.canonicalize()
p.dims = {'n': n, 'm': m}
p.codegen("python")
socp_vars = p.prob2socp(locals())
# convert to CSR for fast row slicing to distribute problem
if socp_vars['A'] is not None:
socp_vars['A'] = socp_vars['A'].tocsr()
socp_vars['G'] = socp_vars['G'].tocsr()
# the size of the stuffed x or v
n = socp_vars['G'].shape[1]
ecos_sol = ecos.solve(**socp_vars)
# solution to transformed socp (stuffed)
socp_sol = ecos_sol['x']
# solution to original problem (unstuffed)
prob_sol_a = p.socp2prob(ecos_sol['x'])['a']
prob_sol_b = p.socp2prob(ecos_sol['x'])['b']
