def test_dot(self):
mat1 = self.square_mpi_mat
mat2 = self.square_mpi_mat2
serial_mat1 = self.square_serial_mat
serial_mat2 = self.square_serial_mat2
rank = comm.Get_rank()
bv1 = MPIBlockVector(2, [0, 1], comm)
if rank == 0:
bv1.set_block(0, np.arange(4, dtype=np.float64))
if rank == 1:
bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
bv1.broadcast_block_sizes()
serial_bv1 = BlockVector(2)
serial_bv1.set_block(0, np.arange(4, dtype=np.float64))
serial_bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
res = mat1.dot(bv1)
serial_res = serial_mat1.dot(serial_bv1)
self.assertIsInstance(res, BlockVector)
self.assertEqual(res.nblocks, serial_res.nblocks)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
def test_flatten(self):
v = BlockVector(2)
a = np.arange(5)
b = np.arange(9)
c = np.concatenate([a, b])
v.set_block(0, a)
v.set_block(1, b)
self.assertListEqual(v.flatten().tolist(), c.tolist())
def test_fill(self):
v = BlockVector(2)
a = np.arange(5)
b = np.arange(9)
v.set_block(0, a)
v.set_block(1, b)
v.fill(1.0)
c = np.ones(v.size)
self.assertListEqual(v.tolist(), c.tolist())
def test_min(self):
self.assertEqual(self.ones.min(), 1)
v = BlockVector(2)
a = np.arange(5)
b = np.arange(9)
c = np.concatenate([a, b])
v.set_block(0, a)
v.set_block(1, b)
self.assertEqual(v.min(), c.min())
def test_cumsum(self):
v = BlockVector(3)
v.set_block(0, np.arange(1, 5))
v.set_block(1, np.arange(5, 10))
v.set_block(2, np.arange(10, 15))
c = np.arange(1, 15)
res = v.cumsum()
self.assertIsInstance(res, BlockVector)
self.assertEqual(v.nblocks, res.nblocks)
self.assertTrue(np.allclose(c.cumsum(), res.flatten()))
def test_std(self):
v = BlockVector(2)
a = np.arange(5)
b = np.arange(9)
v.set_block(0, a)
v.set_block(1, b)
vv = np.concatenate([a, b])
self.assertEqual(vv.std(), v.std())
def test_ptp(self):
v = BlockVector(2)
a = np.arange(5)
b = np.arange(9)
v.set_block(0, a)
v.set_block(1, b)
vv = np.arange(9)
self.assertEqual(vv.ptp(), v.ptp())
def test_nonzero(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
n = v.nonzero()
v2 = BlockVector(2)
v2.set_block(0, np.arange(5))
v2.set_block(1, np.zeros(0))
self.assertEqual(n[0].nblocks, v.nblocks)
for bid, blk in enumerate(n[0]):
self.assertTrue(np.allclose(blk, v2.get_block(bid)))
def test_itruediv(self):
v = self.ones
v /= 3
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) / 3))
v.fill(1.0)
v /= v
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size)))
v.fill(1.0)
v /= np.ones(v.size) * 2
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) / 2))
v = BlockVector(2)
a = np.ones(5)
b = np.arange(9, dtype=np.float64)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v /= 2.0
self.assertTrue(np.allclose(v.get_block(0), a_copy / 2.0))
self.assertTrue(np.allclose(v.get_block(1), b_copy / 2.0))
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v2 = BlockVector(2)
v2.set_block(0, np.ones(5) * 2)
v2.set_block(1, np.ones(9) * 2)
v /= v2
self.assertTrue(np.allclose(v.get_block(0), a_copy / 2))
self.assertTrue(np.allclose(v.get_block(1), b_copy / 2))
self.assertTrue(np.allclose(v2.get_block(0), np.ones(5) * 2))
self.assertTrue(np.allclose(v2.get_block(1), np.ones(9) * 2))
with self.assertRaises(Exception) as context:
v *= 'hola'
def test_imul(self):
v = self.ones
v *= 3
self.assertListEqual(v.tolist(), [3] * v.size)
v.fill(1.0)
v *= v
self.assertListEqual(v.tolist(), [1] * v.size)
v.fill(1.0)
v *= np.ones(v.size) * 2
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) * 2))
v = BlockVector(2)
a = np.ones(5)
b = np.arange(9, dtype=np.float64)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v *= 2.0
self.assertTrue(np.allclose(v.get_block(0), a_copy * 2.0))
self.assertTrue(np.allclose(v.get_block(1), b_copy * 2.0))
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v2 = BlockVector(2)
v2.set_block(0, np.ones(5) * 2)
v2.set_block(1, np.ones(9) * 2)
v *= v2
self.assertTrue(np.allclose(v.get_block(0), a_copy * 2))
self.assertTrue(np.allclose(v.get_block(1), b_copy * 2))
self.assertTrue(np.allclose(v2.get_block(0), np.ones(5) * 2))
self.assertTrue(np.allclose(v2.get_block(1), np.ones(9) * 2))
with self.assertRaises(Exception) as context:
v *= 'hola'
def test_dot(self):
A_dense = self.basic_m.toarray()
A_block = self.basic_m
x = np.ones(A_dense.shape[1])
block_x = BlockVector(2)
block_x.set_block(0, np.ones(self.block_m.shape[1]))
block_x.set_block(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)
m = BlockMatrix(2, 2)
sub_m = np.array([[1, 0], [0, 1]])
sub_m = coo_matrix(sub_m)
m.set_block(0, 1, sub_m.copy())
m.set_block(1, 0, sub_m.copy())
x = np.arange(4)
res = m * x
self.assertTrue(np.allclose(res.flatten(), np.array([2, 3, 0, 1])))
def test_mul(self):
mat1 = self.square_mpi_mat
mat2 = self.square_mpi_mat2
serial_mat1 = self.square_serial_mat
serial_mat2 = self.square_serial_mat2
rank = comm.Get_rank()
bv1 = MPIBlockVector(2, [0, 1], comm)
if rank == 0:
bv1.set_block(0, np.arange(4, dtype=np.float64))
if rank == 1:
bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
bv1.broadcast_block_sizes()
serial_bv1 = BlockVector(2)
serial_bv1.set_block(0, np.arange(4, dtype=np.float64))
serial_bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
res = mat1 * bv1
serial_res = serial_mat1 * serial_bv1
self.assertIsInstance(res, BlockVector)
self.assertEqual(res.nblocks, serial_res.nblocks)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
res = mat2 * bv1
serial_res = serial_mat2 * serial_bv1
self.assertIsInstance(res, BlockVector)
self.assertEqual(res.nblocks, serial_res.nblocks)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
bv1 = MPIBlockVector(2, [0, -1], comm)
if rank == 0:
bv1.set_block(0, np.arange(4, dtype=np.float64))
bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
bv1.broadcast_block_sizes()
res = mat1 * bv1
serial_res = serial_mat1 * serial_bv1
self.assertIsInstance(res, BlockVector)
self.assertEqual(res.nblocks, serial_res.nblocks)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
res = mat2 * bv1
serial_res = serial_mat2 * serial_bv1
self.assertIsInstance(res, BlockVector)
self.assertEqual(res.nblocks, serial_res.nblocks)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
# rectangular matrix
mat1 = self.rectangular_mpi_mat
serial_mat1 = self.rectangular_serial_mat
bv1 = MPIBlockVector(3, [0, 1, 2], comm)
if rank == 0:
bv1.set_block(0, np.arange(4, dtype=np.float64))
if rank == 1:
bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
if rank == 2:
bv1.set_block(2, np.arange(2, dtype=np.float64) + 8)
bv1.broadcast_block_sizes()
serial_bv1 = BlockVector(3)
serial_bv1.set_block(0, np.arange(4, dtype=np.float64))
serial_bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
serial_bv1.set_block(2, np.arange(2, dtype=np.float64) + 8)
# with warnings.catch_warnings():
# warnings.simplefilter("ignore")
res = mat1 * bv1
serial_res = serial_mat1 * serial_bv1
self.assertIsInstance(res, BlockVector)
self.assertEqual(serial_res.nblocks, 2)
self.assertEqual(res.nblocks, 2)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
bv1 = MPIBlockVector(3, [0, 1, 0], comm)
if rank == 0:
bv1.set_block(0, np.arange(4, dtype=np.float64))
bv1.set_block(2, np.arange(2, dtype=np.float64) + 8)
if rank == 1:
bv1.set_block(1, np.arange(4, dtype=np.float64) + 4)
bv1.broadcast_block_sizes()
res = mat1 * bv1
serial_res = serial_mat1 * serial_bv1
self.assertIsInstance(res, BlockVector)
self.assertEqual(res.nblocks, serial_res.nblocks)
for bid in range(serial_res.nblocks):
self.assertTrue(
np.allclose(res.get_block(bid), serial_res.get_block(bid)))
res = mat1 * 3.0
serial_res = serial_mat1 * 3.0
self.assertIsInstance(res, MPIBlockMatrix)
rows, columns = np.nonzero(res.ownership_mask)
for i, j in zip(rows, columns):
if res.get_block(i, j) is not None:
self.assertTrue(
np.allclose(
res.get_block(i, j).toarray(),
serial_res.get_block(i, j).toarray()))
else:
self.assertIsNone(serial_res.get_block(i, j))
res = 3.0 * mat1
serial_res = serial_mat1 * 3.0
self.assertIsInstance(res, MPIBlockMatrix)
rows, columns = np.nonzero(res.ownership_mask)
for i, j in zip(rows, columns):
if res.get_block(i, j) is not None:
self.assertTrue(
np.allclose(
res.get_block(i, j).toarray(),
serial_res.get_block(i, j).toarray()))
else:
self.assertIsNone(serial_res.get_block(i, j))
def test_sum(self):
self.assertEqual(self.ones.sum(), self.ones.size)
v = BlockVector(2)
v.set_block(0, np.arange(5))
v.set_block(1, np.arange(9))
self.assertEqual(v.sum(), 46)
