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_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_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 _create_vectors(self): # Note: This method requires the complicated vars nz to be defined beforehand # init values and lower and upper bounds self._init_x = BlockVector(len(self._nlps) + 1) self._init_y = BlockVector(len(self._nlps) + self.nblocks) self._lower_x = BlockVector(len(self._nlps) + 1) self._upper_x = BlockVector(len(self._nlps) + 1) self._lower_g = BlockVector(len(self._nlps) + self.nblocks) self._upper_g = BlockVector(len(self._nlps) + self.nblocks) ndx = 0 for nlp in self._nlps: self._init_x.set_block(ndx, nlp.x_init()) self._init_y.set_block(ndx, nlp.y_init()) self._lower_x.set_block(ndx, nlp.xl()) self._upper_x.set_block(ndx, nlp.xu()) self._lower_g.set_block(ndx, nlp.gl()) self._upper_g.set_block(ndx, nlp.gu()) ndx += 1 self._init_x.set_block(ndx, np.zeros(self.nz, dtype=np.double)) self._lower_x.set_block(ndx, np.full(self.nz, -np.inf, dtype=np.double)) self._upper_x.set_block(ndx, np.full(self.nz, np.inf, dtype=np.double)) for i in range(self.nblocks): self._init_y.set_block(ndx, np.zeros(self.nz, dtype=np.double)) self._lower_g.set_block(ndx, np.zeros(self.nz, dtype=np.double)) self._upper_g.set_block(ndx, np.zeros(self.nz, dtype=np.double)) ndx += 1 # define x maps and masks self._lower_x_mask = np.isfinite(self._lower_x) self._lower_x_map = self._lower_x_mask.nonzero()[0] self._upper_x_mask = np.isfinite(self._upper_x) self._upper_x_map = self._upper_x_mask.nonzero()[0] # define gcd maps and masks bounds_difference = self._upper_g - self._lower_g abs_bounds_difference = np.absolute(bounds_difference) tolerance_equalities = 1e-8 self._c_mask = abs_bounds_difference < tolerance_equalities self._c_map = self._c_mask.nonzero()[0] self._d_mask = abs_bounds_difference >= tolerance_equalities self._d_map = self._d_mask.nonzero()[0] self._lower_g_mask = np.isfinite( self._lower_g) * self._d_mask + self._c_mask self._lower_g_map = self._lower_g_mask.nonzero()[0] self._upper_g_mask = np.isfinite( self._upper_g) * self._d_mask + self._c_mask self._upper_g_map = self._upper_g_mask.nonzero()[0] self._lower_d_mask = pn.isin(self._d_map, self._lower_g_map) self._upper_d_mask = pn.isin(self._d_map, self._upper_g_map) # remove empty vectors at the end of lower and upper d _lower_d_mask = BlockVector(self.nblocks) for i in range(self.nblocks): _lower_d_mask.set_block(i, self._lower_d_mask.get_block(i)) self._lower_d_mask = _lower_d_mask _upper_d_mask = BlockVector(self.nblocks) for i in range(self.nblocks): _upper_d_mask.set_block(i, self._upper_d_mask.get_block(i)) self._upper_d_mask = _upper_d_mask # define lower and upper d maps self._lower_d_map = pn.where(self._lower_d_mask)[0] self._upper_d_map = pn.where(self._upper_d_mask)[0] # get lower and upper d values self._lower_d = np.compress(self._d_mask, self._lower_g) self._upper_d = np.compress(self._d_mask, self._upper_g) # remove empty vectors at the end of lower and upper d _lower_d = BlockVector(self.nblocks) _upper_d = BlockVector(self.nblocks) for i in range(self.nblocks): _lower_d.set_block(i, self._lower_d.get_block(i)) _upper_d.set_block(i, self._upper_d.get_block(i)) self._lower_d = _lower_d self._upper_d = _upper_d
def _create_vectors(self): # Note: This method requires the complicated vars nz to be defined beforehand # init values self._init_x = BlockVector([nlp.x_init() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double)]) self._init_y = BlockVector( [nlp.y_init() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks)]) # lower and upper bounds self._lower_x = BlockVector( [nlp.xl() for nlp in self._nlps] + [np.full(self.nz, -np.inf, dtype=np.double)]) self._upper_x = BlockVector( [nlp.xu() for nlp in self._nlps] + [np.full(self.nz, np.inf, dtype=np.double)]) self._lower_g = BlockVector( [nlp.gl() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks)]) self._upper_g = BlockVector( [nlp.gu() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks)]) # define x maps and masks self._lower_x_mask = np.isfinite(self._lower_x) self._lower_x_map = self._lower_x_mask.nonzero()[0] self._upper_x_mask = np.isfinite(self._upper_x) self._upper_x_map = self._upper_x_mask.nonzero()[0] # define gcd maps and masks bounds_difference = self._upper_g - self._lower_g abs_bounds_difference = np.absolute(bounds_difference) tolerance_equalities = 1e-8 self._c_mask = abs_bounds_difference < tolerance_equalities self._c_map = self._c_mask.nonzero()[0] self._d_mask = abs_bounds_difference >= tolerance_equalities self._d_map = self._d_mask.nonzero()[0] self._lower_g_mask = np.isfinite( self._lower_g) * self._d_mask + self._c_mask self._lower_g_map = self._lower_g_mask.nonzero()[0] self._upper_g_mask = np.isfinite( self._upper_g) * self._d_mask + self._c_mask self._upper_g_map = self._upper_g_mask.nonzero()[0] self._lower_d_mask = pn.isin(self._d_map, self._lower_g_map) self._upper_d_mask = pn.isin(self._d_map, self._upper_g_map) # remove empty vectors at the end of lower and upper d self._lower_d_mask = \ BlockVector([self._lower_d_mask[i] for i in range(self.nblocks)]) self._upper_d_mask = \ BlockVector([self._upper_d_mask[i] for i in range(self.nblocks)]) # define lower and upper d maps self._lower_d_map = pn.where(self._lower_d_mask)[0] self._upper_d_map = pn.where(self._upper_d_mask)[0] # get lower and upper d values self._lower_d = np.compress(self._d_mask, self._lower_g) self._upper_d = np.compress(self._d_mask, self._upper_g) # remove empty vectors at the end of lower and upper d self._lower_d = BlockVector( [self._lower_d[i] for i in range(self.nblocks)]) self._upper_d = BlockVector( [self._upper_d[i] for i in range(self.nblocks)])
def _create_vectors(self): # Note: This method requires the complicated vars nz to be defined beforehand # init values self._init_x = BlockVector([nlp.x_init() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double)]) self._init_y = BlockVector([nlp.y_init() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks)]) # lower and upper bounds self._lower_x = BlockVector([nlp.xl() for nlp in self._nlps] + [np.full(self.nz, -np.inf, dtype=np.double)]) self._upper_x = BlockVector([nlp.xu() for nlp in self._nlps] + [np.full(self.nz, np.inf, dtype=np.double)]) self._lower_g = BlockVector([nlp.gl() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks)]) self._upper_g = BlockVector([nlp.gu() for nlp in self._nlps] + [np.zeros(self.nz, dtype=np.double) for i in range(self.nblocks)]) # define x maps and masks self._lower_x_mask = np.isfinite(self._lower_x) self._lower_x_map = self._lower_x_mask.nonzero()[0] self._upper_x_mask = np.isfinite(self._upper_x) self._upper_x_map = self._upper_x_mask.nonzero()[0] # define gcd maps and masks bounds_difference = self._upper_g - self._lower_g abs_bounds_difference = np.absolute(bounds_difference) tolerance_equalities = 1e-8 self._c_mask = abs_bounds_difference < tolerance_equalities self._c_map = self._c_mask.nonzero()[0] self._d_mask = abs_bounds_difference >= tolerance_equalities self._d_map = self._d_mask.nonzero()[0] self._lower_g_mask = np.isfinite(self._lower_g) * self._d_mask + self._c_mask self._lower_g_map = self._lower_g_mask.nonzero()[0] self._upper_g_mask = np.isfinite(self._upper_g) * self._d_mask + self._c_mask self._upper_g_map = self._upper_g_mask.nonzero()[0] self._lower_d_mask = pn.isin(self._d_map, self._lower_g_map) self._upper_d_mask = pn.isin(self._d_map, self._upper_g_map) # remove empty vectors at the end of lower and upper d self._lower_d_mask = \ BlockVector([self._lower_d_mask[i] for i in range(self.nblocks)]) self._upper_d_mask = \ BlockVector([self._upper_d_mask[i] for i in range(self.nblocks)]) # define lower and upper d maps self._lower_d_map = pn.where(self._lower_d_mask)[0] self._upper_d_map = pn.where(self._upper_d_mask)[0] # get lower and upper d values self._lower_d = np.compress(self._d_mask, self._lower_g) self._upper_d = np.compress(self._d_mask, self._upper_g) # remove empty vectors at the end of lower and upper d self._lower_d = BlockVector([self._lower_d[i] for i in range(self.nblocks)]) self._upper_d = BlockVector([self._upper_d[i] for i in range(self.nblocks)])