def test_preorder_visit(self): # test that we can use the advanced preorder_visit # function on a block to efficiently check for these # constraint containers (without iterating over # their children) A = numpy.ones((3,3)) m = block() m.c = matrix_constraint(A) m.v = variable() m.V = variable_list() m.V.append(variable()) m.B = block_list() m.B.append(block()) m.B[0].c = matrix_constraint(A) m.B[0].v = variable() m.B[0].V = variable_list() m.B[0].V.append(variable()) m.b = block() m.b.c = constraint_dict() m.b.c[None] = matrix_constraint(A) m.b.c[1] = matrix_constraint(A) m.b.c[2] = constraint() m.b.c[3] = constraint_list() # don't visit things below a matrix constraint # (e.g., cases where we want to handle it in bulk) def no_mc_descend(x): if isinstance(x, matrix_constraint): return False return True cnt = 0 for obj in m.preorder_traversal(ctype=IConstraint, descend=no_mc_descend): self.assertTrue(type(obj.parent) is not matrix_constraint) self.assertTrue((obj.ctype is block._ctype) or \ (obj.ctype is constraint._ctype)) cnt += 1 self.assertEqual(cnt, 11) cnt = 0 mc_child_cnt = 0 for obj in m.preorder_traversal(ctype=IConstraint): self.assertTrue((obj.ctype is block._ctype) or \ (obj.ctype is constraint._ctype)) if type(obj.parent) is matrix_constraint: mc_child_cnt += 1 cnt += 1 self.assertEqual(cnt, 23) self.assertEqual(mc_child_cnt, 12) self.assertEqual( len(list(m.components(ctype=IConstraint))), 13)
def test_preorder_traversal(self): A = numpy.ones((3,3)) m = block() m.c = matrix_constraint(A) m.v = variable() m.V = variable_list() m.V.append(variable()) m.B = block_list() m.B.append(block()) m.B[0].c = matrix_constraint(A) m.B[0].v = variable() m.B[0].V = variable_list() m.B[0].V.append(variable()) m.b = block() m.b.c = constraint_dict() m.b.c[None] = matrix_constraint(A) m.b.c[1] = matrix_constraint(A) m.b.c[2] = constraint() m.b.c[3] = constraint_list() # don't visit things below a matrix constraint # (e.g., cases where we want to handle it in bulk) def no_mc_descend(x): if isinstance(x, matrix_constraint): return False return True cnt = 0 for obj in pmo.preorder_traversal(m, ctype=IConstraint, descend=no_mc_descend): self.assertTrue(type(obj.parent) is not matrix_constraint) self.assertTrue((obj.ctype is block._ctype) or \ (obj.ctype is constraint._ctype)) cnt += 1 self.assertEqual(cnt, 11) cnt = 0 mc_child_cnt = 0 for obj in pmo.preorder_traversal(m, ctype=IConstraint): self.assertTrue((obj.ctype is block._ctype) or \ (obj.ctype is constraint._ctype)) if type(obj.parent) is matrix_constraint: mc_child_cnt += 1 cnt += 1 self.assertEqual(cnt, 23) self.assertEqual(mc_child_cnt, 12) self.assertEqual( len(list(m.components(ctype=IConstraint))), 13)
def test_preorder_traversal(self): A = numpy.ones((3,3)) m = block() m.c = matrix_constraint(A) m.v = variable() m.V = variable_list() m.V.append(variable()) m.B = block_list() m.B.append(block()) m.B[0].c = matrix_constraint(A) m.B[0].v = variable() m.B[0].V = variable_list() m.B[0].V.append(variable()) m.b = block() m.b.c = constraint_dict() m.b.c[None] = matrix_constraint(A) m.b.c[1] = matrix_constraint(A) m.b.c[2] = constraint() m.b.c[3] = constraint_list() # don't visit things below a matrix constraint # (e.g., cases where we want to handle it in bulk) def no_mc_descend(x): if isinstance(x, matrix_constraint): return False return True cnt = 0 for obj in pmo.preorder_traversal(m, ctype=IConstraint, descend=no_mc_descend): self.assertTrue(type(obj.parent) is not matrix_constraint) self.assertTrue((obj.ctype is block._ctype) or \ (obj.ctype is constraint._ctype)) cnt += 1 self.assertEqual(cnt, 11) cnt = 0 mc_child_cnt = 0 for obj in pmo.preorder_traversal(m, ctype=IConstraint): self.assertTrue((obj.ctype is block._ctype) or \ (obj.ctype is constraint._ctype)) if type(obj.parent) is matrix_constraint: mc_child_cnt += 1 cnt += 1 self.assertEqual(cnt, 23) self.assertEqual(mc_child_cnt, 12) self.assertEqual( len(list(m.components(ctype=IConstraint))), 13)
def test_containers(self): c = self._object_factory() self.assertIs(c.parent, None) cdict = constraint_dict() cdict[None] = c self.assertIs(c.parent, cdict) del cdict[None] self.assertIs(c.parent, None) clist = constraint_list() clist.append(c) self.assertIs(c.parent, clist) clist.remove(c) self.assertIs(c.parent, None) ctuple = constraint_tuple((c, )) self.assertIs(c.parent, ctuple)
def test_containers(self): c = self._object_factory() self.assertIs(c.parent, None) cdict = constraint_dict() cdict[None] = c self.assertIs(c.parent, cdict) del cdict[None] self.assertIs(c.parent, None) clist = constraint_list() clist.append(c) self.assertIs(c.parent, clist) clist.remove(c) self.assertIs(c.parent, None) ctuple = constraint_tuple((c,)) self.assertIs(c.parent, ctuple)
class TestComponentSet(unittest.TestCase): _components = [ variable(), variable_dict(), variable_list(), constraint(), constraint_dict(), constraint_list(), objective(), objective_dict(), objective_list(), expression(), expression_dict(), expression_list(), block(), block_dict(), block_list(), suffix() ] def test_pickle(self): c = ComponentSet() self.assertEqual(len(c), 0) cup = pickle.loads(pickle.dumps(c)) self.assertIsNot(cup, c) self.assertEqual(len(cup), 0) v = variable() c.add(v) self.assertEqual(len(c), 1) self.assertTrue(v in c) cup = pickle.loads(pickle.dumps(c)) vup = cup.pop() cup.add(vup) self.assertIsNot(cup, c) self.assertIsNot(vup, v) self.assertEqual(len(cup), 1) self.assertTrue(vup in cup) self.assertEqual(vup.parent, None) b = block() V = b.V = variable_list() b.V.append(v) b.c = c self.assertEqual(len(c), 1) self.assertTrue(v in c) self.assertIs(v.parent, b.V) self.assertIs(V.parent, b) self.assertIs(b.parent, None) bup = pickle.loads(pickle.dumps(b)) Vup = bup.V vup = Vup[0] cup = bup.c self.assertIsNot(cup, c) self.assertIsNot(vup, v) self.assertIsNot(Vup, V) self.assertIsNot(bup, b) self.assertEqual(len(cup), 1) self.assertTrue(vup in cup) self.assertIs(vup.parent, Vup) self.assertIs(Vup.parent, bup) self.assertIs(bup.parent, None) self.assertEqual(len(c), 1) self.assertTrue(v in c) def test_init(self): cset = ComponentSet() cset = ComponentSet(self._components) with self.assertRaises(TypeError): cset = ComponentSet(*self._components) def test_type(self): cset = ComponentSet() self.assertTrue(isinstance(cset, collections.abc.Set)) self.assertTrue(isinstance(cset, collections.abc.MutableSet)) self.assertTrue(issubclass(type(cset), collections.abc.Set)) self.assertTrue(issubclass(type(cset), collections.abc.MutableSet)) def test_str(self): cset = ComponentSet() self.assertEqual(str(cset), "ComponentSet([])") cset.update(self._components) str(cset) def test_len(self): cset = ComponentSet() self.assertEqual(len(cset), 0) cset.update(self._components) self.assertEqual(len(cset), len(self._components)) cset = ComponentSet(self._components) self.assertEqual(len(cset), len(self._components)) self.assertTrue(len(self._components) > 0) def test_iter(self): cset = ComponentSet() self.assertEqual(list(iter(cset)), []) cset.update(self._components) ids_seen = set() for c in cset: ids_seen.add(id(c)) self.assertEqual(ids_seen, set(id(c) for c in self._components)) def set_add(self): cset = ComponentSet() self.assertEqual(len(cset), 0) for i, c in enumerate(self._components): self.assertTrue(c not in cset) cset.add(c) self.assertTrue(c in cset) self.assertEqual(len(cset), i + 1) self.assertEqual(len(cset), len(self._components)) for c in self._components: self.assertTrue(c in cset) cset.add(c) self.assertTrue(c in cset) self.assertEqual(len(cset), len(self._components)) def test_pop(self): cset = ComponentSet() self.assertEqual(len(cset), 0) with self.assertRaises(KeyError): cset.pop() v = variable() cset.add(v) self.assertTrue(v in cset) self.assertEqual(len(cset), 1) v_ = cset.pop() self.assertIs(v, v_) self.assertTrue(v not in cset) self.assertEqual(len(cset), 0) def test_update(self): cset = ComponentSet() self.assertEqual(len(cset), 0) cset.update(self._components) self.assertEqual(len(cset), len(self._components)) for c in self._components: self.assertTrue(c in cset) def test_clear(self): cset = ComponentSet() self.assertEqual(len(cset), 0) cset.update(self._components) self.assertEqual(len(cset), len(self._components)) cset.clear() self.assertEqual(len(cset), 0) def test_remove(self): cset = ComponentSet() self.assertEqual(len(cset), 0) cset.update(self._components) self.assertEqual(len(cset), len(self._components)) for i, c in enumerate(self._components): cset.remove(c) self.assertEqual(len(cset), len(self._components) - (i + 1)) for c in self._components: self.assertTrue(c not in cset) with self.assertRaises(KeyError): cset.remove(c) def test_discard(self): cset = ComponentSet() self.assertEqual(len(cset), 0) cset.update(self._components) self.assertEqual(len(cset), len(self._components)) for i, c in enumerate(self._components): cset.discard(c) self.assertEqual(len(cset), len(self._components) - (i + 1)) for c in self._components: self.assertTrue(c not in cset) cset.discard(c) def test_isdisjoint(self): cset1 = ComponentSet() cset2 = ComponentSet() self.assertTrue(cset1.isdisjoint(cset2)) self.assertTrue(cset2.isdisjoint(cset1)) v = variable() cset1.add(v) self.assertTrue(cset1.isdisjoint(cset2)) self.assertTrue(cset2.isdisjoint(cset1)) cset2.add(v) self.assertFalse(cset1.isdisjoint(cset2)) self.assertFalse(cset2.isdisjoint(cset1)) def test_misc_set_ops(self): v1 = variable() cset1 = ComponentSet([v1]) v2 = variable() cset2 = ComponentSet([v2]) cset3 = ComponentSet([v1, v2]) empty = ComponentSet([]) self.assertEqual(cset1 | cset2, cset3) self.assertEqual((cset1 | cset2) - cset3, empty) self.assertEqual(cset1 ^ cset2, cset3) self.assertEqual(cset1 ^ cset3, cset2) self.assertEqual(cset2 ^ cset3, cset1) self.assertEqual(cset1 & cset2, empty) self.assertEqual(cset1 & cset3, cset1) self.assertEqual(cset2 & cset3, cset2) def test_eq(self): cset1 = ComponentSet() self.assertEqual(cset1, set()) self.assertTrue(cset1 == set()) self.assertNotEqual(cset1, list()) self.assertFalse(cset1 == list()) self.assertNotEqual(cset1, tuple()) self.assertFalse(cset1 == tuple()) self.assertNotEqual(cset1, dict()) self.assertFalse(cset1 == dict()) cset1.update(self._components) self.assertNotEqual(cset1, set()) self.assertFalse(cset1 == set()) self.assertNotEqual(cset1, list()) self.assertFalse(cset1 == list()) self.assertNotEqual(cset1, tuple()) self.assertFalse(cset1 == tuple()) self.assertNotEqual(cset1, dict()) self.assertFalse(cset1 == dict()) self.assertTrue(cset1 == cset1) self.assertEqual(cset1, cset1) cset2 = ComponentSet(self._components) self.assertTrue(cset2 == cset1) self.assertFalse(cset2 != cset1) self.assertEqual(cset2, cset1) self.assertTrue(cset1 == cset2) self.assertFalse(cset1 != cset2) self.assertEqual(cset1, cset2) cset2.remove(self._components[0]) self.assertFalse(cset2 == cset1) self.assertTrue(cset2 != cset1) self.assertNotEqual(cset2, cset1) self.assertFalse(cset1 == cset2) self.assertTrue(cset1 != cset2) self.assertNotEqual(cset1, cset2)
class TestComponentMap(unittest.TestCase): _components = [(variable(), "v"), (variable_dict(), "vdict"), (variable_list(), "vlist"), (constraint(), "c"), (constraint_dict(), "cdict"), (constraint_list(), "clist"), (objective(), "o"), (objective_dict(), "odict"), (objective_list(), "olist"), (expression(), "e"), (expression_dict(), "edict"), (expression_list(), "elist"), (block(), "b"), (block_dict(), "bdict"), (block_list(), "blist"), (suffix(), "s")] def test_pickle(self): c = ComponentMap() self.assertEqual(len(c), 0) cup = pickle.loads( pickle.dumps(c)) self.assertIsNot(cup, c) self.assertEqual(len(cup), 0) v = variable() c[v] = 1.0 self.assertEqual(len(c), 1) self.assertEqual(c[v], 1.0) cup = pickle.loads( pickle.dumps(c)) vup = list(cup.keys())[0] self.assertIsNot(cup, c) self.assertIsNot(vup, v) self.assertEqual(len(cup), 1) self.assertEqual(cup[vup], 1) self.assertEqual(vup.parent, None) b = block() V = b.V = variable_list() b.V.append(v) b.c = c self.assertEqual(len(c), 1) self.assertEqual(c[v], 1.0) self.assertIs(v.parent, b.V) self.assertIs(V.parent, b) self.assertIs(b.parent, None) bup = pickle.loads( pickle.dumps(b)) Vup = bup.V vup = Vup[0] cup = bup.c self.assertIsNot(cup, c) self.assertIsNot(vup, v) self.assertIsNot(Vup, V) self.assertIsNot(bup, b) self.assertEqual(len(cup), 1) self.assertEqual(cup[vup], 1) self.assertIs(vup.parent, Vup) self.assertIs(Vup.parent, bup) self.assertIs(bup.parent, None) self.assertEqual(len(c), 1) self.assertEqual(c[v], 1) def test_init(self): cmap = ComponentMap() cmap = ComponentMap(self._components) with self.assertRaises(TypeError): cmap = ComponentMap(*self._components) def test_type(self): cmap = ComponentMap() self.assertTrue(isinstance(cmap, collections_Mapping)) self.assertTrue(isinstance(cmap, collections_MutableMapping)) self.assertTrue(issubclass(type(cmap), collections_Mapping)) self.assertTrue(issubclass(type(cmap), collections_MutableMapping)) def test_str(self): cmap = ComponentMap() self.assertEqual(str(cmap), "ComponentMap({})") cmap.update(self._components) str(cmap) def test_len(self): cmap = ComponentMap() self.assertEqual(len(cmap), 0) cmap.update(self._components) self.assertEqual(len(cmap), len(self._components)) cmap = ComponentMap(self._components) self.assertEqual(len(cmap), len(self._components)) self.assertTrue(len(self._components) > 0) def test_getsetdelitem(self): cmap = ComponentMap() for c, val in self._components: self.assertTrue(c not in cmap) for c, val in self._components: cmap[c] = val self.assertEqual(cmap[c], val) self.assertEqual(cmap.get(c), val) del cmap[c] with self.assertRaises(KeyError): cmap[c] with self.assertRaises(KeyError): del cmap[c] self.assertEqual(cmap.get(c), None) def test_iter(self): cmap = ComponentMap() self.assertEqual(list(iter(cmap)), []) cmap.update(self._components) ids_seen = set() for c in cmap: ids_seen.add(id(c)) self.assertEqual(ids_seen, set(id(c) for c,val in self._components)) def test_keys(self): cmap = ComponentMap(self._components) self.assertEqual(sorted(cmap.keys(), key=id), sorted(list(c for c,val in self._components), key=id)) def test_values(self): cmap = ComponentMap(self._components) self.assertEqual(sorted(cmap.values()), sorted(list(val for c,val in self._components))) def test_items(self): cmap = ComponentMap(self._components) for x in cmap.items(): self.assertEqual(type(x), tuple) self.assertEqual(len(x), 2) self.assertEqual(sorted(cmap.items(), key=lambda _x: (id(_x[0]), _x[1])), sorted(self._components, key=lambda _x: (id(_x[0]), _x[1]))) def test_update(self): cmap = ComponentMap() self.assertEqual(len(cmap), 0) cmap.update(self._components) self.assertEqual(len(cmap), len(self._components)) for c, val in self._components: self.assertEqual(cmap[c], val) def test_clear(self): cmap = ComponentMap() self.assertEqual(len(cmap), 0) cmap.update(self._components) self.assertEqual(len(cmap), len(self._components)) cmap.clear() self.assertEqual(len(cmap), 0) def test_setdefault(self): cmap = ComponentMap() for c,_ in self._components: with self.assertRaises(KeyError): cmap[c] self.assertTrue(c not in cmap) cmap.setdefault(c, []).append(1) self.assertEqual(cmap[c], [1]) del cmap[c] with self.assertRaises(KeyError): cmap[c] self.assertTrue(c not in cmap) cmap[c] = [] cmap.setdefault(c, []).append(1) self.assertEqual(cmap[c], [1]) def test_eq(self): cmap1 = ComponentMap() self.assertNotEqual(cmap1, set()) self.assertFalse(cmap1 == set()) self.assertNotEqual(cmap1, list()) self.assertFalse(cmap1 == list()) self.assertNotEqual(cmap1, tuple()) self.assertFalse(cmap1 == tuple()) self.assertEqual(cmap1, dict()) self.assertTrue(cmap1 == dict()) cmap1.update(self._components) self.assertNotEqual(cmap1, set()) self.assertFalse(cmap1 == set()) self.assertNotEqual(cmap1, list()) self.assertFalse(cmap1 == list()) self.assertNotEqual(cmap1, tuple()) self.assertFalse(cmap1 == tuple()) self.assertNotEqual(cmap1, dict()) self.assertFalse(cmap1 == dict()) self.assertTrue(cmap1 == cmap1) self.assertEqual(cmap1, cmap1) cmap2 = ComponentMap(self._components) self.assertTrue(cmap2 == cmap1) self.assertFalse(cmap2 != cmap1) self.assertEqual(cmap2, cmap1) self.assertTrue(cmap1 == cmap2) self.assertFalse(cmap1 != cmap2) self.assertEqual(cmap1, cmap2) del cmap2[self._components[0][0]] self.assertFalse(cmap2 == cmap1) self.assertTrue(cmap2 != cmap1) self.assertNotEqual(cmap2, cmap1) self.assertFalse(cmap1 == cmap2) self.assertTrue(cmap1 != cmap2) self.assertNotEqual(cmap1, cmap2)