def test_subset_properties(self):
vars1 = sym.Variables([x, y, z])
vars2 = sym.Variables([x, y])
self.assertFalse(vars1.IsSubsetOf(vars2))
self.assertFalse(vars1.IsStrictSubsetOf(vars2))
self.assertTrue(vars1.IsSupersetOf(vars2))
self.assertTrue(vars1.IsStrictSupersetOf(vars2))
def test_sos(self):
# Find a,b,c,d subject to
# a(0) + a(1)*x,
# b(0) + 2*b(1)*x + b(2)*x^2 is SOS,
# c(0)*x^2 + 2*c(1)*x*y + c(2)*y^2 is SOS,
# d(0)*x^2 is SOS.
# d(1)*x^2 is SOS.
# d(0) + d(1) = 1
prog = mp.MathematicalProgram()
x = prog.NewIndeterminates(1, "x")
self.assertEqual(prog.indeterminates_index()[x[0].get_id()], 0)
poly = prog.NewFreePolynomial(sym.Variables(x), 1)
(poly,
binding) = prog.NewSosPolynomial(indeterminates=sym.Variables(x),
degree=2)
y = prog.NewIndeterminates(1, "y")
self.assertEqual(prog.indeterminates_index()[y[0].get_id()], 1)
(poly,
binding) = prog.NewSosPolynomial(monomial_basis=(sym.Monomial(x[0]),
sym.Monomial(y[0])))
d = prog.NewContinuousVariables(2, "d")
prog.AddSosConstraint(d[0] * x.dot(x))
prog.AddSosConstraint(d[1] * x.dot(x), [sym.Monomial(x[0])])
prog.AddLinearEqualityConstraint(d[0] + d[1] == 1)
result = mp.Solve(prog)
self.assertTrue(result.is_success())
def test_constructor_expression_indeterminates(self):
e = a * x + b * y + c * z
p = sym.Polynomial(e, sym.Variables([x, y, z]))
decision_vars = sym.Variables([a, b, c])
indeterminates = sym.Variables([x, y, z])
self.assertEqual(p.indeterminates(), indeterminates)
self.assertEqual(p.decision_variables(), decision_vars)
def test_sub(self):
vars1 = sym.Variables([x, y])
vars2 = sym.Variables([y, z])
vars3 = vars1 - vars2 # [x]
self.assertEqual(vars3, sym.Variables([x]))
vars4 = vars1 - y # [x]
self.assertEqual(vars4, sym.Variables([x]))
def test_add(self):
vars1 = sym.Variables([x, y])
vars2 = sym.Variables([y, z])
vars3 = vars1 + vars2 # [x, y, z]
self.assertEqual(vars3.size(), 3)
vars4 = vars1 + z # [x, y, z]
self.assertEqual(vars4.size(), 3)
vars5 = x + vars1 # [x, y]
self.assertEqual(vars5.size(), 2)
def test_set_indeterminates(self):
e = a * x * x + b * y + c * z
indeterminates1 = sym.Variables([x, y, z])
p = sym.Polynomial(e, indeterminates1)
self.assertEqual(p.TotalDegree(), 2)
indeterminates2 = sym.Variables([a, b, c])
p.SetIndeterminates(indeterminates2)
self.assertEqual(p.TotalDegree(), 1)
def test_iterable(self):
vars = sym.Variables([x, y, z])
count = 0
for var in vars:
self.assertTrue(var in vars)
count = count + 1
self.assertEqual(count, 3)
def test_sos(self):
# Find a,b,c,d subject to
# a(0) + a(1)*x,
# b(0) + 2*b(1)*x + b(2)*x^2 is SOS,
# c(0)*x^2 + 2*c(1)*x*y + c(2)*y^2 is SOS,
# d(0)*x^2 is SOS.
# d(1)*x^2 is SOS.
prog = mp.MathematicalProgram()
x = prog.NewIndeterminates(1, "x")
poly = prog.NewFreePolynomial(sym.Variables(x), 1)
(poly,
binding) = prog.NewSosPolynomial(indeterminates=sym.Variables(x),
degree=2)
y = prog.NewIndeterminates(1, "y")
(poly,
binding) = prog.NewSosPolynomial(monomial_basis=(sym.Monomial(x[0]),
sym.Monomial(y[0])))
d = prog.NewContinuousVariables(2, "d")
prog.AddSosConstraint(d[0] * x.dot(x))
prog.AddSosConstraint(d[1] * x.dot(x), [sym.Monomial(x[0])])
result = mp.Solve(prog)
self.assertTrue(result.is_success())
# Test SubstituteSolution(sym.Expression)
with catch_drake_warnings(action='ignore'):
prog.Solve()
# TODO(eric.cousineau): Expose `SymbolicTestCase` so that other
# tests can use the assertion utilities.
self.assertEqual(
prog.SubstituteSolution(d[0] + d[1]).Evaluate(),
prog.GetSolution(d[0]) + prog.GetSolution(d[1]))
# Test SubstituteSolution(sym.Polynomial)
poly = d[0] * x.dot(x)
poly_sub_actual = prog.SubstituteSolution(
sym.Polynomial(poly, sym.Variables(x)))
poly_sub_expected = sym.Polynomial(
prog.SubstituteSolution(d[0]) * x.dot(x), sym.Variables(x))
# TODO(soonho): At present, these must be converted to `Expression`
# to compare, because as `Polynomial`s the comparison fails with
# `0*x(0)^2` != `0`, which indicates that simplification is not
# happening somewhere.
self.assertTrue(
poly_sub_actual.ToExpression().EqualTo(
poly_sub_expected.ToExpression()),
"{} != {}".format(poly_sub_actual, poly_sub_expected))
def test_sos(self):
# Find a,b,c,d subject to
# a(0) + a(1)*x,
# b(0) + 2*b(1)*x + b(2)*x^2 is SOS,
# c(0)*x^2 + 2*c(1)*x*y + c(2)*y^2 is SOS,
# d(0)*x^2 is SOS.
# d(1)*x^2 is SOS.
prog = mp.MathematicalProgram()
x = prog.NewIndeterminates(1, "x")
poly = prog.NewFreePolynomial(sym.Variables(x), 1)
(poly, binding) = prog.NewSosPolynomial(sym.Variables(x), 2)
y = prog.NewIndeterminates(1, "y")
(poly, binding) = prog.NewSosPolynomial(
(sym.Monomial(x[0]), sym.Monomial(y[0])))
d = prog.NewContinuousVariables(2, "d")
prog.AddSosConstraint(d[0] * x.dot(x))
prog.AddSosConstraint(d[1] * x.dot(x), [sym.Monomial(x[0])])
result = prog.Solve()
self.assertEqual(result, mp.SolutionResult.kSolutionFound)
def test_nonnegative_polynomial(self):
# Only check if the API works.
prog = mp.MathematicalProgram()
x = prog.NewIndeterminates(3, "x")
(poly1, gramian1) = prog.NewNonnegativePolynomial(
indeterminates=sym.Variables(x), degree=4,
type=mp.MathematicalProgram.NonnegativePolynomial.kSdsos)
self.assertIsInstance(poly1, sym.Polynomial)
self.assertIsInstance(gramian1, np.ndarray)
gramian2 = prog.NewSymmetricContinuousVariables(2)
poly2 = prog.NewNonnegativePolynomial(
gramian=gramian2,
monomial_basis=(sym.Monomial(x[0]), sym.Monomial(x[1])),
type=mp.MathematicalProgram.NonnegativePolynomial.kDsos)
self.assertIsInstance(gramian2, np.ndarray)
poly3, gramian3 = prog.NewNonnegativePolynomial(
monomial_basis=(sym.Monomial(x[0]), sym.Monomial(x[1])),
type=mp.MathematicalProgram.NonnegativePolynomial.kSos)
self.assertIsInstance(poly3, sym.Polynomial)
self.assertIsInstance(gramian3, np.ndarray)
def test_lt(self):
vars1 = sym.Variables([x, y])
vars2 = sym.Variables([x, y, z])
self.assertTrue(vars1 < vars2)
def test_to_string(self):
vars = sym.Variables()
vars.insert(x)
vars.insert(y)
vars.insert(z)
self.assertEqual(vars.to_string(), "{x, y, z}")
def test_eq(self):
vars1 = sym.Variables([x, y, z])
vars2 = sym.Variables([x, y])
self.assertFalse(vars1 == vars2)
def test_default_constructor(self):
vars = sym.Variables()
self.assertEqual(vars.size(), 0)
self.assertTrue(vars.empty())
def test_equalto(self):
vars1 = sym.Variables([x, y, z])
vars2 = sym.Variables([y, z])
vars3 = sym.Variables([x, y, z])
self.assertTrue(vars1.EqualTo(vars3))
self.assertFalse(vars1.EqualTo(vars2))
def test_erase1(self):
vars = sym.Variables([x, y, z])
count = vars.erase(x)
self.assertEqual(count, 1)
def test_intersect(self):
vars1 = sym.Variables([x, y, z])
vars2 = sym.Variables([y, w])
vars3 = sym.intersect(vars1, vars2) # = [y]
self.assertEqual(vars3, sym.Variables([y]))
def test_get_free_variables(self):
f = x > y
self.assertEqual(f.GetFreeVariables(), sym.Variables([x, y]))
def test_off_degree_monomial_basis(self):
vars = sym.Variables([x, y])
basis = sym.OddDegreeMonomialBasis(vars, 3)
self.assertEqual(basis.size, 6)
def test_repr(self):
vars = sym.Variables([x, y, z])
self.assertEqual(repr(vars), '<Variables "{x, y, z}">')
def test_to_string(self):
vars = sym.Variables([x, y, z])
self.assertEqual(vars.to_string(), "{x, y, z}")
self.assertEqual("{}".format(vars), "{x, y, z}")
def test_constructor_list(self):
vars = sym.Variables([x, y, z])
self.assertEqual(vars.size(), 3)
self.assertEqual(len(vars), 3)
def test_add_assignment(self):
vars = sym.Variables([x])
vars += y
self.assertEqual(vars.size(), 2)
vars += sym.Variables([x, z])
self.assertEqual(vars.size(), 3)
def test_erase2(self):
vars1 = sym.Variables([x, y, z])
vars2 = sym.Variables([w, z])
count = vars1.erase(vars2)
self.assertEqual(count, 1)
self.assertEqual(vars1.size(), 2)
def test_sub_assignment(self):
vars = sym.Variables([x, y, z])
vars -= y # = [x, z]
self.assertEqual(vars, sym.Variables([x, z]))
vars -= sym.Variables([x]) # = [z]
self.assertEqual(vars, sym.Variables([z]))
def test_include(self):
vars = sym.Variables([x, y, z])
self.assertTrue(vars.include(y))
self.assertTrue(z in vars)
def test_insert1(self):
vars = sym.Variables()
vars.insert(x)
self.assertEqual(vars.size(), 1)
def test_is_affine(self):
M = np.array([[a * a * x, 3 * x], [2 * x, 3 * a]])
self.assertTrue(sym.IsAffine(M, sym.Variables([x])))
self.assertFalse(sym.IsAffine(M))
def test_monomial_basis(self):
vars = sym.Variables([x, y, z])
basis1 = sym.MonomialBasis(vars, 3)
basis2 = sym.MonomialBasis([x, y, z], 3)
self.assertEqual(basis1.size, 20)
self.assertEqual(basis2.size, 20)
def test_insert2(self):
vars = sym.Variables([x])
vars.insert(sym.Variables([y, z]))
self.assertEqual(vars.size(), 3)
