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)
