def test_multiply(self): # test scalar multiplication m = self.basic_m * 5.0 dense_m = m.todense() b00 = self.block00.tocoo() b11 = self.block11.tocoo() b10 = self.block10 scipy_m = bmat([[b00, b10.transpose()], [b10, b11]], format='coo') dense_scipy_m = scipy_m.todense() * 5.0 self.assertTrue(np.allclose(dense_scipy_m, dense_m, atol=1e-3)) m = 5.0 * self.basic_m dense_m = m.todense() self.assertTrue(np.allclose(dense_scipy_m, dense_m, atol=1e-3)) # test matrix vector product m = self.basic_m x = BlockVector(m.bshape[1]) for i in range(m.bshape[1]): x[i] = np.ones(m.col_block_sizes()[i], dtype=np.float64) dinopy_res = m * x scipy_res = scipy_m * x.flatten() self.assertListEqual(dinopy_res.tolist(), scipy_res.tolist()) dinopy_res = m * x.flatten() scipy_res = scipy_m * x.flatten() self.assertListEqual(dinopy_res.tolist(), scipy_res.tolist()) self.basic_m *= 5.0 self.assertTrue(np.allclose(self.basic_m.todense(), dense_m, atol=1e-3))
def compute_init_lam(nlp, x=None, lam_max=1e3): if x is None: x = nlp.x_init else: assert x.size == nlp.nx assert nlp.nd == 0, "only supported for equality constrained nlps for now" nx = nlp.nx nc = nlp.nc # create Jacobian jac_c = nlp.jacobian_g(x) # create gradient of objective df = nlp.grad_objective(x) # create KKT system kkt = BlockSymMatrix(2) kkt[0, 0] = identity(nx) kkt[1, 0] = jac_c zeros = np.zeros(nc) rhs = BlockVector([-df, zeros]) flat_kkt = kkt.tocoo().tocsc() flat_rhs = rhs.flatten() sol = spsolve(flat_kkt, flat_rhs) return sol[nlp.nx:nlp.nx + nlp.ng]
def test__isub__(self): v = BlockVector(2) a = np.ones(5) b = np.zeros(9) v[0] = a v[1] = b v -= 5.0 self.assertTrue(np.allclose(v[0], a - 5.0)) self.assertTrue(np.allclose(v[1], b - 5.0)) v = BlockVector(2) a = np.ones(5) b = np.zeros(9) v[0] = a v[1] = b v2 = BlockVector(2) v2[0] = np.ones(5) v2[1] = np.ones(9) v -= v2 self.assertTrue(np.allclose(v[0], a - 1)) self.assertTrue(np.allclose(v[1], b - 1)) self.assertTrue(np.allclose(v2[0], np.ones(5))) self.assertTrue(np.allclose(v2[1], np.ones(9)))
def test__imul__(self): v = BlockVector(2) a = np.ones(5) b = np.arange(9) v[0] = a v[1] = b v *= 2.0 self.assertTrue(np.allclose(v[0], a * 2.0)) self.assertTrue(np.allclose(v[1], b * 2.0)) v = BlockVector(2) a = np.ones(5) b = np.zeros(9) v[0] = a v[1] = b v2 = BlockVector(2) v2[0] = np.ones(5)*2 v2[1] = np.ones(9)*2 v *= v2 self.assertTrue(np.allclose(v[0], a * 2)) self.assertTrue(np.allclose(v[1], b * 2)) self.assertTrue(np.allclose(v2[0], np.ones(5)*2)) self.assertTrue(np.allclose(v2[1], np.ones(9)*2))
def test__iadd__(self): v = BlockVector(2) a = np.ones(5) b = np.zeros(9) v[0] = a v[1] = b v += 1.0 self.assertTrue(np.allclose(v[0], a+1)) self.assertTrue(np.allclose(v[1], b + 1)) v = BlockVector(2) a = np.ones(5) b = np.zeros(9) v[0] = a v[1] = b v2 = BlockVector(2) v2[0] = np.ones(5) v2[1] = np.ones(9) v += v2 self.assertTrue(np.allclose(v[0], a + 1)) self.assertTrue(np.allclose(v[1], b + 1)) self.assertTrue(np.allclose(v2[0], np.ones(5))) self.assertTrue(np.allclose(v2[1], np.ones(9)))
def create_vector_y(self, subset=None): """Return ndarray of vector of constraints Parameters ---------- subset : str, optional determines size of vector. `c`: only equality constraints `d`: only inequality constraints `dl`: only inequality constraints with lower bound `du`: only inequality constraints with upper bound Returns ------- BlockVector """ if subset is None: return BlockVector( [np.zeros(nlp.ng, dtype=np.double) for nlp in self._nlps] + [ np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks) ]) elif subset == 'c': return BlockVector( [np.zeros(nlp.nc, dtype=np.double) for nlp in self._nlps] + [ np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks) ]) elif subset == 'd': return BlockVector( [np.zeros(nlp.nd, dtype=np.double) for nlp in self._nlps]) else: raise RuntimeError('Subset not recognized')
def setUp(self): self.v1 = np.array([1.1, 2.2, 3.3]) self.v2 = np.array([4.4, 5.5, 6.6, 7.7]) self.v3 = np.array([1.1, 2.2, 3.3])*2 self.v4 = np.array([4.4, 5.5, 6.6, 7.7])*2 self.bv = BlockVector([self.v1, self.v2]) self.bv2 = BlockVector([self.v3, self.v4])
def test_cumsum(self): v = BlockVector(3) v[0] = np.arange(1, 5) v[1] = np.arange(5, 10) v[2] = np.arange(10, 15) c = np.arange(1, 15) self.assertListEqual(v.cumsum().tolist(), c.cumsum().tolist())
def test_get_block_vector_for_dot_product_5(self): rank = comm.Get_rank() rank_ownership = np.array([[1, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]) m = MPIBlockMatrix(4, 3, rank_ownership, comm) sub_m = np.array([[1, 0], [0, 1]]) sub_m = coo_matrix(sub_m) if rank == 0: m.set_block(3, rank, sub_m.copy()) elif rank == 1: m.set_block(0, 0, sub_m.copy()) m.set_block(rank, rank, sub_m.copy()) m.set_block(3, rank, sub_m.copy()) else: m.set_block(rank, rank, sub_m.copy()) m.set_block(3, rank, sub_m.copy()) v = BlockVector(3) sub_v = np.ones(2) for ndx in range(3): v.set_block(ndx, sub_v.copy()) res = m._get_block_vector_for_dot_product(v) self.assertIs(res, v) v_flat = v.flatten() res = m._get_block_vector_for_dot_product(v_flat) self.assertIsInstance(res, BlockVector) for ndx in range(3): block = res.get_block(ndx) self.assertTrue(np.array_equal(block, sub_v))
def test_multiply(self): # test scalar multiplication m = self.basic_m * 5.0 dense_m = m.todense() b00 = self.block00.tofullcoo() b11 = self.block11.tofullcoo() b10 = self.block10 scipy_m = bmat([[b00, b10.transpose()], [b10, b11]], format='coo') dense_scipy_m = scipy_m.todense() * 5.0 self.assertTrue(np.allclose(dense_scipy_m, dense_m, atol=1e-3)) m = 5.0 * self.basic_m dense_m = m.todense() self.assertTrue(np.allclose(dense_scipy_m, dense_m, atol=1e-3)) # test matrix vector product m = self.basic_m x = BlockVector(m.bshape[1]) for i in range(m.bshape[1]): x[i] = np.ones(m.col_block_sizes()[i], dtype=np.float64) dinopy_res = m * x scipy_res = scipy_m * x.flatten() self.assertListEqual(dinopy_res.tolist(), scipy_res.tolist()) dinopy_res = m * x.flatten() scipy_res = scipy_m * x.flatten() self.assertListEqual(dinopy_res.tolist(), scipy_res.tolist())
def compute_init_lam(nlp, x=None, lam_max=1e3): if x is None: x = nlp.init_primals() else: assert x.size == nlp.n_primals() nlp.set_primals(x) assert nlp.n_ineq_constraints( ) == 0, "only supported for equality constrained nlps for now" nx = nlp.n_primals() nc = nlp.n_constraints() # create Jacobian jac = nlp.evaluate_jacobian() # create gradient of objective df = nlp.evaluate_grad_objective() # create KKT system kkt = BlockSymMatrix(2) kkt[0, 0] = identity(nx) kkt[1, 0] = jac zeros = np.zeros(nc) rhs = BlockVector([-df, zeros]) flat_kkt = kkt.tocoo().tocsc() flat_rhs = rhs.flatten() sol = spsolve(flat_kkt, flat_rhs) return sol[nlp.n_primals():nlp.n_primals() + nlp.n_constraints()]
def set_primal_dual_kkt_solution(self, sol: BlockVector): for ndx, nlp in self._nlps.items(): nlp.set_primal_dual_kkt_solution(sol.get_block(ndx).get_block(0)) self._delta_primals.set_block(ndx, nlp.get_delta_primals()) self._delta_slacks.set_block(ndx, nlp.get_delta_slacks()) self._delta_duals_eq.get_block(ndx).set_block( 0, nlp.get_delta_duals_eq()) self._delta_duals_ineq.set_block(ndx, nlp.get_delta_duals_ineq()) self._delta_duals_primals_lb.set_block( ndx, nlp.get_delta_duals_primals_lb()) self._delta_duals_primals_ub.set_block( ndx, nlp.get_delta_duals_primals_ub()) self._delta_duals_slacks_lb.set_block( ndx, nlp.get_delta_duals_slacks_lb()) self._delta_duals_slacks_ub.set_block( ndx, nlp.get_delta_duals_slacks_ub()) self._delta_duals_eq.get_block(ndx).set_block( 1, sol.get_block(ndx).get_block(1)) self._delta_duals_eq.get_block(ndx).set_block( 2, sol.get_block( self._num_time_blocks).get_block(0).get_block(ndx)) self._delta_primals.set_block( self._num_time_blocks, sol.get_block(self._num_time_blocks).get_block(1))
def test_tolist(self): v = BlockVector(2) a = np.arange(5) b = np.arange(9) c = np.concatenate([a, b]) v[0] = a v[1] = b self.assertListEqual(v.tolist(), c.tolist())
def test_fill(self): v = BlockVector(2) a = np.arange(5) b = np.arange(9) v[0] = a v[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[0] = a v[1] = b self.assertEqual(v.min(), c.min())
def test_copyto(self): v = self.ones v2 = BlockVector(len(self.list_sizes_ones)) v.copyto(v2) self.assertListEqual(v.tolist(), v2.tolist()) v3 = np.zeros(v.size) v.copyto(v3) self.assertListEqual(v.tolist(), v3.tolist()) v *= 5 v.copyto(v2) self.assertListEqual(v.tolist(), v2.tolist())
def set_duals_ineq(self, duals_ineq: BlockVector): """ Parameters ---------- duals_ineq: BlockVector The values for the duals of the inequality constraints. This BlockVector has one block for every time block. """ for ndx, nlp in self._nlps.items(): nlp.set_duals_ineq(duals_ineq.get_block(ndx)) self._duals_ineq.set_block(ndx, duals_ineq.get_block(ndx))
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))
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))
def test_create_vector_x(self): x_ = BlockVector(self.n_scenarios + 1) nz = len(self.complicated_vars_ids) nx_i = (self.G.shape[0] + nz) for i in range(self.n_scenarios): x_[i] = np.zeros(nx_i) x_[self.n_scenarios] = np.zeros(nz) self.assertEqual(x_.shape, self.nlp.create_vector_x().shape) self.assertEqual(x_.nblocks, self.nlp.create_vector_x().nblocks) self.assertTrue( np.allclose(x_.block_sizes(), self.nlp.create_vector_x().block_sizes())) self.assertListEqual(list(x_.flatten()), list(self.nlp.create_vector_x().flatten())) # check for subset for s in ['l', 'u']: xs = self.nlp.create_vector_x(subset=s) xs_ = BlockVector(self.n_scenarios + 1) for i in range(self.n_scenarios): xs_[i] = np.zeros(1) xs_[self.n_scenarios] = np.zeros(0) self.assertEqual(xs_.shape, xs.shape) self.assertEqual(xs_.nblocks, xs.nblocks) self.assertTrue(np.allclose(xs_.block_sizes(), xs.block_sizes())) self.assertListEqual(list(xs_.flatten()), list(xs.flatten()))
def evaluate_eq_constraints(self) -> BlockVector: """ Returns ------- eq_resid: BlockVector The residuals of the equality constraints, including the coupling constraints. This BlockVector has one block for every time block. Each block is itself a BlockVector with 3 blocks. The first block contains the residuals of the equality constraints in the corresponding time block. The second block has the residuals for the coupling constraints linking the states at the beginning of the time block to the coupling variables between the time block and the previous time block. The third block has the residuals for the coupling constraints linking the states at the end of the time block to the coupling variables between the time block and the next time block. """ for ndx, nlp in self._nlps.items(): sub_block = BlockVector(3) sub_block.set_block(0, nlp.evaluate_eq_constraints()) sub_block.set_block( 1, (self._link_backward_matrices[ndx] * nlp.get_primals() - (self._link_backward_coupling_matrices[ndx] * self._primals.get_block(self._num_time_blocks)))) sub_block.set_block( 2, (self._link_forward_matrices[ndx] * nlp.get_primals() - (self._link_forward_coupling_matrices[ndx] * self._primals.get_block(self._num_time_blocks)))) self._eq_resid.set_block(ndx, sub_block) return self._eq_resid
def set_primals(self, primals: BlockVector): """ Set the values of the primal variables for evaluation (i.e., the evaluate_* methods). Parameters ---------- primals: BlockVector The values for each primal variable. This BlockVector should have one block for every time block and one block for the coupling variables. """ for ndx, nlp in self._nlps.items(): nlp.set_primals(primals.get_block(ndx)) self._primals.set_block(ndx, primals.get_block(ndx)) self._primals.set_block(self._num_time_blocks, primals.get_block(self._num_time_blocks))
def test_xu(self): xu = BlockVector(self.n_scenarios + 1) nz = len(self.complicated_vars_ids) nx_i = (self.G.shape[0] + nz) for i in range(self.n_scenarios): xu[i] = np.array([np.inf] * nx_i) xu[i][0] = 100.0 xu[self.n_scenarios] = np.array([np.inf] * nz) self.assertIsInstance(self.nlp.xu(), BlockVector) xu_flat = xu.flatten() self.assertEqual(xu.nblocks, self.nlp.xu().nblocks) self.assertTrue( np.allclose(xu.block_sizes(), self.nlp.xu().block_sizes())) self.assertListEqual(list(xu_flat), list(self.nlp.xu().flatten()))
def evaluate_d(self, x, out=None, **kwargs): """Returns the inequality constraints evaluated at x Parameters ---------- x : array_like Array with values of primal variables. out : array_like Output array. Its type is preserved and it must be of the right shape to hold the output. Returns ------- array_like """ evaluated_g = kwargs.pop('evaluated_g', None) if out is None: res = self.create_vector_y(subset='d') else: assert isinstance( out, BlockVector), 'Composite NLP takes block vector to evaluate g' assert out.nblocks == self.nblocks assert out.size == self.nd res = out if evaluated_g is not None: assert isinstance(evaluated_g, BlockVector), 'evaluated_g must be a BlockVector' assert evaluated_g.nblocks == 2 * self.nblocks assert evaluated_g.size == self.ng d = evaluated_g.compress(self._d_mask) if out is None: return BlockVector( [d.get_block(j) for j in range(self.nblocks)]) for bid in range(self.nblocks): out.set_block(bid, d.get_block(bid)) return out if isinstance(x, BlockVector): assert x.size == self.nx assert x.nblocks == self.nblocks + 1 for sid in range(self.nblocks): self._nlps[sid].evaluate_d(x.get_block(sid), out=res.get_block(sid)) return res elif isinstance(x, np.ndarray): assert x.size == self.nx block_x = self.create_vector_x() block_x.copyfrom(x) x_ = block_x for sid in range(self.nblocks): self._nlps[sid].evaluate_d(x_.get_block(sid), out=res.get_block(sid)) return res else: raise NotImplementedError( "x must be a numpy array or a BlockVector")
def test_x_init(self): x_init = BlockVector(self.n_scenarios + 1) nz = len(self.complicated_vars_ids) nx_i = (self.G.shape[0] + nz) for i in range(self.n_scenarios): x_init[i] = np.zeros(nx_i) x_init[i][0] = 1.0 x_init[self.n_scenarios] = np.zeros(nz) self.assertIsInstance(self.nlp.x_init(), BlockVector) x_init_flat = x_init.flatten() self.assertEqual(x_init.nblocks, self.nlp.x_init().nblocks) self.assertTrue( np.allclose(x_init.block_sizes(), self.nlp.x_init().block_sizes())) self.assertListEqual(list(x_init_flat), list(self.nlp.x_init().flatten()))
def test_setdiff1d(self): vv1 = np.array([1.1, 3.3]) vv2 = np.array([4.4, 7.7]) bvv = BlockVector(2) bvv.set_blocks([vv1, vv2]) res = pn.setdiff1d(self.bv, bvv) self.assertIsInstance(res, BlockVector) self.assertTrue(np.allclose(res.get_block(0), np.array([2.2]))) self.assertTrue(np.allclose(res.get_block(1), np.array([5.5, 6.6]))) vv3 = np.array([1.1, 7.7]) res = pn.setdiff1d(self.bv, vv3) self.assertIsInstance(res, BlockVector) self.assertTrue(np.allclose(res.get_block(0), np.array([2.2, 3.3]))) self.assertTrue( np.allclose(res.get_block(1), np.array([4.4, 5.5, 6.6])))
def test_arccos(self): self.v1 = np.array([1.1, 2.2, 3.3]) / 10.0 self.v2 = np.array([4.4, 5.5, 6.6, 7.7]) / 10.0 self.bv = BlockVector([self.v1, self.v2]) fname = 'arccos' fnp = getattr(np, fname) fpn = getattr(pn, fname) np_v1 = fnp(self.v1) pn_v1 = fpn(self.v1) self.assertTrue(np.allclose(np_v1, pn_v1)) np_v1 = fnp(self.v1) np_v2 = fnp(self.v2) pn_block = fpn(self.bv) self.assertTrue(np.allclose(np_v1, pn_block[0])) self.assertTrue(np.allclose(np_v2, pn_block[1]))
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[0] = a test_bv[1] = b res = pn.isin(bv, test_bv) for bid, blk in enumerate(bv): self.assertEqual(blk.size, res[bid].size) res_flat = np.isin(blk, test_bv[bid]) self.assertTrue(np.allclose(res[bid], res_flat)) c = np.concatenate([a, b]) res = pn.isin(bv, c) for bid, blk in enumerate(bv): self.assertEqual(blk.size, res[bid].size) res_flat = np.isin(blk, c) self.assertTrue(np.allclose(res[bid], res_flat)) res = pn.isin(bv, test_bv, invert=True) for bid, blk in enumerate(bv): self.assertEqual(blk.size, res[bid].size) res_flat = np.isin(blk, test_bv[bid], invert=True) self.assertTrue(np.allclose(res[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[bid].size) res_flat = np.isin(blk, c, invert=True) self.assertTrue(np.allclose(res[bid], res_flat))
def test_where(self): bv = self.bv condition = bv >= 4.5 res = pn.where(condition)[0] for bid, blk in enumerate(res): self.assertTrue( np.allclose(blk, pn.where(bv.get_block(bid) >= 4.5))) flat_condition = condition.flatten() res = pn.where(condition, 2.0, 1.0) res_flat = pn.where(flat_condition, 2.0, 1.0) self.assertTrue(np.allclose(res.flatten(), res_flat)) res = pn.where(condition, 2.0, np.ones(bv.size)) res_flat = pn.where(flat_condition, 2.0, np.ones(bv.size)) self.assertTrue(np.allclose(res.flatten(), res_flat)) res = pn.where(condition, np.ones(bv.size) * 2.0, 1.0) res_flat = pn.where(flat_condition, np.ones(bv.size) * 2.0, 1.0) self.assertTrue(np.allclose(res.flatten(), res_flat)) res = pn.where(condition, np.ones(bv.size) * 2.0, np.ones(bv.size)) res_flat = pn.where(flat_condition, np.ones(bv.size) * 2.0, np.ones(bv.size)) self.assertTrue(np.allclose(res.flatten(), res_flat)) bones = BlockVector(2) bones.set_blocks([np.ones(3), np.ones(4)]) res = pn.where(condition, bones * 2.0, 1.0) res_flat = pn.where(flat_condition, np.ones(bv.size) * 2.0, 1.0) self.assertTrue(np.allclose(res.flatten(), res_flat)) res = pn.where(condition, 2.0, bones) res_flat = pn.where(flat_condition, 2.0, bones) self.assertTrue(np.allclose(res.flatten(), res_flat)) res = pn.where(condition, np.ones(bv.size) * 2.0, bones) res_flat = pn.where(flat_condition, np.ones(bv.size) * 2.0, np.ones(bv.size)) self.assertTrue(np.allclose(res.flatten(), res_flat)) res = pn.where(condition, bones * 2.0, np.ones(bv.size)) res_flat = pn.where(flat_condition, np.ones(bv.size) * 2.0, np.ones(bv.size)) self.assertTrue(np.allclose(res.flatten(), res_flat))
def test_copyfrom(self): v = self.ones v1 = np.zeros(v.size) v.copyfrom(v1) self.assertListEqual(v.tolist(), v1.tolist()) v2 = BlockVector(len(self.list_sizes_ones)) for i, s in enumerate(self.list_sizes_ones): v2[i] = np.ones(s)*i v.copyfrom(v2) for idx, blk in enumerate(v2): self.assertListEqual(blk.tolist(), v2[idx].tolist()) v3 = BlockVector(2) v4 = v.clone(2) v3[0] = v4 v3[1] = np.zeros(3) self.assertListEqual(v3.tolist(), v4.tolist() + [0]*3)
def test_intersect1d(self): vv1 = np.array([1.1, 3.3]) vv2 = np.array([4.4, 7.7]) bvv = BlockVector(2) bvv.set_blocks([vv1, vv2]) res = pn.intersect1d(self.bv, bvv) self.assertIsInstance(res, BlockVector) self.assertTrue(np.allclose(res.get_block(0), vv1)) self.assertTrue(np.allclose(res.get_block(1), vv2)) vv3 = np.array([1.1, 7.7]) res = pn.intersect1d(self.bv, vv3) self.assertIsInstance(res, BlockVector) self.assertTrue(np.allclose(res.get_block(0), np.array([1.1]))) self.assertTrue(np.allclose(res.get_block(1), np.array([7.7]))) res = pn.intersect1d(vv3, self.bv) self.assertIsInstance(res, BlockVector) self.assertTrue(np.allclose(res.get_block(0), np.array([1.1]))) self.assertTrue(np.allclose(res.get_block(1), np.array([7.7])))
def create_blocks(self, m: np.ndarray, x: np.ndarray): m = coo_matrix(m) r = m * x bm = BlockMatrix(2, 2) bm.set_block(0, 0, m.copy()) bm.set_block(1, 1, m.copy()) br = BlockVector(2) br.set_block(0, r.copy()) br.set_block(1, r.copy()) bx = BlockVector(2) bx.set_block(0, x.copy()) bx.set_block(1, x.copy()) return bm, bx, br