def __init__(self, *args, **kwds): super(piecewise_convex, self).__init__(*args, **kwds) breakpoints = self.breakpoints values = self.values self.c = constraint_list() for i in xrange(len(breakpoints) - 1): X0 = breakpoints[i] F_AT_X0 = values[i] dF_AT_X0 = (values[i+1] - F_AT_X0) / \ (breakpoints[i+1] - X0) const = F_AT_X0 - dF_AT_X0 * X0 con = linear_constraint((self.output, self.input), (-1, dF_AT_X0)) if self.bound == 'ub': con.lb = -const elif self.bound == 'lb': con.ub = -const else: assert self.bound == 'eq' con.rhs = -const self.c.append(con) # In order to enforce the same behavior as actual # piecewise constraints, we need to constrain the # input expression to be between first and last # breakpoint. This might be duplicating the # variable, but its not always the case, and there's # no guarantee that the input "variable" is not a # more general linear expression. self.c.append( linear_constraint(terms=[(self.input, 1)], lb=self.breakpoints[0], ub=self.breakpoints[-1]))
def __init__(self, *args, **kwds): super(piecewise_sos2, self).__init__(*args, **kwds) # create vars y_tuple = tuple(variable(lb=0) for i in xrange(len(self.breakpoints))) y = self.v = variable_tuple(y_tuple) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint(variables=y_tuple + (self.input, ), coefficients=self.breakpoints + (-1, ), rhs=0)) self.c.append( linear_constraint(variables=y_tuple + (self.output, ), coefficients=self.values + (-1, ))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append( linear_constraint(variables=y_tuple, coefficients=(1, ) * len(y), rhs=1)) self.s = sos2(y)
def __init__(self, *args, **kwds): super(piecewise_dcc, self).__init__(*args, **kwds) # create index sets polytopes = range(len(self.breakpoints) - 1) vertices = range(len(self.breakpoints)) def polytope_verts(p): return xrange(p, p + 2) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_dict( ((p, v), variable(lb=0)) for p in polytopes for v in vertices) y = self.v['y'] = variable_tuple( variable(domain=Binary) for p in polytopes) # create piecewise constraints self.c = constraint_list() self.c.append(linear_constraint( variables=tuple(lmbda[p,v] for p in polytopes for v in polytope_verts(p)) + \ (self.input,), coefficients=tuple(self.breakpoints[v] for p in polytopes for v in polytope_verts(p)) + \ (-1,), rhs=0)) self.c.append(linear_constraint( variables=tuple(lmbda[p,v] for p in polytopes for v in polytope_verts(p)) + \ (self.output,), coefficients=tuple(self.values[v] for p in polytopes for v in polytope_verts(p)) + (-1,))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 clist = [] for p in polytopes: variables = tuple(lmbda[p, v] for v in polytope_verts(p)) clist.append( linear_constraint(variables=variables + (y[p], ), coefficients=(1, ) * len(variables) + (-1, ), rhs=0)) self.c.append(constraint_tuple(clist)) self.c.append( linear_constraint(variables=tuple(y), coefficients=(1, ) * len(y), rhs=1))
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 __init__(self, *args, **kwds): super(piecewise_inc, self).__init__(*args, **kwds) # create indexers polytopes = range(len(self.breakpoints)-1) # create vars self.v = variable_dict() delta = self.v['delta'] = variable_tuple( variable() for p in polytopes) delta[0].ub = 1 delta[-1].lb = 0 delta_tuple = tuple(delta) y = self.v['y'] = variable_tuple( variable(domain_type=IntegerSet, lb=0, ub=1) for p in polytopes[:-1]) # create piecewise constraints self.c = constraint_list() self.c.append(linear_constraint( variables=(self.input,) + delta_tuple, coefficients=(-1,) + tuple(self.breakpoints[p+1] - \ self.breakpoints[p] for p in polytopes), rhs=-self.breakpoints[0])) self.c.append(linear_constraint( variables=(self.output,) + delta_tuple, coefficients=(-1,) + tuple(self.values[p+1] - \ self.values[p] for p in polytopes))) if self.bound == 'ub': self.c[-1].lb = -self.values[0] elif self.bound == 'lb': self.c[-1].ub = -self.values[0] else: assert self.bound == 'eq' self.c[-1].rhs = -self.values[0] clist1 = [] clist2 = [] for p in polytopes[:-1]: clist1.append(linear_constraint( variables=(delta[p+1], y[p]), coefficients=(1, -1), ub=0)) clist2.append(linear_constraint( variables=(y[p], delta[p]), coefficients=(1, -1), ub=0)) self.c.append(constraint_tuple(clist1)) self.c.append(constraint_tuple(clist2))
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)
def test_pprint(self): # Not really testing what the output is, just that # an error does not occur. The pprint functionality # is still in the early stages. v = variable() clist = constraint_list([constraint()]) s = suffix() s[v] = 1 s[clist] = None pprint(s) b = block() b.s = s pprint(s) pprint(b) m = block() m.b = b pprint(s) pprint(b) pprint(m) pprint({'a': 1, 'b': 2})
def test_pprint(self): import pyomo.kernel # Not really testing what the output is, just that # an error does not occur. The pprint functionality # is still in the early stages. v = variable() clist = constraint_list([constraint()]) s = suffix() s[v] = 1 s[clist] = None pyomo.kernel.pprint(s) b = block() b.s = s pyomo.kernel.pprint(s) pyomo.kernel.pprint(b) m = block() m.b = b pyomo.kernel.pprint(s) pyomo.kernel.pprint(b) pyomo.kernel.pprint(m) pyomo.kernel.pprint({'a': 1, 'b': 2})
def __init__(self, *args, **kwds): super(piecewise_nd_cc, self).__init__(*args, **kwds) ndim = len(self.input) nsimplices = len(self.triangulation.simplices) npoints = len(self.triangulation.points) pointsT = list(zip(*self.triangulation.points)) # create index objects dimensions = range(ndim) simplices = range(nsimplices) vertices = range(npoints) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple( variable(lb=0) for v in vertices) y = self.v['y'] = variable_tuple( variable(domain=Binary) for s in simplices) lmbda_tuple = tuple(lmbda) # create constraints self.c = constraint_list() clist = [] for d in dimensions: clist.append(linear_constraint( variables=lmbda_tuple + (self.input[d],), coefficients=tuple(pointsT[d]) + (-1,), rhs=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=lmbda_tuple + (self.output,), coefficients=tuple(self.values) + (-1,))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append(linear_constraint( variables=lmbda_tuple, coefficients=(1,)*len(lmbda_tuple), rhs=1)) # generate a map from vertex index to simplex index, # which avoids an n^2 lookup when generating the # constraint vertex_to_simplex = [[] for v in vertices] for s, simplex in enumerate(self.triangulation.simplices): for v in simplex: vertex_to_simplex[v].append(s) clist = [] for v in vertices: variables = tuple(y[s] for s in vertex_to_simplex[v]) clist.append(linear_constraint( variables=variables + (lmbda[v],), coefficients=(1,)*len(variables) + (-1,), lb=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=y, coefficients=(1,)*len(y), rhs=1))
def __init__(self, *args, **kwds): super(piecewise_dlog, self).__init__(*args, **kwds) breakpoints = self.breakpoints values = self.values if not is_positive_power_of_two(len(breakpoints) - 1): raise ValueError("The list of breakpoints must be " "of length (2^n)+1 for some positive " "integer n. Invalid length: %s" % (len(breakpoints))) # create branching schemes L = log2floor(len(breakpoints) - 1) assert 2**L == len(breakpoints) - 1 B_LEFT, B_RIGHT = self._branching_scheme(L) # create indexers polytopes = range(len(breakpoints) - 1) vertices = range(len(breakpoints)) def polytope_verts(p): return xrange(p, p + 2) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_dict(((p, v), variable(lb=0)) for p in polytopes for v in polytope_verts(p)) y = self.v['y'] = variable_tuple( variable(domain=Binary) for i in range(L)) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint( variables=(self.input, ) + tuple(lmbda[p, v] for p in polytopes for v in polytope_verts(p)), coefficients=(-1, ) + tuple(breakpoints[v] for p in polytopes for v in polytope_verts(p)), rhs=0)) self.c.append( linear_constraint( variables=(self.output, ) + tuple(lmbda[p, v] for p in polytopes for v in polytope_verts(p)), coefficients=(-1, ) + tuple(values[v] for p in polytopes for v in polytope_verts(p)))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append( linear_constraint(variables=tuple(lmbda.values()), coefficients=(1, ) * len(lmbda), rhs=1)) clist = [] for i in range(L): variables = tuple(lmbda[p, v] for p in B_LEFT[i] for v in polytope_verts(p)) clist.append( linear_constraint(variables=variables + (y[i], ), coefficients=(1, ) * len(variables) + (-1, ), ub=0)) self.c.append(constraint_tuple(clist)) del clist clist = [] for i in range(L): variables = tuple(lmbda[p, v] for p in B_RIGHT[i] for v in polytope_verts(p)) clist.append( linear_constraint(variables=variables + (y[i], ), coefficients=(1, ) * len(variables) + (1, ), ub=1)) self.c.append(constraint_tuple(clist))
def __init__(self, *args, **kwds): super(piecewise_mc, self).__init__(*args, **kwds) # create indexers polytopes = range(len(self.breakpoints) - 1) # create constants (using future division) # these might also be expressions if the breakpoints # or values lists contain mutable objects slopes = tuple((self.values[p+1] - self.values[p]) / \ (self.breakpoints[p+1] - self.breakpoints[p]) for p in polytopes) intercepts = tuple(self.values[p] - \ (slopes[p] * self.breakpoints[p]) for p in polytopes) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple(variable() for p in polytopes) lmbda_tuple = tuple(lmbda) y = self.v['y'] = variable_tuple( variable(domain=Binary) for p in polytopes) y_tuple = tuple(y) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint(variables=lmbda_tuple + (self.input, ), coefficients=(1, ) * len(lmbda) + (-1, ), rhs=0)) self.c.append( linear_constraint(variables=lmbda_tuple + y_tuple + (self.output, ), coefficients=slopes + intercepts + (-1, ))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 clist1 = [] clist2 = [] for p in polytopes: clist1.append( linear_constraint(variables=(y[p], lmbda[p]), coefficients=(self.breakpoints[p], -1), ub=0)) clist2.append( linear_constraint(variables=(lmbda[p], y[p]), coefficients=(1, -self.breakpoints[p + 1]), ub=0)) self.c.append(constraint_tuple(clist1)) self.c.append(constraint_tuple(clist2)) self.c.append( linear_constraint(variables=y_tuple, coefficients=(1, ) * len(y), rhs=1))
def __init__(self, *args, **kwds): super(piecewise_cc, self).__init__(*args, **kwds) # create index sets polytopes = range(len(self.breakpoints) - 1) vertices = range(len(self.breakpoints)) def vertex_polys(v): if v == 0: return [v] if v == len(self.breakpoints) - 1: return [v - 1] else: return [v - 1, v] # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple( variable(lb=0) for v in vertices) y = self.v['y'] = variable_tuple( variable(domain=Binary) for p in polytopes) lmbda_tuple = tuple(lmbda) # create piecewise constraints self.c = constraint_list() self.c.append( linear_constraint(variables=lmbda_tuple + (self.input, ), coefficients=self.breakpoints + (-1, ), rhs=0)) self.c.append( linear_constraint(variables=lmbda_tuple + (self.output, ), coefficients=self.values + (-1, ))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append( linear_constraint(variables=lmbda_tuple, coefficients=(1, ) * len(lmbda), rhs=1)) clist = [] for v in vertices: variables = tuple(y[p] for p in vertex_polys(v)) clist.append( linear_constraint(variables=variables + (lmbda[v], ), coefficients=(1, ) * len(variables) + (-1, ), lb=0)) self.c.append(constraint_tuple(clist)) self.c.append( linear_constraint(variables=tuple(y), coefficients=(1, ) * len(y), rhs=1))
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)
def __init__(self, *args, **kwds): super(piecewise_nd_cc, self).__init__(*args, **kwds) ndim = len(self.input) nsimplices = len(self.triangulation.simplices) npoints = len(self.triangulation.points) pointsT = list(zip(*self.triangulation.points)) # create index objects dimensions = range(ndim) simplices = range(nsimplices) vertices = range(npoints) # create vars self.v = variable_dict() lmbda = self.v['lambda'] = variable_tuple( variable(lb=0) for v in vertices) y = self.v['y'] = variable_tuple( variable(domain=Binary) for s in simplices) lmbda_tuple = tuple(lmbda) # create constraints self.c = constraint_list() clist = [] for d in dimensions: clist.append(linear_constraint( variables=lmbda_tuple + (self.input[d],), coefficients=tuple(pointsT[d]) + (-1,), rhs=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=lmbda_tuple + (self.output,), coefficients=tuple(self.values) + (-1,))) if self.bound == 'ub': self.c[-1].lb = 0 elif self.bound == 'lb': self.c[-1].ub = 0 else: assert self.bound == 'eq' self.c[-1].rhs = 0 self.c.append(linear_constraint( variables=lmbda_tuple, coefficients=(1,)*len(lmbda_tuple), rhs=1)) # generate a map from vertex index to simplex index, # which avoids an n^2 lookup when generating the # constraint vertex_to_simplex = [[] for v in vertices] for s, simplex in enumerate(self.triangulation.simplices): for v in simplex: vertex_to_simplex[v].append(s) clist = [] for v in vertices: variables = tuple(y[s] for s in vertex_to_simplex[v]) clist.append(linear_constraint( variables=variables + (lmbda[v],), coefficients=(1,)*len(variables) + (-1,), lb=0)) self.c.append(constraint_tuple(clist)) del clist self.c.append(linear_constraint( variables=y, coefficients=(1,)*len(y), rhs=1))
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)