def test_init(self):
s = sos([])
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, ISOS)
self.assertEqual(len(s), 0)
self.assertEqual(s.variables, ())
self.assertEqual(s.weights, ())
self.assertEqual(s.level, 1)
vlist = tuple([variable(), variable()])
s = sos(vlist)
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, ISOS)
self.assertEqual(len(s), 2)
self.assertEqual(len(s.variables), 2)
for v in vlist:
self.assertTrue(v in s)
self.assertEqual(s.weights, tuple([1, 2]))
self.assertEqual(s.level, 1)
vlist = tuple([variable(), variable()])
s = sos(vlist, weights=[3.5, 4.5], level=2)
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, ISOS)
self.assertEqual(len(s), 2)
self.assertEqual(len(s.variables), 2)
for v in vlist:
self.assertTrue(v in s)
self.assertEqual(s.weights, tuple([3.5, 4.5]))
self.assertEqual(s.level, 2)
for i, (v, w) in enumerate(s.items()):
self.assertIs(v, vlist[i])
self.assertEqual(w, s.weights[i])
def test_init(self):
v = variable()
self.assertTrue(v.parent is None)
self.assertEqual(v.ctype, IVariable)
self.assertEqual(v.domain_type, RealSet)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, None)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
self.assertEqual(v.stale, True)
b = block()
b.v = v
self.assertTrue(v.parent is b)
del b.v
self.assertTrue(v.parent is None)
v = variable(domain_type=IntegerSet,
value=1,
lb=0,
ub=2,
fixed=True)
self.assertTrue(v.parent is None)
self.assertEqual(v.ctype, IVariable)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.lb, 0)
self.assertEqual(v.ub, 2)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1)
self.assertEqual(v.stale, True)
def test_init(self):
s = sos([])
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, ISOS)
self.assertEqual(len(s), 0)
self.assertEqual(s.variables, ())
self.assertEqual(s.weights, ())
self.assertEqual(s.level, 1)
vlist = tuple([variable(), variable()])
s = sos(vlist)
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, ISOS)
self.assertEqual(len(s), 2)
self.assertEqual(len(s.variables), 2)
for v in vlist:
self.assertTrue(v in s)
self.assertEqual(s.weights, tuple([1,2]))
self.assertEqual(s.level, 1)
vlist = tuple([variable(), variable()])
s = sos(vlist, weights=[3.5,4.5], level=2)
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, ISOS)
self.assertEqual(len(s), 2)
self.assertEqual(len(s.variables), 2)
for v in vlist:
self.assertTrue(v in s)
self.assertEqual(s.weights, tuple([3.5, 4.5]))
self.assertEqual(s.level, 2)
for i, (v,w) in enumerate(s.items()):
self.assertIs(v, vlist[i])
self.assertEqual(w, s.weights[i])
def test_bad_repn(self):
repn = list(transforms.registered_transforms.keys())[0]
self.assertTrue(repn in transforms.registered_transforms)
transforms.piecewise([1,2,3],
[1,2,1],
validate=False,
repn=repn)
repn = '_bad_repn_'
self.assertFalse(repn in transforms.registered_transforms)
with self.assertRaises(ValueError):
transforms.piecewise([1,2,3],
[1,2,1],
validate=False,
repn=repn)
with self.assertRaises(ValueError):
transforms.piecewise([1,2,3],
[1,2,1],
input=variable(lb=1,ub=3),
validate=True,
simplify=False,
repn=repn)
with self.assertRaises(ValueError):
transforms.piecewise([1,2,3],
[1,2,1],
input=variable(lb=1,ub=3),
validate=True,
simplify=True,
repn=repn)
def test_generate_delaunay(self):
vlist = variable_list()
vlist.append(variable(lb=0, ub=1))
vlist.append(variable(lb=1, ub=2))
vlist.append(variable(lb=2, ub=3))
if not (util.numpy_available and util.scipy_available):
with self.assertRaises(ImportError):
util.generate_delaunay(vlist)
else:
tri = util.generate_delaunay(vlist, num=2)
self.assertTrue(isinstance(tri, util.scipy.spatial.Delaunay))
self.assertEqual(len(tri.simplices), 6)
self.assertEqual(len(tri.points), 8)
tri = util.generate_delaunay(vlist, num=3)
self.assertTrue(isinstance(tri, util.scipy.spatial.Delaunay))
self.assertEqual(len(tri.simplices), 62)
self.assertEqual(len(tri.points), 27)
#
# Check cases where not all variables are bounded
#
vlist = variable_list()
vlist.append(variable(lb=0))
with self.assertRaises(ValueError):
util.generate_delaunay(vlist)
vlist = variable_list()
vlist.append(variable(ub=0))
with self.assertRaises(ValueError):
util.generate_delaunay(vlist)
def test_init(self):
v = variable()
self.assertTrue(v.parent is None)
self.assertEqual(v.ctype, IVariable)
self.assertEqual(v.domain_type, RealSet)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, None)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
self.assertEqual(v.stale, True)
b = block()
b.v = v
self.assertTrue(v.parent is b)
del b.v
self.assertTrue(v.parent is None)
v = variable(domain_type=IntegerSet, value=1, lb=0, ub=2, fixed=True)
self.assertTrue(v.parent is None)
self.assertEqual(v.ctype, IVariable)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.lb, 0)
self.assertEqual(v.ub, 2)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1)
self.assertEqual(v.stale, True)
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_build_linking_constraints(self):
c = _build_linking_constraints([], [])
self.assertIs(type(c), constraint_tuple)
self.assertEqual(len(c), 0)
v = [1, data_expression(), variable(), expression(expr=1.0)]
vaux = [variable(), variable(), variable(), variable()]
c = _build_linking_constraints(v, vaux)
self.assertIs(type(c), constraint_tuple)
self.assertEqual(len(c), 4)
self.assertIs(type(c[0]), linear_constraint)
self.assertEqual(c[0].rhs, 1)
self.assertEqual(len(list(c[0].terms)), 1)
self.assertIs(list(c[0].terms)[0][0], vaux[0])
self.assertEqual(list(c[0].terms)[0][1], 1)
self.assertIs(type(c[1]), linear_constraint)
self.assertIs(c[1].rhs, v[1])
self.assertEqual(len(list(c[1].terms)), 1)
self.assertIs(list(c[1].terms)[0][0], vaux[1])
self.assertEqual(list(c[1].terms)[0][1], 1)
self.assertIs(type(c[2]), linear_constraint)
self.assertEqual(c[2].rhs, 0)
self.assertEqual(len(list(c[2].terms)), 2)
self.assertIs(list(c[2].terms)[0][0], vaux[2])
self.assertEqual(list(c[2].terms)[0][1], 1)
self.assertIs(list(c[2].terms)[1][0], v[2])
self.assertEqual(list(c[2].terms)[1][1], -1)
self.assertIs(type(c[3]), constraint)
self.assertEqual(c[3].rhs, 0)
from pyomo.repn import generate_standard_repn
repn = generate_standard_repn(c[3].body)
self.assertEqual(len(repn.linear_vars), 1)
self.assertIs(repn.linear_vars[0], vaux[3])
self.assertEqual(repn.linear_coefs[0], 1)
self.assertEqual(repn.constant, -1)
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()
e = noclone(v**2)
pyomo.kernel.pprint(e)
pyomo.kernel.pprint(e, indent=1)
b = block()
b.e = expression(expr=e)
pyomo.kernel.pprint(e)
pyomo.kernel.pprint(b)
m = block()
m.b = b
pyomo.kernel.pprint(e)
pyomo.kernel.pprint(b)
pyomo.kernel.pprint(m)
# tests compatibility with _ToStringVisitor
pyomo.kernel.pprint(noclone(v) + 1)
pyomo.kernel.pprint(noclone(v + 1))
x = variable()
y = variable()
pyomo.kernel.pprint(y + x * noclone(noclone(x * y)))
pyomo.kernel.pprint(y + noclone(noclone(x * y)) * x)
def test_pickle(self):
v = variable()
e = noclone(v)
self.assertEqual(type(e), noclone)
self.assertIs(type(e.expr), variable)
eup = pickle.loads(pickle.dumps(e))
self.assertEqual(type(eup), noclone)
self.assertTrue(e is not eup)
self.assertIs(type(eup.expr), variable)
self.assertIs(type(e.expr), variable)
self.assertTrue(eup.expr is not e.expr)
del e
del v
v = variable(value=1)
b = block()
b.v = v
eraw = b.v + 1
b.e = 1 + noclone(eraw)
bup = pickle.loads(pickle.dumps(b))
self.assertTrue(isinstance(bup.e, NumericValue))
self.assertEqual(value(bup.e), 3.0)
b.v.value = 2
self.assertEqual(value(b.e), 4.0)
self.assertEqual(value(bup.e), 3.0)
bup.v.value = -1
self.assertEqual(value(b.e), 4.0)
self.assertEqual(value(bup.e), 1.0)
self.assertIs(b.v.parent, b)
self.assertIs(bup.v.parent, bup)
del b.v
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_clear(self):
x = variable()
y = variable()
s = suffix()
s[x] = 1.0
s[y] = None
self.assertEqual(len(s), 2)
s.clear()
self.assertEqual(len(s), 0)
def test_clear(self):
x = variable()
y = variable()
s = suffix()
s[x] = 1.0
s[y] = None
self.assertEqual(len(s), 2)
s.clear()
self.assertEqual(len(s), 0)
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_domain_type(self):
v = variable()
self.assertEqual(v.domain_type, RealSet)
self.assertEqual(v.is_continuous(), True)
self.assertEqual(v.is_discrete(), False)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), False)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, None)
self.assertEqual(v.bounds, (None, None))
v.domain_type = IntegerSet
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.is_continuous(), False)
self.assertEqual(v.is_discrete(), True)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), True)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, None)
self.assertEqual(v.bounds, (None, None))
v = variable(domain_type=IntegerSet, lb=0)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.is_continuous(), False)
self.assertEqual(v.is_discrete(), True)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), True)
self.assertEqual(v.lb, 0)
self.assertEqual(v.ub, None)
self.assertEqual(v.bounds, (0, None))
v = variable(domain_type=IntegerSet, ub=0)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.is_continuous(), False)
self.assertEqual(v.is_discrete(), True)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), True)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, 0)
self.assertEqual(v.bounds, (None, 0))
v.domain_type = RealSet
self.assertEqual(v.domain_type, RealSet)
self.assertEqual(v.is_continuous(), True)
self.assertEqual(v.is_discrete(), False)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), False)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, 0)
self.assertEqual(v.bounds, (None, 0))
with self.assertRaises(ValueError):
v.domain_type = BooleanSet
def test_domain_type(self):
v = variable()
self.assertEqual(v.domain_type, RealSet)
self.assertEqual(v.is_continuous(), True)
self.assertEqual(v.is_discrete(), False)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), False)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, None)
self.assertEqual(v.bounds, (None, None))
v.domain_type = IntegerSet
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.is_continuous(), False)
self.assertEqual(v.is_discrete(), True)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), True)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, None)
self.assertEqual(v.bounds, (None, None))
v = variable(domain_type=IntegerSet, lb=0)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.is_continuous(), False)
self.assertEqual(v.is_discrete(), True)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), True)
self.assertEqual(v.lb, 0)
self.assertEqual(v.ub, None)
self.assertEqual(v.bounds, (0, None))
v = variable(domain_type=IntegerSet, ub=0)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.is_continuous(), False)
self.assertEqual(v.is_discrete(), True)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), True)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, 0)
self.assertEqual(v.bounds, (None, 0))
v.domain_type = RealSet
self.assertEqual(v.domain_type, RealSet)
self.assertEqual(v.is_continuous(), True)
self.assertEqual(v.is_discrete(), False)
self.assertEqual(v.is_binary(), False)
self.assertEqual(v.is_integer(), False)
self.assertEqual(v.lb, None)
self.assertEqual(v.ub, 0)
self.assertEqual(v.bounds, (None, 0))
with self.assertRaises(ValueError):
v.domain_type = BooleanSet
def test_set_all_values(self):
x = variable()
y = variable()
s = suffix()
s[x] = 1.0
s[y] = None
self.assertEqual(s[x], 1.0)
self.assertEqual(s[y], None)
s.set_all_values(0)
self.assertEqual(s[x], 0)
self.assertEqual(s[y], 0)
def test_set_all_values(self):
x = variable()
y = variable()
s = suffix()
s[x] = 1.0
s[y] = None
self.assertEqual(s[x], 1.0)
self.assertEqual(s[y], None)
s.set_all_values(0)
self.assertEqual(s[x], 0)
self.assertEqual(s[y], 0)
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_existing_alias(self):
s = SymbolMap()
v1 = variable()
s.alias(v1, "v")
self.assertIs(s.aliases["v"](), v1)
v2 = variable()
with self.assertRaises(RuntimeError):
s.alias(v2, "v")
s.alias(v1, "A")
self.assertIs(s.aliases["v"](), v1)
self.assertIs(s.aliases["A"](), v1)
s.alias(v1, "A")
self.assertIs(s.aliases["v"](), v1)
self.assertIs(s.aliases["A"](), v1)
def test_existing_alias(self):
s = SymbolMap()
v1 = variable()
s.alias(v1, "v")
self.assertIs(s.aliases["v"](), v1)
v2 = variable()
with self.assertRaises(RuntimeError):
s.alias(v2, "v")
s.alias(v1, "A")
self.assertIs(s.aliases["v"](), v1)
self.assertIs(s.aliases["A"](), v1)
s.alias(v1, "A")
self.assertIs(s.aliases["v"](), v1)
self.assertIs(s.aliases["A"](), v1)
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_potentially_variable(self):
v = variable()
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
def test_call(self):
f = functional_value()
self.assertEqual(f(), None)
self.assertIs(f.fn, None)
f.fn = lambda: variable(value=1)
self.assertIsNot(f.fn, None)
# the function did not return numeric data
# (always causes an exception)
with self.assertRaises(TypeError):
f(exception=False)
with self.assertRaises(TypeError):
f(exception=True)
with self.assertRaises(TypeError):
f()
f.fn = lambda: None
self.assertIsNot(f.fn, None)
# the function did not return numeric data
# (always causes an exception)
with self.assertRaises(TypeError):
f(exception=False)
with self.assertRaises(TypeError):
f(exception=True)
with self.assertRaises(TypeError):
f()
def value_error():
raise ValueError()
f.fn = value_error
self.assertIsNot(f.fn, None)
self.assertEqual(f(exception=False), None)
with self.assertRaises(ValueError):
f(exception=True)
with self.assertRaises(ValueError):
f()
def test_pickle(self):
for key in transforms.registered_transforms:
v = variable(lb=1, ub=3)
p = transforms.piecewise([1, 2, 3], [1, 2, 1],
input=v,
validate=False,
repn=key)
self.assertEqual(p.parent, None)
self.assertEqual(p.input.expr.parent, None)
self.assertIs(p.input.expr, v)
pup = pickle.loads(pickle.dumps(p))
self.assertEqual(pup.parent, None)
self.assertEqual(pup.input.expr.parent, None)
self.assertIsNot(pup.input.expr, v)
b = block()
b.v = v
b.p = p
self.assertIs(p.parent, b)
self.assertEqual(p.input.expr.parent, b)
bup = pickle.loads(pickle.dumps(b))
pup = bup.p
self.assertIs(pup.parent, bup)
self.assertEqual(pup.input.expr.parent, bup)
self.assertIs(pup.input.expr, bup.v)
self.assertIsNot(pup.input.expr, b.v)
def test_fix_free(self):
v = variable()
self.assertEqual(v.value, None)
self.assertEqual(v.fixed, False)
v.fix(1)
self.assertEqual(v.value, 1)
self.assertEqual(v.fixed, True)
v.free()
self.assertEqual(v.value, 1)
self.assertEqual(v.fixed, False)
v.value = 0
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, False)
v.fix()
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, True)
with self.assertRaises(TypeError):
v.fix(1, 2)
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, True)
v.free()
with self.assertRaises(TypeError):
v.fix(1, 2)
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, False)
def test_pickle(self):
v = variable(lb=1,
ub=2,
domain_type=IntegerSet,
fixed=True)
self.assertEqual(v.lb, 1)
self.assertEqual(type(v.lb), int)
self.assertEqual(v.ub, 2)
self.assertEqual(type(v.ub), int)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.fixed, True)
self.assertEqual(v.parent, None)
vup = pickle.loads(
pickle.dumps(v))
self.assertEqual(vup.lb, 1)
self.assertEqual(type(vup.lb), int)
self.assertEqual(vup.ub, 2)
self.assertEqual(type(vup.ub), int)
self.assertEqual(vup.domain_type, IntegerSet)
self.assertEqual(vup.fixed, True)
self.assertEqual(vup.parent, None)
b = block()
b.v = v
self.assertIs(v.parent, b)
bup = pickle.loads(
pickle.dumps(b))
vup = bup.v
self.assertEqual(vup.lb, 1)
self.assertEqual(vup.ub, 2)
self.assertEqual(vup.domain_type, IntegerSet)
self.assertEqual(vup.fixed, True)
self.assertIs(vup.parent, bup)
def test_pickle(self):
s = suffix(direction=suffix.EXPORT,
datatype=suffix.FLOAT)
self.assertEqual(s.direction, suffix.EXPORT)
self.assertEqual(s.datatype, suffix.FLOAT)
self.assertEqual(s.parent, None)
sup = pickle.loads(
pickle.dumps(s))
self.assertEqual(sup.direction, suffix.EXPORT)
self.assertEqual(sup.datatype, suffix.FLOAT)
self.assertEqual(sup.parent, None)
b = block()
b.s = s
self.assertIs(s.parent, b)
bup = pickle.loads(
pickle.dumps(b))
sup = bup.s
self.assertEqual(sup.direction, suffix.EXPORT)
self.assertEqual(sup.datatype, suffix.FLOAT)
self.assertIs(sup.parent, bup)
b.v = variable(lb=1)
b.s[b.v] = 1.0
bup = pickle.loads(
pickle.dumps(b))
sup = bup.s
vup = bup.v
self.assertEqual(sup[vup], 1.0)
def test_potentially_variable(self):
v = variable()
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
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 test_call(self):
f = functional_value()
self.assertEqual(f(), None)
self.assertIs(f.fn, None)
f.fn = lambda: variable(value=1)
self.assertIsNot(f.fn, None)
# the function did not return numeric data
# (always causes an exception)
with self.assertRaises(TypeError):
f(exception=False)
with self.assertRaises(TypeError):
f(exception=True)
with self.assertRaises(TypeError):
f()
f.fn = lambda: None
self.assertIsNot(f.fn, None)
# the function did not return numeric data
# (always causes an exception)
with self.assertRaises(TypeError):
f(exception=False)
with self.assertRaises(TypeError):
f(exception=True)
with self.assertRaises(TypeError):
f()
def value_error():
raise ValueError()
f.fn = value_error
self.assertIsNot(f.fn, None)
self.assertEqual(f(exception=False), None)
with self.assertRaises(ValueError):
f(exception=True)
with self.assertRaises(ValueError):
f()
def test_bad_assignment(self):
e = self._ctype_factory(expr=1.0)
self.assertEqual(e.expr, 1.0)
v = variable()
with self.assertRaises(ValueError):
e.expr = v + 1
def test_polynomial_degree(self):
v = variable()
self.assertEqual(v.polynomial_degree(), 1)
v.fix(0)
self.assertEqual(v.polynomial_degree(), 0)
v.free()
self.assertEqual(v.polynomial_degree(), 1)
def test_bad_assignment(self):
e = self._ctype_factory(expr=1.0)
self.assertEqual(e.expr, 1.0)
v = variable()
with self.assertRaises(ValueError):
e.expr = v + 1
def test_pickle(self):
s = suffix(direction=suffix.EXPORT,
datatype=suffix.FLOAT)
self.assertEqual(s.direction, suffix.EXPORT)
self.assertEqual(s.datatype, suffix.FLOAT)
self.assertEqual(s.parent, None)
sup = pickle.loads(
pickle.dumps(s))
self.assertEqual(sup.direction, suffix.EXPORT)
self.assertEqual(sup.datatype, suffix.FLOAT)
self.assertEqual(sup.parent, None)
b = block()
b.s = s
self.assertIs(s.parent, b)
bup = pickle.loads(
pickle.dumps(b))
sup = bup.s
self.assertEqual(sup.direction, suffix.EXPORT)
self.assertEqual(sup.datatype, suffix.FLOAT)
self.assertIs(sup.parent, bup)
b.v = variable(lb=1)
b.s[b.v] = 1.0
bup = pickle.loads(
pickle.dumps(b))
sup = bup.s
vup = bup.v
self.assertEqual(sup[vup], 1.0)
def test_fix_free(self):
v = variable()
self.assertEqual(v.value, None)
self.assertEqual(v.fixed, False)
v.fix(1)
self.assertEqual(v.value, 1)
self.assertEqual(v.fixed, True)
v.free()
self.assertEqual(v.value, 1)
self.assertEqual(v.fixed, False)
v.value = 0
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, False)
v.fix()
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, True)
with self.assertRaises(TypeError):
v.fix(1,2)
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, True)
v.free()
with self.assertRaises(TypeError):
v.fix(1,2)
self.assertEqual(v.value, 0)
self.assertEqual(v.fixed, False)
def test_is_fixed(self):
v = variable()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
def test_pickle(self):
v = variable()
s = sos([v], weights=[1])
self.assertEqual(len(s), 1)
self.assertIs(s.variables[0], v)
self.assertTrue(v in s)
self.assertEqual(s.weights[0], 1)
self.assertEqual(s.level, 1)
self.assertEqual(s.parent, None)
sup = pickle.loads(pickle.dumps(s))
self.assertEqual(len(sup), 1)
self.assertIsNot(sup.variables[0], v)
self.assertFalse(v in sup)
self.assertEqual(sup.weights[0], 1)
self.assertEqual(sup.level, 1)
self.assertEqual(sup.parent, None)
b = block()
b.v = v
self.assertIs(v.parent, b)
b.s = s
self.assertIs(s.parent, b)
bup = pickle.loads(pickle.dumps(b))
sup = bup.s
self.assertEqual(len(sup), 1)
self.assertIs(sup.variables[0], bup.v)
self.assertTrue(bup.v in sup)
self.assertEqual(sup.weights[0], 1)
self.assertEqual(sup.level, 1)
self.assertIs(sup.parent, bup)
def test_pickle(self):
v = variable(lb=1, ub=2, domain_type=IntegerSet, fixed=True)
self.assertEqual(v.lb, 1)
self.assertEqual(type(v.lb), int)
self.assertEqual(v.ub, 2)
self.assertEqual(type(v.ub), int)
self.assertEqual(v.domain_type, IntegerSet)
self.assertEqual(v.fixed, True)
self.assertEqual(v.parent, None)
vup = pickle.loads(pickle.dumps(v))
self.assertEqual(vup.lb, 1)
self.assertEqual(type(vup.lb), int)
self.assertEqual(vup.ub, 2)
self.assertEqual(type(vup.ub), int)
self.assertEqual(vup.domain_type, IntegerSet)
self.assertEqual(vup.fixed, True)
self.assertEqual(vup.parent, None)
b = block()
b.v = v
self.assertIs(v.parent, b)
bup = pickle.loads(pickle.dumps(b))
vup = bup.v
self.assertEqual(vup.lb, 1)
self.assertEqual(vup.ub, 2)
self.assertEqual(vup.domain_type, IntegerSet)
self.assertEqual(vup.fixed, True)
self.assertIs(vup.parent, bup)
def test_pickle(self):
v = variable()
s = sos([v],weights=[1])
self.assertEqual(len(s), 1)
self.assertIs(s.variables[0], v)
self.assertTrue(v in s)
self.assertEqual(s.weights[0], 1)
self.assertEqual(s.level, 1)
self.assertEqual(s.parent, None)
sup = pickle.loads(
pickle.dumps(s))
self.assertEqual(len(sup), 1)
self.assertIsNot(sup.variables[0], v)
self.assertFalse(v in sup)
self.assertEqual(sup.weights[0], 1)
self.assertEqual(sup.level, 1)
self.assertEqual(sup.parent, None)
b = block()
b.v = v
self.assertIs(v.parent, b)
b.s = s
self.assertIs(s.parent, b)
bup = pickle.loads(
pickle.dumps(b))
sup = bup.s
self.assertEqual(len(sup), 1)
self.assertIs(sup.variables[0], bup.v)
self.assertTrue(bup.v in sup)
self.assertEqual(sup.weights[0], 1)
self.assertEqual(sup.level, 1)
self.assertIs(sup.parent, bup)
def test_polynomial_degree(self):
v = variable()
self.assertEqual(v.polynomial_degree(), 1)
v.fix(0)
self.assertEqual(v.polynomial_degree(), 0)
v.free()
self.assertEqual(v.polynomial_degree(), 1)
def test_is_fixed(self):
v = variable()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
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.
vlist = variable_list([variable(), variable()])
s = sos(vlist)
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)
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.
vlist = variable_list([variable(), variable()])
s = sos(vlist)
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)
def test_active(self):
v = variable()
b = block()
self.assertEqual(b.active, True)
b.deactivate()
self.assertEqual(b.active, False)
b.v = v
self.assertEqual(b.active, False)
b.activate()
self.assertEqual(b.active, True)
def test_clear_value(self):
x = variable()
s = suffix()
s[x] = 1.0
self.assertEqual(len(s), 1)
s.clear_value(x)
self.assertEqual(len(s), 0)
s.clear_value(x)
def test_clear_value(self):
x = variable()
s = suffix()
s[x] = 1.0
self.assertEqual(len(s), 1)
s.clear_value(x)
self.assertEqual(len(s), 0)
s.clear_value(x)
def test_active(self):
v = variable()
b = block()
self.assertEqual(b.active, True)
b.deactivate()
self.assertEqual(b.active, False)
b.v = v
self.assertEqual(b.active, False)
b.activate()
self.assertEqual(b.active, True)
def test_del(self):
x = variable()
s = suffix()
s[x] = 1.0
self.assertEqual(len(s), 1)
del s[x]
self.assertEqual(len(s), 0)
with self.assertRaises(KeyError):
del s[x]
def test_is_fixed(self):
v = variable()
e = noclone(v + 1)
self.assertEqual(e.is_fixed(), False)
self.assertEqual(is_fixed(e), False)
v.fix()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e = noclone(parameter())
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
def testis_potentially_variable(self):
e = noclone(variable())
self.assertEqual(e.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(e), True)
e = noclone(parameter())
self.assertEqual(e.is_potentially_variable(), False)
self.assertEqual(is_potentially_variable(e), False)
e = noclone(expression())
self.assertEqual(e.is_potentially_variable(), True)
self.assertEqual(is_potentially_variable(e), True)
e = noclone(data_expression())
self.assertEqual(e.is_potentially_variable(), False)
self.assertEqual(is_potentially_variable(e), False)
def as_domain(cls, r, x):
"""Builds a conic domain. Input arguments take the
same form as those of the conic constraint, but in
place of each variable, one can optionally supply a
constant, linear expression, or None.
Returns
-------
block
A block object with the core conic constraint
(block.q) expressed using auxiliary variables
(block.r, block.x) linked to the input arguments
through auxiliary constraints (block.c).
"""
b = block()
b.r = variable(lb=0)
b.x = variable_tuple(
[variable() for i in range(len(x))])
b.c = _build_linking_constraints([r] + list(x),
[b.r] + list(b.x))
b.q = cls(r=b.r, x=b.x)
return b
def test_call(self):
v = variable()
self.assertEqual(v.value, None)
with self.assertRaises(ValueError):
v()
with self.assertRaises(ValueError):
v(exception=True)
self.assertEqual(v(exception=False), None)
v.value = 2
self.assertEqual(v.value, 2)
self.assertEqual(v(), 2)
self.assertEqual(v(exception=True), 2)
self.assertEqual(v(exception=False), 2)
def as_domain(cls, r, x1, x2):
"""Builds a conic domain. Input arguments take the
same form as those of the conic constraint, but in
place of each variable, one can optionally supply a
constant, linear expression, or None.
Returns
-------
block
A block object with the core conic constraint
(block.q) expressed using auxiliary variables
(block.r, block.x1, block.x2) linked to the
input arguments through auxiliary constraints
(block.c).
"""
b = block()
b.r = variable(lb=0)
b.x1 = variable()
b.x2 = variable(ub=0)
b.c = _build_linking_constraints([r,x1,x2],
[b.r,b.x1,b.x2])
b.q = cls(r=b.r, x1=b.x1, x2=b.x2)
return b
def test_is_constant(self):
v = variable()
e = noclone(v)
self.assertEqual(e.is_constant(), False)
self.assertEqual(is_constant(e), False)
v.fix(1)
self.assertEqual(e.is_constant(), False)
self.assertEqual(is_constant(e), False)
p = parameter()
e = noclone(p)
self.assertEqual(p.is_constant(), False)
self.assertEqual(is_constant(p), False)
self.assertEqual(is_constant(noclone(1)), True)
def test_init_NumericValue(self):
v = variable()
p = parameter()
e = expression()
d = data_expression()
o = objective()
for obj in (v, v+1, v**2,
p, p+1, p**2,
e, e+1, e**2,
d, d+1, d**2,
o, o+1, o**2):
self.assertTrue(isinstance(noclone(obj), NumericValue))
self.assertTrue(isinstance(noclone(obj), IIdentityExpression))
self.assertTrue(isinstance(noclone(obj), noclone))
self.assertIs(noclone(obj).expr, obj)
def test_pickle(self):
v = variable()
e = noclone(v)
self.assertEqual(type(e), noclone)
self.assertIs(type(e.expr), variable)
eup = pickle.loads(
pickle.dumps(e))
self.assertEqual(type(eup), noclone)
self.assertTrue(e is not eup)
self.assertIs(type(eup.expr), variable)
self.assertIs(type(e.expr), variable)
self.assertTrue(eup.expr is not e.expr)
del e
del v
v = variable(value=1)
b = block()
b.v = v
eraw = b.v + 1
b.e = 1 + noclone(eraw)
bup = pickle.loads(
pickle.dumps(b))
self.assertTrue(isinstance(bup.e, NumericValue))
self.assertEqual(value(bup.e), 3.0)
b.v.value = 2
self.assertEqual(value(b.e), 4.0)
self.assertEqual(value(bup.e), 3.0)
bup.v.value = -1
self.assertEqual(value(b.e), 4.0)
self.assertEqual(value(bup.e), 1.0)
self.assertIs(b.v.parent, b)
self.assertIs(bup.v.parent, bup)
del b.v
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()
pyomo.kernel.pprint(v)
b = block()
b.v = v
pyomo.kernel.pprint(v)
pyomo.kernel.pprint(b)
m = block()
m.b = b
pyomo.kernel.pprint(v)
pyomo.kernel.pprint(b)
pyomo.kernel.pprint(m)
def test_bad_bounds(self):
v = variable()
self.assertIs(v.lb, None)
self.assertIs(v.ub, None)
v.lb = 1.0
v.ub = 1.0
self.assertEqual(v.lb, 1.0)
self.assertEqual(v.ub, 1.0)
with self.assertRaises(ValueError):
v.lb = "string"
self.assertEqual(v.lb, 1.0)
self.assertEqual(v.ub, 1.0)
with self.assertRaises(ValueError):
v.ub = "string"
self.assertEqual(v.lb, 1.0)
self.assertEqual(v.ub, 1.0)
