def test_sub(self):
A_dense = self.basic_m.toarray()
A_block = self.basic_m
A_block2 = 2 * self.basic_m
aa = A_dense - A_dense
mm = A_block - A_block
self.assertTrue(np.allclose(aa, mm.toarray()))
mm = A_block2 - A_block.tocoo()
self.assertTrue(np.allclose(A_block.toarray(), mm.toarray()))
mm = A_block2.tocoo() - A_block
self.assertTrue(np.allclose(A_block.toarray(), mm.toarray()))
mm = A_block2.T - A_block.tocoo()
dense_r = A_block2.toarray().T - A_block.toarray()
self.assertTrue(np.allclose(dense_r, mm.toarray()))
with self.assertRaises(Exception) as context:
mm = A_block - A_block.toarray()
with self.assertRaises(Exception) as context:
mm = A_block - 1.0
with self.assertRaises(Exception) as context:
mm = 1.0 - A_block
def test_reset_bcol(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))
rank = comm.Get_rank()
# create mpi matrix
rank_ownership = [[0, -1], [-1, 1]]
bm = MPIBlockMatrix(2, 2, rank_ownership, comm)
if rank == 0:
bm.set_block(0, 0, m)
if rank == 1:
bm.set_block(1, 1, m)
bm.broadcast_block_sizes()
serial_bm = BlockMatrix(2, 2)
serial_bm.set_block(0, 0, m)
serial_bm.set_block(1, 1, m)
self.assertTrue(
np.allclose(serial_bm.row_block_sizes(), bm.row_block_sizes()))
bm.reset_bcol(0)
serial_bm.reset_bcol(0)
self.assertTrue(
np.allclose(serial_bm.col_block_sizes(), bm.col_block_sizes()))
bm.reset_bcol(1)
serial_bm.reset_bcol(1)
self.assertTrue(
np.allclose(serial_bm.col_block_sizes(), bm.col_block_sizes()))
def test_create_vector_y(self):
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_y(),
self.nlp.create_vector_y()))
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_y(subset='c'),
self.nlp.create_vector_y(subset='c')))
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_y(subset='d'),
self.nlp.create_vector_y(subset='d')))
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_y(subset='dl'),
self.nlp.create_vector_y(subset='dl')))
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_y(subset='du'),
self.nlp.create_vector_y(subset='du')))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_y(),
self.nlp3.create_vector_y()))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_y(subset='c'),
self.nlp3.create_vector_y(subset='c')))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_y(subset='d'),
self.nlp3.create_vector_y(subset='d')))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_y(subset='dl'),
self.nlp3.create_vector_y(subset='dl')))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_y(subset='du'),
self.nlp3.create_vector_y(subset='du')))
def test_add(self):
mat1 = self.square_mpi_mat
mat2 = self.square_mpi_mat2
serial_mat1 = self.square_serial_mat
serial_mat2 = self.square_serial_mat2
res = mat1 + mat2
serial_res = serial_mat1 + serial_mat2
self.assertTrue(np.allclose(mat1.rank_ownership, res.rank_ownership))
self._compare_mpi_and_serial_block_matrices(res, serial_res)
res = mat1 + serial_mat2
self.assertTrue(np.allclose(mat1.rank_ownership, res.rank_ownership))
self._compare_mpi_and_serial_block_matrices(res, serial_res)
res = serial_mat2 + mat1
self.assertTrue(np.allclose(mat1.rank_ownership, res.rank_ownership))
self._compare_mpi_and_serial_block_matrices(res, serial_res)
with self.assertRaises(Exception) as context:
res = mat1 + serial_mat2.tocoo()
with self.assertRaises(Exception) as context:
res = serial_mat2.tocoo() + mat1
def test_jacobian_d(self):
nlp = self.nlp
x = nlp.create_vector_x()
self.assertEqual(nlp.jacobian_d(x).shape, (0, 3))
x = self.nlp3.create_vector_x()
x.fill(1.0)
jac = self.nlp3.jacobian_d(x)
self.assertEqual(3, jac.shape[1])
self.assertEqual(3, jac.shape[0])
values = np.ones(7)
self.assertTrue(np.allclose(values, jac.data))
new_jac = self.nlp3.jacobian_d(x)
new_jac.data.fill(0.0)
self.nlp3.jacobian_d(x, out=new_jac)
self.assertTrue(np.allclose(values, new_jac.data))
jac_g = self.nlp3.jacobian_g(x)
new_jac = self.nlp3.jacobian_d(x, evaluated_jac_g=jac_g)
self.assertTrue(np.allclose(values, new_jac.data))
new_jac = self.nlp3.jacobian_d(x)
new_jac.data.fill(0.0)
self.nlp3.jacobian_d(x, out=new_jac, evaluated_jac_g=jac_g)
self.assertTrue(np.allclose(values, new_jac.data))
def test_eval_g(self):
x = np.ones(self.nlp3.nx)
res = np.array([-1.0, -0.5, 2, 2, 3])
self.assertTrue(np.allclose(self.nlp3.evaluate_g(x), res))
res_ = self.nlp3.create_vector_y()
self.nlp3.evaluate_g(x, out=res_)
self.assertTrue(np.allclose(res_, res))
def test_isin(self):
bv = self.bv
test_bv = BlockVector(2)
a = np.array([1.1, 3.3])
b = np.array([5.5, 7.7])
test_bv.set_block(0, a)
test_bv.set_block(1, b)
res = pn.isin(bv, test_bv)
for bid, blk in enumerate(bv):
self.assertEqual(blk.size, res.get_block(bid).size)
res_flat = np.isin(blk, test_bv.get_block(bid))
self.assertTrue(np.allclose(res.get_block(bid), res_flat))
c = np.concatenate([a, b])
res = pn.isin(bv, c)
for bid, blk in enumerate(bv):
self.assertEqual(blk.size, res.get_block(bid).size)
res_flat = np.isin(blk, c)
self.assertTrue(np.allclose(res.get_block(bid), res_flat))
res = pn.isin(bv, test_bv, invert=True)
for bid, blk in enumerate(bv):
self.assertEqual(blk.size, res.get_block(bid).size)
res_flat = np.isin(blk, test_bv.get_block(bid), invert=True)
self.assertTrue(np.allclose(res.get_block(bid), res_flat))
c = np.concatenate([a, b])
res = pn.isin(bv, c, invert=True)
for bid, blk in enumerate(bv):
self.assertEqual(blk.size, res.get_block(bid).size)
res_flat = np.isin(blk, c, invert=True)
self.assertTrue(np.allclose(res.get_block(bid), res_flat))
def test_jacobian_c(self):
nlp = self.nlp
jac_c = self.model.jacobian_c
x = nlp.create_vector_x()
self.assertTrue(np.allclose(nlp.jacobian_c(x).todense(), jac_c))
x = self.nlp3.create_vector_x()
x.fill(1.0)
jac = self.nlp3.jacobian_c(x)
self.assertEqual(3, jac.shape[1])
self.assertEqual(2, jac.shape[0])
values = np.array([2.0, 1.0, -1.0, -1.0])
self.assertTrue(np.allclose(values, jac.data))
new_jac = self.nlp3.jacobian_c(x)
new_jac.data.fill(0.0)
self.nlp3.jacobian_c(x, out=new_jac)
self.assertTrue(np.allclose(values, new_jac.data))
jac_g = self.nlp3.jacobian_g(x)
new_jac = self.nlp3.jacobian_c(x, evaluated_jac_g=jac_g)
self.assertTrue(np.allclose(values, new_jac.data))
new_jac = self.nlp3.jacobian_c(x)
new_jac.data.fill(0.0)
self.nlp3.jacobian_c(x, out=new_jac, evaluated_jac_g=jac_g)
self.assertTrue(np.allclose(values, new_jac.data))
def test_x_init(self):
x_init = np.array(range(1, 4))
self.assertTrue(np.allclose(self.nlp3.x_init(), x_init))
self.assertTrue(np.allclose(self.nlp.x_init(),
self.pyomo_nlp.x_init()))
self.assertTrue(
np.allclose(self.nlp2.x_init(), self.pyomo_nlp2.x_init()))
def test_y_init(self):
y_init = np.zeros(self.nlp3.ng)
self.assertTrue(np.allclose(self.nlp3.y_init(), y_init))
self.assertTrue(
np.allclose(self.nlp2.y_init(), self.pyomo_nlp2.y_init()))
self.assertTrue(
np.allclose(self.nlp3.y_init(), self.pyomo_nlp3.y_init()))
def test_ge(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
flags = v >= 0
v.set_block(1, b + 1)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
v.set_block(1, b - 1)
flags = v >= np.zeros(v.size)
v.set_block(1, b)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
v.set_block(1, b - 1)
vv = v.copy()
vv.fill(0.0)
flags = v >= vv
v.set_block(1, b)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
def test_compress(self):
v = self.ones
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
c = v.compress(v < 1)
v2 = BlockVector(2)
b = np.zeros(9)
v2.set_block(0, np.ones(0))
v2.set_block(1, b)
self.assertEqual(c.nblocks, v.nblocks)
for bid, blk in enumerate(c):
self.assertTrue(np.allclose(blk, v2.get_block(bid)))
flags = v < 1
c = v.compress(flags.flatten())
self.assertEqual(c.nblocks, v.nblocks)
for bid, blk in enumerate(c):
self.assertTrue(np.allclose(blk, v2.get_block(bid)))
with self.assertRaises(Exception) as context:
v.compress(1.0)
def test_ge(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
A_flat = self.basic_m.tocoo()
A_block = self.basic_m
A_bool_flat = A_flat >= 2.0
A_bool_block = A_block >= 2.0
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
A_bool_flat = 2.0 <= A_flat
A_bool_block = 2.0 <= A_block
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
A_bool_flat = A_flat >= A_flat
A_bool_block = A_block >= A_block
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
A_bool_flat = A_flat >= 0.5 * A_flat
A_bool_block = A_block >= 0.5 * A_block
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
def test_lt(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
A_flat = self.basic_m.tocoo()
A_block = self.basic_m
A_bool_flat = A_flat < 2.0
A_bool_block = A_block < 2.0
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
# A_bool_flat = 2.0 <= A_flat
# A_bool_block = 2.0 <= A_block
# self.assertTrue(np.allclose(A_bool_flat.toarray(),
# A_bool_block.toarray()))
A_bool_flat = A_flat < A_flat
A_bool_block = A_block < A_block
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
A_bool_flat = A_flat < 2 * A_flat
A_bool_block = A_block < 2 * A_block
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
A_bool_flat = 2.0 > A_flat
A_bool_block = 2.0 > A_block
self.assertTrue(
np.allclose(A_bool_flat.toarray(), A_bool_block.toarray()))
def test_le(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
flags = v <= 1
v.set_block(1, b + 1)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
flags = v <= v
vv = v.copy()
vv.fill(1.0)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, vv.get_block(bid)))
flags = v <= v.flatten()
vv = v.copy()
vv.fill(1.0)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, vv.get_block(bid)))
def test_create_vector_x(self):
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_x(),
self.nlp.create_vector_x()))
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_x(subset='l'),
self.nlp.create_vector_x(subset='l')))
self.assertTrue(
np.allclose(self.pyomo_nlp.create_vector_x(subset='u'),
self.nlp.create_vector_x(subset='u')))
self.assertTrue(
np.allclose(self.pyomo_nlp2.create_vector_x(),
self.nlp2.create_vector_x()))
self.assertTrue(
np.allclose(self.pyomo_nlp2.create_vector_x(subset='l'),
self.nlp2.create_vector_x(subset='l')))
self.assertTrue(
np.allclose(self.pyomo_nlp2.create_vector_x(subset='u'),
self.nlp2.create_vector_x(subset='u')))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_x(),
self.nlp3.create_vector_x()))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_x(subset='l'),
self.nlp3.create_vector_x(subset='l')))
self.assertTrue(
np.allclose(self.pyomo_nlp3.create_vector_x(subset='u'),
self.nlp3.create_vector_x(subset='u')))
def test_gt(self):
mat1 = self.square_mpi_mat
mat2 = self.square_mpi_mat2
serial_mat1 = self.square_serial_mat
serial_mat2 = self.square_serial_mat2
with warnings.catch_warnings():
warnings.simplefilter("ignore")
res = mat1 > mat2
serial_res = serial_mat1 > serial_mat2
self.assertIsInstance(res, MPIBlockMatrix)
self.assertTrue(
np.allclose(mat1.rank_ownership, res.rank_ownership))
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))
with self.assertRaises(Exception) as context:
res = mat1 > serial_mat2
mat1 = self.rectangular_mpi_mat
serial_mat1 = self.rectangular_serial_mat
with warnings.catch_warnings():
warnings.simplefilter("ignore")
res = mat1 > mat1
serial_res = serial_mat1 > serial_mat1
self.assertIsInstance(res, MPIBlockMatrix)
self.assertTrue(
np.allclose(mat1.rank_ownership, res.rank_ownership))
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))
with self.assertRaises(Exception) as context:
res = mat1 > serial_mat1
with self.assertRaises(Exception) as context:
res = serial_mat1 > mat1
def test_z_estimates(self):
z_estimates = np.array([5.0, 5.0])
nlp = AdmmNLP(self.pyomo_nlp,
self.coupling_vars,
rho=2.0,
z_estimates=z_estimates)
self.assertTrue(np.allclose(nlp.z_estimates(), z_estimates))
z_estimates = np.array([6.0, 5.0])
nlp.set_z_estimates(z_estimates)
self.assertTrue(np.allclose(nlp.z_estimates(), z_estimates))
self.assertEqual(len(nlp.create_vector_z()), 2)
def test_w_estimates(self):
w_estimates = np.array([5.0, 5.0])
nlp = AdmmNLP(self.pyomo_nlp,
self.coupling_vars,
rho=2.0,
w_estimates=w_estimates)
self.assertTrue(np.allclose(nlp.w_estimates(), w_estimates))
w_estimates = np.array([6.0, 5.0])
nlp.set_w_estimates(w_estimates)
self.assertTrue(np.allclose(nlp.w_estimates(), w_estimates))
self.assertEqual(len(nlp.create_vector_w()), 2)
def test_model2(self):
model = create_model2()
nlp = PyomoNLP(model)
solver = CyIpoptSolver(CyIpoptNLP(nlp))
x, info = solver.solve(tee=False)
x_sol = np.array([3.0, 1.99997807])
y_sol = np.array([0.00017543])
self.assertTrue(np.allclose(x, x_sol, rtol=1e-4))
nlp.set_primals(x)
nlp.set_duals(y_sol)
self.assertAlmostEqual(nlp.evaluate_objective(), -31.000000057167462, places=5)
self.assertTrue(np.allclose(info['mult_g'], y_sol, rtol=1e-4))
def test_model1(self):
model = create_model1()
nlp = PyomoNLP(model)
solver = CyIpoptSolver(CyIpoptNLP(nlp))
x, info = solver.solve(tee=False)
x_sol = np.array([3.85958688, 4.67936007, 3.10358931])
y_sol = np.array([-1.0, 53.90357665])
self.assertTrue(np.allclose(x, x_sol, rtol=1e-4))
nlp.set_primals(x)
nlp.set_duals(y_sol)
self.assertAlmostEqual(nlp.evaluate_objective(), -428.6362455416348, places=5)
self.assertTrue(np.allclose(info['mult_g'], y_sol, rtol=1e-4))
def test_transpose(self):
A_dense = self.basic_m.toarray()
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.toarray()))
A_dense = self.composed_m.toarray()
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.toarray()))
def test_copy(self):
clone = self.basic_m.copy()
self.assertTrue(np.allclose(clone.toarray(), self.dense))
clone.get_block(0, 0).data.fill(1)
self.assertAlmostEqual(clone.toarray()[0, 0], 1)
self.assertAlmostEqual(self.basic_m.toarray()[0, 0], 2)
bm = self.basic_m.copy()
clone = bm.copy(deep=False)
self.assertTrue(np.allclose(clone.toarray(), self.dense))
clone.get_block(0, 0).data.fill(1)
self.assertAlmostEqual(clone.toarray()[0, 0], 1)
self.assertAlmostEqual(bm.toarray()[0, 0], 1)
def test_rtruediv(self):
v = self.ones
v1 = v.clone(5.0, copy=True)
result = v1.__rtruediv__(v)
self.assertListEqual(result.tolist(), [1.0 / 5.0] * v.size)
result = v.flatten() / v1
self.assertTrue(
np.allclose(result.flatten(),
v.flatten() / v1.flatten()))
result = 5.0 / v1
self.assertTrue(np.allclose(result.flatten(), v.flatten()))
result = v1 / 5.0
self.assertTrue(np.allclose(result.flatten(), v.flatten()))
def test_copyto(self):
bm0 = self.basic_m.copy()
coo = bm0.tocoo()
coo.data.fill(1.0)
csr = coo.tocsr()
csc = coo.tocsc()
self.assertFalse(np.allclose(coo.toarray(), self.dense))
self.assertFalse(np.allclose(csr.toarray(), self.dense))
self.assertFalse(np.allclose(csc.toarray(), self.dense))
bm0.copyto(coo)
bm0.copyto(csr)
bm0.copyto(csc)
self.assertTrue(np.allclose(coo.toarray(), self.dense))
self.assertTrue(np.allclose(csr.toarray(), self.dense))
self.assertTrue(np.allclose(csc.toarray(), self.dense))
flat = np.ones((8, 8))
bm0.copyto(flat)
self.assertTrue(np.allclose(flat, self.dense))
bm = bm0.copy_structure()
bm0.copyto(bm)
self.assertTrue(np.allclose(bm.toarray(), self.dense))
bm.get_block(0, 0).data.fill(1.0)
self.assertAlmostEqual(bm0.toarray()[0, 0],
2) # this tests that a deep copy was done
self.assertAlmostEqual(bm.toarray()[0, 0], 1)
bm0.copyto(bm, deep=False)
bm.get_block(0, 0).data.fill(1.0)
self.assertAlmostEqual(bm0.toarray()[0, 0],
1) # this tests that a shallow copy was done
self.assertAlmostEqual(bm.toarray()[0, 0], 1)
def test_getrow(self):
m = self.basic_m
flat_mat = m.tocoo()
flat_row = flat_mat.getrow(2)
block_row = m.getrow(2)
self.assertTrue(
np.allclose(flat_row.toarray().flatten(), block_row.flatten()))
flat_row = flat_mat.getrow(7)
block_row = m.getrow(7)
self.assertTrue(
np.allclose(flat_row.toarray().flatten(), block_row.flatten()))
def test_rfloordiv(self):
v = self.ones
v.fill(2.0)
v1 = v.clone(5.0, copy=True)
result = v.__rfloordiv__(v1)
self.assertListEqual(result.tolist(), [5.0 // 2.0] * v.size)
result = v.flatten() // v1
self.assertTrue(
np.allclose(result.flatten(),
v.flatten() // v1.flatten()))
result = 2.0 // v1
self.assertTrue(np.allclose(result.flatten(), np.zeros(v1.size)))
result = v1 // 2.0
self.assertTrue(np.allclose(result.flatten(), np.ones(v1.size) * 2.0))
def test_abs(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))
rank = comm.Get_rank()
# create mpi matrix
rank_ownership = [[0, -1], [-1, 1]]
bm = MPIBlockMatrix(2, 2, rank_ownership, comm)
if rank == 0:
bm.set_block(0, 0, m)
if rank == 1:
bm.set_block(1, 1, m)
bm.broadcast_block_sizes()
serial_bm = BlockMatrix(2, 2)
serial_bm.set_block(0, 0, m)
serial_bm.set_block(1, 1, m)
res = abs(bm)
serial_res = abs(serial_bm)
rows, columns = np.nonzero(bm.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()))
def test_isub(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))
rank = comm.Get_rank()
# create mpi matrix
rank_ownership = [[0, -1], [-1, 1]]
bm = MPIBlockMatrix(2, 2, rank_ownership, comm)
if rank == 0:
bm.set_block(0, 0, m.copy())
if rank == 1:
bm.set_block(1, 1, m.copy())
bm.broadcast_block_sizes()
serial_bm = BlockMatrix(2, 2)
serial_bm.set_block(0, 0, m.copy())
serial_bm.set_block(1, 1, m.copy())
bm -= bm
serial_bm -= serial_bm
rows, columns = np.nonzero(bm.ownership_mask)
for i, j in zip(rows, columns):
if bm.get_block(i, j) is not None:
self.assertTrue(
np.allclose(
bm.get_block(i, j).toarray(),
serial_bm.get_block(i, j).toarray()))
with self.assertRaises(Exception) as context:
bm -= serial_bm
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)))
