def make_linC_from_linPy(linPy, linPy_to_linC):
"""Construct a C++ LinOp corresponding to LinPy.
Children of linPy are retrieved from linPy_to_linC.
"""
if linPy in linPy_to_linC:
return
typ = get_type(linPy)
shape = cvxcore.IntVector()
lin_args_vec = cvxcore.ConstLinOpVector()
for dim in linPy.shape:
shape.push_back(int(dim))
for argPy in linPy.args:
lin_args_vec.push_back(linPy_to_linC[argPy])
linC = cvxcore.LinOp(typ, shape, lin_args_vec)
linPy_to_linC[linPy] = linC
if linPy.data is not None:
if isinstance(linPy.data, lo.LinOp):
linC_data = linPy_to_linC[linPy.data]
linC.set_linOp_data(linC_data)
linC.set_data_ndim(len(linPy.data.shape))
else:
set_linC_data(linC, linPy)
def get_problem_matrix(linOps, var_length, id_to_col, param_to_size,
param_to_col, constr_length):
"""
Builds a sparse representation of the problem data.
Parameters
----------
linOps: A list of python linOp trees representing an affine expression
var_length: The total length of the variables.
id_to_col: A map from variable id to column offset.
param_to_size: A map from parameter id to parameter size.
param_to_col: A map from parameter id to column in tensor.
constr_length: Summed sizes of constraints input.
Returns
-------
A sparse (CSC) matrix with constr_length * (var_length + 1) rows and
param_size + 1 columns (where param_size is the length of the
parameter vector).
"""
lin_vec = cvxcore.ConstLinOpVector()
id_to_col_C = cvxcore.IntIntMap()
for id, col in id_to_col.items():
id_to_col_C[int(id)] = int(col)
param_to_size_C = cvxcore.IntIntMap()
for id, size in param_to_size.items():
param_to_size_C[int(id)] = int(size)
# dict to memoize construction of C++ linOps, and to keep Python references
# to them to prevent their deletion
linPy_to_linC = {}
for lin in linOps:
build_lin_op_tree(lin, linPy_to_linC)
tree = linPy_to_linC[lin]
lin_vec.push_back(tree)
problemData = cvxcore.build_matrix(lin_vec, int(var_length), id_to_col_C,
param_to_size_C, s.get_num_threads())
# Populate tensors with info from problemData.
tensor_V = {}
tensor_I = {}
tensor_J = {}
for param_id, size in param_to_size.items():
tensor_V[param_id] = []
tensor_I[param_id] = []
tensor_J[param_id] = []
problemData.param_id = param_id
for i in range(size):
problemData.vec_idx = i
prob_len = problemData.getLen()
tensor_V[param_id].append(problemData.getV(prob_len))
tensor_I[param_id].append(problemData.getI(prob_len))
tensor_J[param_id].append(problemData.getJ(prob_len))
# Reduce tensors to a single sparse CSR matrix.
V = []
I = []
J = []
# one of the 'parameters' in param_to_col is a constant scalar offset,
# hence 'plus_one'
param_size_plus_one = 0
for param_id, col in param_to_col.items():
size = param_to_size[param_id]
param_size_plus_one += size
for i in range(size):
V.append(tensor_V[param_id][i])
I.append(tensor_I[param_id][i] +
tensor_J[param_id][i] * constr_length)
J.append(tensor_J[param_id][i] * 0 + (i + col))
V = np.concatenate(V)
I = np.concatenate(I)
J = np.concatenate(J)
A = scipy.sparse.csc_matrix(
(V, (I, J)),
shape=(np.int64(constr_length) * np.int64(var_length + 1),
param_size_plus_one))
return A