class TestBlockMatrix(unittest.TestCase):
def setUp(self):
row = np.array([0, 3, 1, 2, 3, 0])
col = np.array([0, 0, 1, 2, 3, 3])
data = np.array([2, 1, 3, 4, 5, 1])
m = coo_matrix((data, (row, col)), shape=(4, 4))
self.block_m = m
bm = BlockMatrix(2, 2)
bm.name = 'basic_matrix'
bm[0, 0] = m
bm[1, 1] = m
bm[0, 1] = m
self.basic_m = bm
self.composed_m = BlockMatrix(2, 2)
self.composed_m[0, 0] = self.block_m
self.composed_m[1, 1] = self.basic_m
def test_name(self):
self.assertEqual(self.basic_m.name, 'basic_matrix')
self.basic_m.name = 'hola'
self.assertEqual(self.basic_m.name, 'hola')
def test_bshape(self):
self.assertEqual(self.basic_m.bshape, (2, 2))
def test_shape(self):
shape = (self.block_m.shape[0]*2, self.block_m.shape[1]*2)
self.assertEqual(self.basic_m.shape, shape)
def test_tocoo(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='coo')
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
srow = np.sort(scipy_mat.row)
scol = np.sort(scipy_mat.col)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_tocsr(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='csr')
dinopy_mat = m.tocsr()
dindices = np.sort(dinopy_mat.indices)
dindptr = np.sort(dinopy_mat.indptr)
ddata = np.sort(dinopy_mat.data)
sindices = np.sort(scipy_mat.indices)
sindptr = np.sort(scipy_mat.indptr)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(dindices.tolist(), sindices.tolist())
self.assertListEqual(dindptr.tolist(), sindptr.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_tocsc(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='csc')
dinopy_mat = m.tocsc()
dindices = np.sort(dinopy_mat.indices)
dindptr = np.sort(dinopy_mat.indptr)
ddata = np.sort(dinopy_mat.data)
sindices = np.sort(scipy_mat.indices)
sindptr = np.sort(scipy_mat.indptr)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(dindices.tolist(), sindices.tolist())
self.assertListEqual(dindptr.tolist(), sindptr.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_multiply(self):
# check scalar multiplication
block = self.block_m
m = self.basic_m * 5.0
scipy_mat = bmat([[block, block], [None, block]], format='coo')
mulscipy_mat = scipy_mat * 5.0
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
srow = np.sort(mulscipy_mat.row)
scol = np.sort(mulscipy_mat.col)
sdata = np.sort(mulscipy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
m = 5.0 * self.basic_m
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
# check dot product with block vector
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='coo')
x = BlockVector(2)
x[0] = np.ones(block.shape[1], dtype=np.float64)
x[1] = np.ones(block.shape[1], dtype=np.float64)
res_scipy = scipy_mat.dot(x.flatten())
res_dinopy = m * x
res_dinopy_flat = m * x.flatten()
self.assertListEqual(res_dinopy.tolist(), res_scipy.tolist())
self.assertListEqual(res_dinopy_flat.tolist(), res_scipy.tolist())
dense_mat = dinopy_mat.todense()
self.basic_m *= 5.0
self.assertTrue(np.allclose(dense_mat, self.basic_m.todense()))
flat_mat = self.basic_m.tocoo()
result = flat_mat * flat_mat
dense_result = result.toarray()
mat = self.basic_m * self.basic_m.tocoo()
dense_mat = mat.toarray()
self.assertTrue(np.allclose(dense_mat, dense_result))
# not supported block matrix times block matrix for now
#with self.assertRaises(Exception) as context:
# mat = self.basic_m * self.basic_m.tocoo()
def test_getitem(self):
m = BlockMatrix(3, 3)
for i in range(3):
for j in range(3):
self.assertIsNone(m[i, j])
m[0, 1] = self.block_m
self.assertEqual(m[0, 1].shape, self.block_m.shape)
def test_setitem(self):
m = BlockMatrix(2, 2)
m[0, 1] = self.block_m
self.assertFalse(m.is_empty_block(0, 1))
self.assertEqual(m.row_block_sizes()[0], self.block_m.shape[0])
self.assertEqual(m.col_block_sizes()[1], self.block_m.shape[1])
self.assertEqual(m[0, 1].shape, self.block_m.shape)
def test_coo_data(self):
m = self.basic_m.tocoo()
data = self.basic_m.coo_data()
self.assertListEqual(m.data.tolist(), data.tolist())
# ToDo: add tests for block matrices with block matrices in it
# ToDo: add tests for matrices with zeros in the diagonal
# ToDo: add tests for block matrices with coo and csc matrices
def test_nnz(self):
self.assertEqual(self.block_m.nnz*3, self.basic_m.nnz)
def test_block_shapes(self):
shapes = self.basic_m.block_shapes()
for i in range(self.basic_m.bshape[0]):
for j in range(self.basic_m.bshape[1]):
self.assertEqual(shapes[i][j], self.block_m.shape)
def test_dot(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
x = np.ones(A_dense.shape[1])
block_x = BlockVector(2)
block_x[0] = np.ones(self.block_m.shape[1])
block_x[1] = np.ones(self.block_m.shape[1])
flat_res = A_block.dot(x).flatten()
block_res = A_block.dot(block_x)
self.assertTrue(np.allclose(A_dense.dot(x), flat_res))
self.assertTrue(np.allclose(A_dense.dot(x), block_res.flatten()))
self.assertEqual(block_res.bshape[0], 2)
def test_reset_brow(self):
self.basic_m.reset_brow(0)
for j in range(self.basic_m.bshape[1]):
self.assertIsNone(self.basic_m[0, j])
def test_reset_bcol(self):
self.basic_m.reset_bcol(0)
for j in range(self.basic_m.bshape[0]):
self.assertIsNone(self.basic_m[j, 0])
def test_to_scipy(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='coo')
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
srow = np.sort(scipy_mat.row)
scol = np.sort(scipy_mat.col)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_has_empty_rows(self):
self.assertFalse(self.basic_m.has_empty_rows())
def test_has_empty_cols(self):
self.assertFalse(self.basic_m.has_empty_cols())
def test_transpose(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
A_dense_t = A_dense.transpose()
A_block_t = A_block.transpose()
self.assertTrue(np.allclose(A_dense_t, A_block_t.todense()))
A_dense = self.composed_m.todense()
A_block = self.composed_m
A_dense_t = A_dense.transpose()
A_block_t = A_block.transpose()
self.assertTrue(np.allclose(A_dense_t, A_block_t.todense()))
def test_repr(self):
self.assertEqual(len(self.basic_m.__repr__()), 17)
#def test_str(self):
# self.assertEqual(len(self.basic_m.__str__()), 328)
def test_set_item(self):
self.basic_m[1, 0] = None
self.assertIsNone(self.basic_m[1, 0])
self.basic_m[1, 1] = None
self.assertIsNone(self.basic_m[1, 1])
self.assertEqual(self.basic_m._brow_lengths[1], 0)
self.basic_m[1, 1] = self.block_m
self.assertEqual(self.basic_m._brow_lengths[1], self.block_m.shape[1])
def test_add(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
aa = A_dense + A_dense
mm = A_block + A_block
self.assertTrue(np.allclose(aa, mm.todense()))
mm = A_block.__radd__(A_block)
self.assertTrue(np.allclose(aa, mm.todense()))
def test_sub(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
aa = A_dense - A_dense
mm = A_block - A_block
self.assertTrue(np.allclose(aa, mm.todense()))
mm = A_block.__rsub__(A_block)
self.assertTrue(np.allclose(aa, mm.todense()))
class TestBlockMatrix(unittest.TestCase):
def setUp(self):
row = np.array([0, 3, 1, 2, 3, 0])
col = np.array([0, 0, 1, 2, 3, 3])
data = np.array([2, 1, 3, 4, 5, 1])
m = COOMatrix((data, (row, col)), shape=(4, 4))
self.block_m = m
bm = BlockMatrix(2, 2)
bm.name = 'basic_matrix'
bm[0, 0] = m
bm[1, 1] = m
bm[0, 1] = m
self.basic_m = bm
self.composed_m = BlockMatrix(2, 2)
self.composed_m[0, 0] = self.block_m
self.composed_m[1, 1] = self.basic_m
def test_is_symmetric(self):
self.assertFalse(self.basic_m.is_symmetric)
def test_name(self):
self.assertEqual(self.basic_m.name, 'basic_matrix')
self.basic_m.name = 'hola'
self.assertEqual(self.basic_m.name, 'hola')
def test_bshape(self):
self.assertEqual(self.basic_m.bshape, (2, 2))
def test_shape(self):
shape = (self.block_m.shape[0] * 2, self.block_m.shape[1] * 2)
self.assertEqual(self.basic_m.shape, shape)
def test_tocoo(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='coo')
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
srow = np.sort(scipy_mat.row)
scol = np.sort(scipy_mat.col)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_tocsr(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='csr')
dinopy_mat = m.tocsr()
dindices = np.sort(dinopy_mat.indices)
dindptr = np.sort(dinopy_mat.indptr)
ddata = np.sort(dinopy_mat.data)
sindices = np.sort(scipy_mat.indices)
sindptr = np.sort(scipy_mat.indptr)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(dindices.tolist(), sindices.tolist())
self.assertListEqual(dindptr.tolist(), sindptr.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_tocsc(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='csc')
dinopy_mat = m.tocsc()
dindices = np.sort(dinopy_mat.indices)
dindptr = np.sort(dinopy_mat.indptr)
ddata = np.sort(dinopy_mat.data)
sindices = np.sort(scipy_mat.indices)
sindptr = np.sort(scipy_mat.indptr)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(dindices.tolist(), sindices.tolist())
self.assertListEqual(dindptr.tolist(), sindptr.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_multiply(self):
# check scalar multiplication
block = self.block_m
m = self.basic_m * 5.0
scipy_mat = bmat([[block, block], [None, block]], format='coo')
mulscipy_mat = scipy_mat * 5.0
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
srow = np.sort(mulscipy_mat.row)
scol = np.sort(mulscipy_mat.col)
sdata = np.sort(mulscipy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
m = 5.0 * self.basic_m
dinopy_mat = m.tocoo()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
# check dot product with block vector
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='coo')
x = BlockVector(2)
x[0] = np.ones(block.shape[1], dtype=np.float64)
x[1] = np.ones(block.shape[1], dtype=np.float64)
res_scipy = scipy_mat.dot(x.flatten())
res_dinopy = m * x
res_dinopy_flat = m * x.flatten()
self.assertListEqual(res_dinopy.tolist(), res_scipy.tolist())
self.assertListEqual(res_dinopy_flat.tolist(), res_scipy.tolist())
def test_getitem(self):
m = BlockMatrix(3, 3)
for i in range(3):
for j in range(3):
self.assertIsNone(m[i, j])
m[0, 1] = self.block_m
self.assertIsInstance(m[0, 1], SparseBase)
self.assertEqual(m[0, 1].shape, self.block_m.shape)
def test_setitem(self):
m = BlockMatrix(2, 2)
m[0, 1] = self.block_m
self.assertFalse(m.is_empty_block(0, 1))
self.assertEqual(m.row_block_sizes()[0], self.block_m.shape[0])
self.assertEqual(m.col_block_sizes()[1], self.block_m.shape[1])
self.assertIsInstance(m[0, 1], SparseBase)
self.assertEqual(m[0, 1].shape, self.block_m.shape)
def test_coo_data(self):
m = self.basic_m.tocoo()
data = self.basic_m.coo_data()
self.assertListEqual(m.data.tolist(), data.tolist())
# ToDo: add tests for block matrices with block matrices in it
# ToDo: add tests for matrices with zeros in the diagonal
# ToDo: add tests for getallnnz
# ToDo: add tests for block matrices with coo and csc matrices
def test_nnz(self):
self.assertEqual(self.block_m.nnz * 3, self.basic_m.nnz)
def test_block_shapes(self):
shapes = self.basic_m.block_shapes()
for i in range(self.basic_m.bshape[0]):
for j in range(self.basic_m.bshape[1]):
self.assertEqual(shapes[i][j], self.block_m.shape)
def test_dot(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
x = np.ones(A_dense.shape[1])
block_x = BlockVector(2)
block_x[0] = np.ones(self.block_m.shape[1])
block_x[1] = np.ones(self.block_m.shape[1])
flat_res = A_block.dot(x).flatten()
block_res = A_block.dot(block_x)
self.assertTrue(np.allclose(A_dense.dot(x), flat_res))
self.assertTrue(np.allclose(A_dense.dot(x), block_res.flatten()))
self.assertEqual(block_res.bshape[0], 2)
def test_reset_brow(self):
self.basic_m.reset_brow(0)
for j in range(self.basic_m.bshape[1]):
self.assertIsNone(self.basic_m[0, j])
def test_reset_bcol(self):
self.basic_m.reset_bcol(0)
for j in range(self.basic_m.bshape[0]):
self.assertIsNone(self.basic_m[j, 0])
def test_getallnnz(self):
self.assertEqual(self.block_m.nnz * 3, self.basic_m.getallnnz())
self.assertEqual(self.block_m.nnz * 4, self.composed_m.getallnnz())
def test_to_scipy(self):
block = self.block_m
m = self.basic_m
scipy_mat = bmat([[block, block], [None, block]], format='coo')
dinopy_mat = m.toscipy()
drow = np.sort(dinopy_mat.row)
dcol = np.sort(dinopy_mat.col)
ddata = np.sort(dinopy_mat.data)
srow = np.sort(scipy_mat.row)
scol = np.sort(scipy_mat.col)
sdata = np.sort(scipy_mat.data)
self.assertListEqual(drow.tolist(), srow.tolist())
self.assertListEqual(dcol.tolist(), scol.tolist())
self.assertListEqual(ddata.tolist(), sdata.tolist())
def test_has_empty_rows(self):
self.assertFalse(self.basic_m.has_empty_rows())
def test_has_empty_cols(self):
self.assertFalse(self.basic_m.has_empty_cols())
def test_transpose(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
A_dense_t = A_dense.transpose()
A_block_t = A_block.transpose()
self.assertTrue(np.allclose(A_dense_t, A_block_t.todense()))
A_dense = self.composed_m.todense()
A_block = self.composed_m
A_dense_t = A_dense.transpose()
A_block_t = A_block.transpose()
self.assertTrue(np.allclose(A_dense_t, A_block_t.todense()))
def test_repr(self):
self.assertEqual(len(self.basic_m.__repr__()), 17)
def test_str(self):
self.assertEqual(len(self.basic_m.__str__()), 85)
def test_set_item(self):
self.basic_m[1, 0] = None
self.assertIsNone(self.basic_m[1, 0])
self.basic_m[1, 1] = None
self.assertIsNone(self.basic_m[1, 1])
self.assertEqual(self.basic_m._brow_lengths[1], 0)
self.basic_m[1, 1] = self.block_m
self.assertEqual(self.basic_m._brow_lengths[1], self.block_m.shape[1])
def test_add(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
aa = A_dense + A_dense
mm = A_block + A_block
self.assertTrue(np.allclose(aa, mm.todense()))
mm = A_block.__radd__(A_block)
self.assertTrue(np.allclose(aa, mm.todense()))
def test_sub(self):
A_dense = self.basic_m.todense()
A_block = self.basic_m
aa = A_dense - A_dense
mm = A_block - A_block
self.assertTrue(np.allclose(aa, mm.todense()))
mm = A_block.__rsub__(A_block)
self.assertTrue(np.allclose(aa, mm.todense()))
def test_jacobian_c(self):
nz = len(self.complicated_vars_ids)
nxi = nz + self.G.shape[1]
ngi = nz + self.A.shape[0]
Ji = BlockMatrix(2, 2)
Ji[0, 0] = COOMatrix(self.A)
B1 = np.zeros((nz, self.A.shape[1]))
B2 = np.zeros((nz, nz))
for i, v in enumerate(self.complicated_vars_ids):
B1[i, v] = -1.0
B2[i, i] = 1.0
Ji[1, 0] = COOMatrix(B1)
Ji[1, 1] = COOMatrix(B2)
dense_Ji = Ji.todense()
x = self.nlp.create_vector_x()
jac_c = self.nlp.jacobian_c(x)
total_nx = nxi * self.n_scenarios + nz
total_nc = (ngi + nz) * self.n_scenarios
self.assertEqual(jac_c.shape, (total_nc, total_nx))
# check block jacobians
for i in range(self.n_scenarios):
jac_ci = jac_c[i, i].todense()
self.assertTrue(np.allclose(jac_ci, dense_Ji))
# check coupling jacobians
Ai_ = BlockMatrix(1, 2)
Ai_[0, 1] = IdentityMatrix(nz)
Ai_[0, 0] = EmptyMatrix(nz, self.G.shape[1])
Ai_ = Ai_.todense()
Bi_ = -IdentityMatrix(nz).todense()
for i in range(self.n_scenarios):
Ai = jac_c[self.n_scenarios + i, i]
self.assertTrue(np.allclose(Ai.todense(), Ai_))
Bi = jac_c[self.n_scenarios + i, self.n_scenarios]
self.assertTrue(np.allclose(Bi.todense(), Bi_))
# test flattened vector
jac_g = self.nlp.jacobian_c(x.flatten())
total_nx = nxi * self.n_scenarios + nz
total_nc = (ngi + nz) * self.n_scenarios
self.assertEqual(jac_c.shape, (total_nc, total_nx))
# check block jacobians
for i in range(self.n_scenarios):
jac_ci = jac_c[i, i].todense()
self.assertTrue(np.allclose(jac_ci, dense_Ji))
# check coupling jacobians
Ai_ = BlockMatrix(1, 2)
Ai_[0, 1] = IdentityMatrix(nz)
Ai_[0, 0] = EmptyMatrix(nz, self.G.shape[1])
Ai_ = Ai_.todense()
Bi_ = -IdentityMatrix(nz).todense()
for i in range(self.n_scenarios):
Ai = jac_c[self.n_scenarios + i, i]
self.assertTrue(np.allclose(Ai.todense(), Ai_))
Bi = jac_c[self.n_scenarios + i, self.n_scenarios]
self.assertTrue(np.allclose(Bi.todense(), Bi_))
