def test_init(self):
v = variable()
self.assertTrue(v.parent is None)
self.assertEqual(v.ctype, Var)
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, Var)
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_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_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_init(self):
s = sos([])
self.assertTrue(s.parent is None)
self.assertEqual(s.ctype, SOSConstraint)
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, SOSConstraint)
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, SOSConstraint)
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_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 __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_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_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 __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=Binary) 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_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_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_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.
vlist = variable_list([variable(), variable()])
s = sos(vlist)
pyomo.core.kernel.pprint(s)
b = block()
b.s = s
pyomo.core.kernel.pprint(s)
pyomo.core.kernel.pprint(b)
m = block()
m.b = b
pyomo.core.kernel.pprint(s)
pyomo.core.kernel.pprint(b)
pyomo.core.kernel.pprint(m)
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_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_getname_relativeto(self):
m = block()
m.b = block()
m.b.v = variable()
self.assertEqual(m.b.v.getname(fully_qualified=True), 'b.v')
self.assertEqual(m.b.v.getname(fully_qualified=True, relative_to=m.b),
'v')
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):
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_potentially_variable(self):
v = variable()
self.assertEqual(v._potentially_variable(), True)
self.assertEqual(potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v._potentially_variable(), True)
self.assertEqual(potentially_variable(v), True)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v._potentially_variable(), True)
self.assertEqual(potentially_variable(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v._potentially_variable(), True)
self.assertEqual(potentially_variable(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v._potentially_variable(), True)
self.assertEqual(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 = self.v = variable_tuple(
variable(lb=0) for i in xrange(len(self.breakpoints)))
y_tuple = tuple(y)
# 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_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):
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):
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_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 setUpModule():
global _test_v
global _test_tri
global _test_values
if util.numpy_available and util.scipy_available:
_test_v = variable_list(variable(lb=i, ub=i + 1) for i in range(3))
_test_tri = util.generate_delaunay(_test_v, num=4)
_test_values = []
for _xi in _test_tri.points:
_test_values.append(sum(_xi))
_test_values = util.numpy.array(_test_values)
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_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_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)
