def setUp(self):
np.random.seed(0)
m = 10
n = 20
p = 15
self.m = m
self.n = n
self.p = p
self.var_mn = cg.Variable(m, n, name='var_mn')
self.var_np = cg.Variable(n, p, name='var_np')
self.var_mp = cg.Variable(m, p, name='var_mp')
self.var_pn = cg.Variable(p, n, name='var_pn')
self.var_nn = cg.Variable(n, n, name='var_nn')
self.var_n1 = cg.Variable(n, 1, name='var_n1')
self.var_1n = cg.Variable(1, n, name='var_1n')
self.var_11 = cg.Variable(1, 1, name='var_11')
self.param_mn = cg.Parameter(m, n, name='param_mn', value=np.random.randn(m, n))
self.param_np = cg.Parameter(n, p, name='param_np', value=np.random.randn(n, p))
self.param_mp = cg.Parameter(m, p, name='param_mp', value=np.random.randn(m, p))
self.param_pn = cg.Parameter(p, n, name='param_pn', value=np.random.randn(p, n))
self.param_nn = cg.Parameter(n, n, name='param_nn', value=np.random.randn(n, n))
self.param_n1 = cg.Parameter(n, 1, name='param_n1', value=np.random.randn(n, 1))
self.param_1n = cg.Parameter(1, n, name='param_1n', value=np.random.randn(1, n))
self.param_11 = cg.Parameter(1, 1, name='param_11', value=np.random.randn(1, 1))
self.const_mn = np.random.randn(m, n)
self.const_np = np.random.randn(n, p)
self.const_mp = np.random.randn(m, p)
self.const_pn = np.random.randn(p, n)
self.const_nn = np.random.randn(n, n)
self.const_n1 = np.random.randn(n, 1)
self.const_1n = np.random.randn(1, n)
self.const_11 = np.random.randn(1, 1)
def mpc_setup(self):
np.random.seed(0)
n = 5
m = 10
self.A_val = np.random.randn(m, n)
self.b_val = np.random.randn(m, 1)
A = cg.Parameter(m, n, name='A', value=self.A_val)
b = cg.Parameter(m, 1, name='b', value=self.b_val)
x = cg.Variable(n, name='x')
objective = cg.norm(A * x - b)
self.prob = cg.Problem(cg.Minimize(objective))
self.prob.solve()
self.x_opt = x.value
def test_param_data(self):
n = 10
m = 5
A = cg.Parameter(m, n, name='A')
A_paramdata = ParamData(A)
# Sparsity pattern.
A_sparsity = sp.csr_matrix(np.full((m, n), True, dtype=bool))
self.assertEqualMatrices(A_paramdata.sparsity, A_sparsity)
# Value
self.assertEqualLists(A_paramdata.value.shape, (m, n))
A_value = np.random.randn(m, n)
A.value = A_value
A_paramdata = ParamData(A)
self.assertEqualMatrices(A_paramdata.value, A_value)
# Other attributes
self.assertEqual(A_paramdata.args, [])
self.assertEqual(A_paramdata.size, (m, n))
self.assertEqual(A_paramdata.length, m * n)
self.assertEqual(A_paramdata.type, 'param')
self.assertEqual(A_paramdata.name, 'A')
self.assertEqual(A_paramdata.var_ids, [CONST_ID])
self.assertEqual(A_paramdata.mem_name, 'A')
def mpc_setup(self, objective='quad'):
np.random.seed(0)
n = 3
m = 1
T = 6
self.A_val = np.eye(n) + .2 * np.random.randn(n, n)
self.B_val = 5 * np.random.randn(n, m)
self.x0_val = 5 * np.random.randn(n, 1)
A = cg.Parameter(n, n, name='A')
B = cg.Parameter(n, m, name='B')
x0 = cg.Parameter(n, 1, name='x0')
A.value = self.A_val
B.value = self.B_val
x0.value = self.x0_val
x = cg.Variable(n, T + 1, name='x')
u = cg.Variable(m, T, name='u')
obj = 0
constr = []
constr += [x[:, 0] == x0]
for t in range(T):
constr += [x[:, t + 1] == A * x[:, t] + B * u[:, t]]
constr += [cg.norm(u[:, t], 'inf') <= 1]
if objective == 'quad':
obj += cg.sum_squares(x[:, t + 1]) + cg.sum_squares(u[:, t])
elif objective == '1norm':
obj += cg.norm(x[:, t + 1], 1) + cg.norm(u[:, t], 1)
elif objective == 'exp1norm':
obj += cg.exp(cg.norm(x[:, t + 1], 1)) + cg.norm(u[:, t], 1)
else:
raise Exception
self.prob = cg.Problem(cg.Minimize(obj), constr)
self.prob.solve()
self.x_opt = x.value
def param_setup(self, atom=None):
np.random.seed(0)
m = 5
n = 10
p = 7
A = cg.Parameter(m,n, name='A', value=np.random.randn(m,n))
B = cg.Parameter(n,p, name='B', value=np.random.randn(n,p))
C = cg.Parameter(m,p, name='C', value=np.random.randn(m,p))
D = cg.Parameter(p,n, name='D', value=np.random.randn(p,n))
P = cg.Parameter(n,n, name='P', value=np.random.randn(n,n))
r = cg.Parameter(1,n, name='r', value=np.random.randn(1,n))
c = cg.Parameter(n,1, name='c', value=np.random.randn(n,1))
params = [A, B, C, D, P, r, c]
self.params = dict([(p.name(), p.value) for p in params])
if atom == 'abs':
rhs = cg.abs(A)
elif atom == 'add':
rhs = A+A
elif atom == 'diag_vec':
rhs = cg.diag(c)
elif atom == 'diag_mat':
rhs = cg.diag(P)
elif atom == 'hstack':
rhs = cg.hstack(A, C)
elif atom == 'index':
rhs = A[0:4:2, 1:9:3]
elif atom == 'max_entries':
rhs = cg.max_entries(A)
elif atom == 'mul':
rhs = A*B
elif atom == 'neg':
rhs = -A
elif atom == 'reshape':
rhs = cg.reshape(A, n, m)
elif atom == 'trace':
rhs = cg.trace(P)
elif atom == 'vstack':
rhs = cg.vstack(A, D)
x = cg.Variable(rhs.size[0], rhs.size[1], name='x')
constr = [rhs == x]
obj = 0
self.prob = cg.Problem(cg.Minimize(obj), constr)
self.prob.solve()
self.x_opt = x.value
import unittest import cvxpy_codegen.tests.utils as tu import cvxpy_codegen as cg import numpy as np import cvxpy_codegen.linop_sym.sym_matrix as sym import scipy.sparse as sp m = 5 n = 6 p = 8 dens = .3 A_sparse = sp.rand(m, n, dens) A_sym = sym.as_sym_matrix(A_sparse) A_dense = A_sparse.toarray() A_param = sym.as_sym_matrix(cg.Parameter(m, n, value=A_sparse)) B_sparse = sp.rand(n, p, dens) B_sym = sym.as_sym_matrix(B_sparse) B_dense = B_sparse.toarray() B_param = sym.as_sym_matrix(cg.Parameter(n, p, value=B_sparse)) C_sparse = sp.rand(m, n, dens) C_sym = sym.as_sym_matrix(C_sparse) C_dense = C_sparse.toarray() C_param = sym.as_sym_matrix(cg.Parameter(m, n, value=C_sparse)) alpha = .5 alpha_sym = sym.SymConst(.5) alpha_symmat = sym.as_sym_matrix(.5) alpha_dense = np.eye(1) * alpha