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