def prob_mat_vs_mul_funcs(self, prob):
data, dims = prob.get_problem_data(solver=SCS)
A = data["A"]
objective, constr_map, dims, solver = prob.canonicalize(SCS)
all_ineq = constr_map[s.EQ] + constr_map[s.LEQ]
var_offsets, var_sizes, x_length = prob._get_var_offsets(objective,
all_ineq)
opts = {}
constraints = constr_map[s.EQ] + constr_map[s.LEQ]
constraints = prune_constants(constraints)
Amul, ATmul = iterative.get_mul_funcs(constraints, dims,
var_offsets, var_sizes,
x_length)
vec = np.array(range(1, x_length+1))
# A*vec
result = np.zeros(A.shape[0])
Amul(vec, result)
mul_mat = self.mat_from_func(Amul, A.shape[0], A.shape[1])
self.assertItemsAlmostEqual(A*vec, result)
Amul(vec, result)
self.assertItemsAlmostEqual(2*A*vec, result)
# A.T*vec
vec = np.array(range(A.shape[0]))
result = np.zeros(A.shape[1])
ATmul(vec, result)
self.assertItemsAlmostEqual(A.T*vec, result)
ATmul(vec, result)
self.assertItemsAlmostEqual(2*A.T*vec, result)
def test_mul_funcs(self):
"""Test functions to multiply by A, A.T
"""
n = 10
x = Variable(n)
obj = Minimize(norm(x, 1))
constraints = [x >= 2]
prob = Problem(obj, constraints)
data, dims = prob.get_problem_data(solver=SCS)
A = data["A"]
objective, constraints = prob.canonicalize()
sym_data = SymData(objective, constraints, SOLVERS[SCS])
sym_data.constraints = prune_constants(sym_data.constraints)
Amul, ATmul = iterative.get_mul_funcs(sym_data)
vec = np.array(range(sym_data.x_length))
# A*vec
result = np.zeros(A.shape[0])
Amul(vec, result)
self.assertItemsAlmostEqual(A * vec, result)
Amul(vec, result)
self.assertItemsAlmostEqual(2 * A * vec, result)
# A.T*vec
vec = np.array(range(A.shape[0]))
result = np.zeros(A.shape[1])
ATmul(vec, result)
self.assertItemsAlmostEqual(A.T * vec, result)
ATmul(vec, result)
self.assertItemsAlmostEqual(2 * A.T * vec, result)
def prob_mat_vs_mul_funcs(self, prob):
data, dims = prob.get_problem_data(solver=SCS)
A = data["A"]
objective, constr_map, dims, solver = prob.canonicalize(SCS)
all_ineq = constr_map[s.EQ] + constr_map[s.LEQ]
var_offsets, var_sizes, x_length = prob._get_var_offsets(
objective, all_ineq)
opts = {}
constraints = constr_map[s.EQ] + constr_map[s.LEQ]
constraints = prune_constants(constraints)
Amul, ATmul = iterative.get_mul_funcs(constraints, dims, var_offsets,
var_sizes, x_length)
vec = np.array(range(1, x_length + 1))
# A*vec
result = np.zeros(A.shape[0])
Amul(vec, result)
mul_mat = self.mat_from_func(Amul, A.shape[0], A.shape[1])
self.assertItemsAlmostEqual(A * vec, result)
Amul(vec, result)
self.assertItemsAlmostEqual(2 * A * vec, result)
# A.T*vec
vec = np.array(range(A.shape[0]))
result = np.zeros(A.shape[1])
ATmul(vec, result)
self.assertItemsAlmostEqual(A.T * vec, result)
ATmul(vec, result)
self.assertItemsAlmostEqual(2 * A.T * vec, result)
def test_mul_funcs(self):
"""Test functions to multiply by A, A.T
"""
n = 10
x = Variable(n)
obj = Minimize(norm(x, 1))
constraints = [x >= 2]
prob = Problem(obj, constraints)
data = prob.get_problem_data(solver=SCS)
A = data["A"]
objective, constraints = prob.canonicalize()
sym_data = SymData(objective, constraints, SOLVERS[SCS])
sym_data.constraints = prune_constants(sym_data.constraints)
Amul, ATmul = iterative.get_mul_funcs(sym_data)
vec = np.array(range(sym_data.x_length))
# A*vec
result = np.zeros(A.shape[0])
Amul(vec, result)
self.assertItemsAlmostEqual(A * vec, result)
Amul(vec, result)
self.assertItemsAlmostEqual(2 * A * vec, result)
# A.T*vec
vec = np.array(range(A.shape[0]))
result = np.zeros(A.shape[1])
ATmul(vec, result)
self.assertItemsAlmostEqual(A.T * vec, result)
ATmul(vec, result)
self.assertItemsAlmostEqual(2 * A.T * vec, result)
def test_mul_funcs(self):
"""Test functions to multiply by A, A.T
"""
n = 10
x = Variable(n)
obj = Minimize(norm(x, 1))
constraints = [x >= 2]
prob = Problem(obj, constraints)
data, dims = prob.get_problem_data(solver=SCS)
A = data["A"]
objective, constr_map, dims, solver = prob.canonicalize(SCS)
all_ineq = constr_map[s.EQ] + constr_map[s.LEQ]
var_offsets, var_sizes, x_length = prob._get_var_offsets(
objective, all_ineq)
opts = {}
constraints = constr_map[s.EQ] + constr_map[s.LEQ]
constraints = prune_constants(constraints)
Amul, ATmul = iterative.get_mul_funcs(constraints, dims, var_offsets,
var_sizes, x_length)
vec = np.array(range(x_length))
# A*vec
result = np.zeros(A.shape[0])
Amul(vec, result)
self.assertItemsAlmostEqual(A * vec, result)
Amul(vec, result)
self.assertItemsAlmostEqual(2 * A * vec, result)
# A.T*vec
vec = np.array(range(A.shape[0]))
result = np.zeros(A.shape[1])
ATmul(vec, result)
self.assertItemsAlmostEqual(A.T * vec, result)
ATmul(vec, result)
self.assertItemsAlmostEqual(2 * A.T * vec, result)
def test_mul_funcs(self):
"""Test functions to multiply by A, A.T
"""
n = 10
x = Variable(n)
obj = Minimize(norm(x, 1))
constraints = [x >= 2]
prob = Problem(obj, constraints)
data, dims = prob.get_problem_data(solver=SCS)
A = data["A"]
objective, constr_map, dims, solver = prob.canonicalize(SCS)
all_ineq = constr_map[s.EQ] + constr_map[s.LEQ]
var_offsets, var_sizes, x_length = prob._get_var_offsets(objective,
all_ineq)
opts = {}
constraints = constr_map[s.EQ] + constr_map[s.LEQ]
constraints = prune_constants(constraints)
Amul, ATmul = iterative.get_mul_funcs(constraints, dims,
var_offsets, var_sizes,
x_length)
vec = np.array(range(x_length))
# A*vec
result = np.zeros(A.shape[0])
Amul(vec, result)
self.assertItemsAlmostEqual(A*vec, result)
Amul(vec, result)
self.assertItemsAlmostEqual(2*A*vec, result)
# A.T*vec
vec = np.array(range(A.shape[0]))
result = np.zeros(A.shape[1])
ATmul(vec, result)
self.assertItemsAlmostEqual(A.T*vec, result)
ATmul(vec, result)
self.assertItemsAlmostEqual(2*A.T*vec, result)
def get_problem_data(self, objective, constraints, cached_data):
"""Returns the argument for the call to the solver.
Parameters
----------
objective : LinOp
The canonicalized objective.
constraints : list
The list of canonicalized cosntraints.
cached_data : dict
A map of solver name to cached problem data.
Returns
-------
tuple
(solver args tuple, offset)
"""
sym_data = self.get_sym_data(objective, constraints, cached_data)
matrix_data = self.get_matrix_data(objective, constraints,
cached_data)
c, offset = matrix_data.get_objective()
all_ineq = sym_data.constr_map[s.EQ] + sym_data.constr_map[s.LEQ]
A_rows = sum(constr.size[0]*constr.size[1] for constr in all_ineq)
b = -iterative.constr_mul(all_ineq, {}, A_rows)
data = {"c": c}
#data["A"] = matrix_data.get_eq_constr()[0]
data["A"] = self.matrix_intf().zeros(A_rows, sym_data.x_length)
data["b"] = b
# Remove constants from expressions.
constraints = tree_mat.prune_constants(all_ineq)
Amul, ATmul, getDE, getM = iterative.get_mul_funcs(sym_data, constraints)
data["Amul"] = Amul
data["ATmul"] = ATmul
data["getDE"] = getDE
data["getM"] = getM
return (data, sym_data.dims), offset
def get_problem_data(self, objective, constraints, cached_data):
"""Returns the argument for the call to the solver.
Parameters
----------
objective : LinOp
The canonicalized objective.
constraints : list
The list of canonicalized cosntraints.
cached_data : dict
A map of solver name to cached problem data.
Returns
-------
tuple
(solver args tuple, offset)
"""
sym_data = self.get_sym_data(objective, constraints, cached_data)
matrix_data = self.get_matrix_data(objective, constraints, cached_data)
c, offset = matrix_data.get_objective()
all_ineq = sym_data.constr_map[s.EQ] + sym_data.constr_map[s.LEQ]
A_rows = sum(constr.size[0] * constr.size[1] for constr in all_ineq)
b = -iterative.constr_mul(all_ineq, {}, A_rows)
data = {"c": c}
#data["A"] = matrix_data.get_eq_constr()[0]
data["A"] = self.matrix_intf().zeros(A_rows, sym_data.x_length)
data["b"] = b
# Remove constants from expressions.
constraints = tree_mat.prune_constants(all_ineq)
Amul, ATmul, getDE, getM = iterative.get_mul_funcs(
sym_data, constraints)
data["Amul"] = Amul
data["ATmul"] = ATmul
data["getDE"] = getDE
data["getM"] = getM
return (data, sym_data.dims), offset
