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 __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 __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_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_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 __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_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_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_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_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)