def setUp(self):
self.nbr_elements = 1000
self.size = 10000
self.non_contiguity = 10
self.A_c = LLSparseMatrix(size=self.size,
size_hint=self.nbr_elements,
itype=INT32_T,
dtype=FLOAT64_T)
self.A_s = lil_matrix((self.size, self.size), dtype=np.float64)
self.list_of_matrices = []
self.list_of_matrices.append(self.A_c)
self.list_of_matrices.append(self.A_s)
construct_random_matrices(self.list_of_matrices, self.size,
self.nbr_elements)
self.CSC_c = self.A_c.to_csc()
self.CSC_s = self.A_s.tocsc()
self.v = np.arange(0,
self.size * self.non_contiguity,
dtype=np.float64)
def construct_cysparse_matrix(n, nbr_elements):
# int is 32 bits on my machine
A = LLSparseMatrix(size=n, size_hint=nbr_elements, itype=INT32_T, dtype=FLOAT64_T)
for i in xrange(nbr_elements):
A[i % n, (2 * i + 1) % n] = i / 3
return A
def setUp(self):
self.nbr_elements = 10000
self.size = 100000
self.A_c = LLSparseMatrix(size=self.size, size_hint=self.nbr_elements, dtype=FLOAT64_T)
construct_sparse_matrix(self.A_c, self.size, self.nbr_elements)
self.A_p = spmatrix.ll_mat(self.size, self.size, self.nbr_elements)
construct_sparse_matrix(self.A_p, self.size, self.nbr_elements)
def jac(self, *args, **kwargs):
"""Evaluate constraints Jacobian at x."""
vals, rows, cols = super(CySparseNLPModel, self).jac(*args, **kwargs)
J = LLSparseMatrix(nrow=self.ncon,
ncol=self.nvar,
size_hint=vals.size,
store_symmetric=False,
itype=types.INT64_T,
dtype=types.FLOAT64_T)
J.put_triplet(rows, cols, vals)
return J
def setUp(self):
self.nbr_elements = 100000
self.size = 1000000
self.A_c = LLSparseMatrix(size=self.size,
size_hint=self.nbr_elements,
dtype=FLOAT64_T)
self.A_p = spmatrix.ll_mat(self.size, self.size, self.nbr_elements)
self.A_s = lil_matrix(
(self.size, self.size),
dtype=np.float64) # how do we reserve space in advance?
def setUp(self):
self.nbr_elements = 80000
self.size = 100000
self.A_c = LLSparseMatrix(size=self.size,
size_hint=self.nbr_elements,
dtype=FLOAT64_T,
store_symmetric=True)
construct_sym_sparse_matrix(self.A_c, self.size, self.nbr_elements)
self.A_p = spmatrix.ll_mat_sym(self.size, self.size, self.nbr_elements)
construct_sym_sparse_matrix(self.A_p, self.size, self.nbr_elements)
def hess(self, *args, **kwargs):
"""Evaluate Lagrangian Hessian at (x, z).
Note that `rows`, `cols` and `vals` must represent a LOWER triangular
sparse matrix in the coordinate format (COO).
"""
vals, rows, cols = super(CySparseNLPModel, self).hess(*args, **kwargs)
H = LLSparseMatrix(size=self.nvar,
size_hint=vals.size,
store_symmetric=True,
itype=types.INT64_T,
dtype=types.FLOAT64_T)
H.put_triplet(rows, cols, vals)
return H
def setUp(self):
self.nbr_elements = 1000
self.size = 10000
self.A_c = LLSparseMatrix(size=self.size, size_hint=self.nbr_elements, dtype=FLOAT64_T)
construct_sparse_matrix(self.A_c, self.size, self.nbr_elements)
self.A_p = spmatrix.ll_mat(self.size, self.size, self.nbr_elements)
construct_sparse_matrix(self.A_p, self.size, self.nbr_elements)
self.stride = 10
self.v = np.arange(0, self.size * self.stride, dtype=np.float64)
def _jac(self, x, lp=False):
"""Helper method to assemble the Jacobian matrix.
See the documentation of :meth:`jac` for more information.
The positional argument `lp` should be set to `True` only if the
problem is known to be a linear program. In this case, the evaluation
of the constraint matrix is cheaper and the argument `x` is ignored.
"""
m = self.m
model = self.model
on = self.original_n
lowerC = np.array(model.lowerC, dtype=np.int64)
nlowerC = model.nlowerC
upperC = np.array(model.upperC, dtype=np.int64)
nupperC = model.nupperC
rangeC = np.array(model.rangeC, dtype=np.int64)
nrangeC = model.nrangeC
# Initialize sparse Jacobian
nnzJ = self.model.nnzj + m
J = LLSparseMatrix(nrow=self.ncon,
ncol=self.nvar,
size_hint=nnzJ,
store_symmetric=False,
itype=types.INT64_T,
dtype=types.FLOAT64_T)
# Insert contribution of general constraints
if lp:
J[:on, :on] = self.model.A()
else:
J[:on, :on] = self.model.jac(x[:on])
# Create a few index lists
rlowerC = np.array(range(nlowerC), dtype=np.int64)
rupperC = np.array(range(nupperC), dtype=np.int64)
rrangeC = np.array(range(nrangeC), dtype=np.int64)
# Insert contribution of slacks on general constraints
J.put_triplet(lowerC, on + rlowerC,
-1.0 * np.ones(nlowerC, dtype=np.float64))
J.put_triplet(upperC, on + nlowerC + rupperC,
-1.0 * np.ones(nupperC, dtype=np.float64))
J.put_triplet(rangeC, on + nlowerC + nupperC + rrangeC,
-1.0 * np.ones(nrangeC, dtype=np.float64))
return J
def A(self, *args, **kwargs):
"""
Evaluate sparse Jacobian of the linear part of the
constraints. Useful to obtain constraint matrix
when problem is a linear programming problem.
"""
vals, rows, cols = super(CySparseAmplModel,
self).A(*args, **kwargs)
A = LLSparseMatrix(nrow=self.ncon,
ncol=self.nvar,
size_hint=vals.size,
store_symmetric=False,
type=types.INT64_T,
dtype=types.FLOAT64_T)
A.put_triplet(rows, cols, vals)
return A
def setUp(self):
self.nbr_elements = 5000
self.size = 1000000
self.A_c = LLSparseMatrix(size=self.size, size_hint=self.nbr_elements, itype=INT32_T, dtype=FLOAT64_T)
self.A_p = spmatrix.ll_mat(self.size, self.size, self.nbr_elements)
self.A_s = lil_matrix((self.size, self.size), dtype=np.float64)
self.list_of_matrices = []
self.list_of_matrices.append(self.A_c)
self.list_of_matrices.append(self.A_p)
self.list_of_matrices.append(self.A_s)
construct_random_matrices(self.list_of_matrices, self.size, self.nbr_elements)
self.v = np.arange(0, self.size, dtype=np.float64)
def hess(self, x, z=None, *args, **kwargs):
"""Evaluate Lagrangian Hessian at (x, z)."""
model = self.model
if isinstance(model, QuasiNewtonModel):
return self.hop(x, z, *args, **kwargs)
if z is None:
z = np.zeros(self.m)
on = model.n
H = LLSparseMatrix(size=self.nvar,
size_hint=self.model.nnzh,
store_symmetric=True,
itype=types.INT64_T,
dtype=types.FLOAT64_T)
H[:on, :on] = self.model.hess(x[:on], z, *args, **kwargs)
return H
def setUp(self):
self.nbr_elements = 1000
self.size = 10000
self.put_size = 10000
assert self.put_size <= self.size
self.A_c = LLSparseMatrix(size=self.size,
size_hint=self.nbr_elements,
itype=INT32_T,
dtype=FLOAT64_T)
construct_sparse_matrix(self.A_c, self.size, self.nbr_elements)
self.A_p = spmatrix.ll_mat(self.size, self.size, self.nbr_elements)
construct_sparse_matrix(self.A_p, self.size, self.nbr_elements)
self.id1 = np.arange(0, self.put_size, dtype=np.int32)
self.id2 = np.full(self.put_size, 37, dtype=np.int32)
self.b = np.arange(0, self.put_size, dtype=np.float64)
def setUp(self):
self.nbr_elements = 1000
self.size = 10000
self.nbr_elements_to_add = 1000
assert self.nbr_elements_to_add < self.size
self.A_c = LLSparseMatrix(size=self.size,
size_hint=self.nbr_elements,
itype=INT32_T,
dtype=FLOAT64_T)
construct_sparse_matrix(self.A_c, self.size, self.nbr_elements)
self.A_p = spmatrix.ll_mat(self.size, self.size, self.nbr_elements)
construct_sparse_matrix(self.A_p, self.size, self.nbr_elements)
self.id1 = np.ones(self.nbr_elements_to_add, dtype=np.int32)
self.id2 = self.v = np.arange(0,
self.nbr_elements_to_add,
dtype=np.int32)
self.val = np.empty(self.nbr_elements_to_add, dtype=np.float64)