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)