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)))