def test_functions_with_float(self): v_x = 1.0 v_y = 1.0 self.assertEqual(sym.abs(v_x), np.abs(v_x)) self.assertEqual(sym.exp(v_x), np.exp(v_x)) self.assertEqual(sym.sqrt(v_x), np.sqrt(v_x)) self.assertEqual(sym.pow(v_x, v_y), v_x**v_y) self.assertEqual(sym.sin(v_x), np.sin(v_x)) self.assertEqual(sym.cos(v_x), np.cos(v_x)) self.assertEqual(sym.tan(v_x), np.tan(v_x)) self.assertEqual(sym.asin(v_x), np.arcsin(v_x)) self.assertEqual(sym.acos(v_x), np.arccos(v_x)) self.assertEqual(sym.atan(v_x), np.arctan(v_x)) self.assertEqual(sym.atan2(v_x, v_y), np.arctan2(v_x, v_y)) self.assertEqual(sym.sinh(v_x), np.sinh(v_x)) self.assertEqual(sym.cosh(v_x), np.cosh(v_x)) self.assertEqual(sym.tanh(v_x), np.tanh(v_x)) self.assertEqual(sym.min(v_x, v_y), min(v_x, v_y)) self.assertEqual(sym.max(v_x, v_y), max(v_x, v_y)) self.assertEqual(sym.ceil(v_x), np.ceil(v_x)) self.assertEqual(sym.floor(v_x), np.floor(v_x)) self.assertEqual( sym.if_then_else( sym.Expression(v_x) > sym.Expression(v_y), v_x, v_y), v_x if v_x > v_y else v_y)
def test_functions_with_float(self): # TODO(eric.cousineau): Use concrete values once vectorized methods are # supported. v_x = 1.0 v_y = 1.0 self.assertEqualStructure(sym.abs(v_x), np.abs(v_x)) self.assertNotEqualStructure(sym.abs(v_x), 0.5 * np.abs(v_x)) self._check_scalar(sym.abs(v_x), np.abs(v_x)) self._check_scalar(sym.abs(v_x), np.abs(v_x)) self._check_scalar(sym.exp(v_x), np.exp(v_x)) self._check_scalar(sym.sqrt(v_x), np.sqrt(v_x)) self._check_scalar(sym.pow(v_x, v_y), v_x**v_y) self._check_scalar(sym.sin(v_x), np.sin(v_x)) self._check_scalar(sym.cos(v_x), np.cos(v_x)) self._check_scalar(sym.tan(v_x), np.tan(v_x)) self._check_scalar(sym.asin(v_x), np.arcsin(v_x)) self._check_scalar(sym.acos(v_x), np.arccos(v_x)) self._check_scalar(sym.atan(v_x), np.arctan(v_x)) self._check_scalar(sym.atan2(v_x, v_y), np.arctan2(v_x, v_y)) self._check_scalar(sym.sinh(v_x), np.sinh(v_x)) self._check_scalar(sym.cosh(v_x), np.cosh(v_x)) self._check_scalar(sym.tanh(v_x), np.tanh(v_x)) self._check_scalar(sym.min(v_x, v_y), min(v_x, v_y)) self._check_scalar(sym.max(v_x, v_y), max(v_x, v_y)) self._check_scalar(sym.ceil(v_x), np.ceil(v_x)) self._check_scalar(sym.floor(v_x), np.floor(v_x)) self._check_scalar( sym.if_then_else( sym.Expression(v_x) > sym.Expression(v_y), v_x, v_y), v_x if v_x > v_y else v_y)
def test_constructor_maptype(self): m = { sym.Monomial(x): sym.Expression(3), sym.Monomial(y): sym.Expression(2) } # 3x + 2y p = sym.Polynomial(m) expected = 3 * x + 2 * y numpy_compare.assert_equal(p.ToExpression(), expected)
def test_constructor_maptype(self): m = { sym.Monomial(x): sym.Expression(3), sym.Monomial(y): sym.Expression(2) } # 3x + 2y p = sym.Polynomial(m) expected = 3 * x + 2 * y self.assertEqualStructure(p.ToExpression(), expected)
def _check_scalar(self, actual, expected): self.assertIsInstance(actual, sym.Expression) # Chain conversion to ensure equivalent treatment. if isinstance(expected, float) or isinstance(expected, int): expected = sym.Expression(expected) if isinstance(expected, sym.Expression): expected = str(expected) self.assertIsInstance(expected, str) self.assertEqual(str(actual), expected)
def test_module_level_solve_function_and_result_accessors(self): qp = TestQP() x_expected = np.array([1, 1]) result = mp.Solve(qp.prog) self.assertTrue(result.is_success()) self.assertTrue(np.allclose(result.get_x_val(), x_expected)) self.assertEqual(result.get_solution_result(), mp.SolutionResult.kSolutionFound) self.assertEqual(result.get_optimal_cost(), 3.0) self.assertTrue(result.get_solver_id().name()) self.assertTrue(np.allclose(result.GetSolution(), x_expected)) self.assertAlmostEqual(result.GetSolution(qp.x[0]), 1.0) self.assertTrue(np.allclose(result.GetSolution(qp.x), x_expected)) self.assertTrue(result.GetSolution(sym.Expression(qp.x[0])).EqualTo( result.GetSolution(qp.x[0]))) m = np.array([sym.Expression(qp.x[0]), sym.Expression(qp.x[1])]) self.assertTrue(result.GetSolution(m)[1, 0].EqualTo( result.GetSolution(qp.x[1])))
def test_comparison(self): p = sym.Polynomial() self.assertEqualStructure(p, p) self.assertIsInstance(p == p, sym.Formula) self.assertEqual(p == p, sym.Formula.True_()) self.assertTrue(p.EqualTo(p)) q = sym.Polynomial(sym.Expression(10)) self.assertNotEqualStructure(p, q) self.assertIsInstance(p != q, sym.Formula) self.assertEqual(p != q, sym.Formula.True_()) self.assertFalse(p.EqualTo(q))
def _best_effort_rich_compare(a, b, *, oper): try: return oper(a, b) except RuntimeError as e: if "not call `__bool__` / `__nonzero__` on `Formula`" in str(e): if isinstance(a, _sym_cls_list): return oper(a, _sym.Expression(b)) elif isinstance(b, _sym_cls_list): return oper(_sym.Expression(a), b) raise except DeprecationWarning as e: # N.B. This is only appears to be triggered for symbolic types. if _is_elementwise_comparison_error(e): if isinstance(a, np.generic): a = float(a) elif isinstance(b, np.generic): b = float(b) else: raise RuntimeError("Unexpected condition") return oper(a, b) raise
def test_functions_with_expression(self): e_x = sym.Expression(x) e_y = sym.Expression(y) self.assertEqual(str(sym.abs(e_x)), "abs(x)") self.assertEqual(str(sym.exp(e_x)), "exp(x)") self.assertEqual(str(sym.sqrt(e_x)), "sqrt(x)") self.assertEqual(str(sym.pow(e_x, e_y)), "pow(x, y)") self.assertEqual(str(sym.sin(e_x)), "sin(x)") self.assertEqual(str(sym.cos(e_x)), "cos(x)") self.assertEqual(str(sym.tan(e_x)), "tan(x)") self.assertEqual(str(sym.asin(e_x)), "asin(x)") self.assertEqual(str(sym.acos(e_x)), "acos(x)") self.assertEqual(str(sym.atan(e_x)), "atan(x)") self.assertEqual(str(sym.atan2(e_x, e_y)), "atan2(x, y)") self.assertEqual(str(sym.sinh(e_x)), "sinh(x)") self.assertEqual(str(sym.cosh(e_x)), "cosh(x)") self.assertEqual(str(sym.tanh(e_x)), "tanh(x)") self.assertEqual(str(sym.min(e_x, e_y)), "min(x, y)") self.assertEqual(str(sym.max(e_x, e_y)), "max(x, y)") self.assertEqual(str(sym.ceil(e_x)), "ceil(x)") self.assertEqual(str(sym.floor(e_x)), "floor(x)") self.assertEqual(str(sym.if_then_else(e_x > e_y, e_x, e_y)), "(if (x > y) then x else y)")
def test_non_method_jacobian(self): # Jacobian([x * cos(y), x * sin(y), x ** 2], [x, y]) returns # the following 3x2 matrix: # # = |cos(y) -x * sin(y)| # |sin(y) x * cos(y)| # | 2 * x 0| J = sym.Jacobian([x * sym.cos(y), x * sym.sin(y), x**2], [x, y]) numpy_compare.assert_equal(J[0, 0], sym.cos(y)) numpy_compare.assert_equal(J[1, 0], sym.sin(y)) numpy_compare.assert_equal(J[2, 0], 2 * x) numpy_compare.assert_equal(J[0, 1], -x * sym.sin(y)) numpy_compare.assert_equal(J[1, 1], x * sym.cos(y)) numpy_compare.assert_equal(J[2, 1], sym.Expression(0))
def test_functions_with_float(self): # TODO(eric.cousineau): Use concrete values once vectorized methods are # supported. v_x = 1.0 v_y = 1.0 # WARNING: If these math functions have `float` overloads that return # `float`, then `assertEqual`-like tests are meaningful (current state, # and before `math` overloads were introduced). # If these math functions implicitly cast `float` to `Expression`, then # `assertEqual` tests are meaningless, as it tests `__nonzero__` for # `Formula`, which will always be True. self.assertEqual(sym.abs(v_x), 0.5*np.abs(v_x)) self.assertNotEqual(str(sym.abs(v_x)), str(0.5*np.abs(v_x))) self._check_scalar(sym.abs(v_x), np.abs(v_x)) self._check_scalar(sym.abs(v_x), np.abs(v_x)) self._check_scalar(sym.exp(v_x), np.exp(v_x)) self._check_scalar(sym.sqrt(v_x), np.sqrt(v_x)) self._check_scalar(sym.pow(v_x, v_y), v_x ** v_y) self._check_scalar(sym.sin(v_x), np.sin(v_x)) self._check_scalar(sym.cos(v_x), np.cos(v_x)) self._check_scalar(sym.tan(v_x), np.tan(v_x)) self._check_scalar(sym.asin(v_x), np.arcsin(v_x)) self._check_scalar(sym.acos(v_x), np.arccos(v_x)) self._check_scalar(sym.atan(v_x), np.arctan(v_x)) self._check_scalar(sym.atan2(v_x, v_y), np.arctan2(v_x, v_y)) self._check_scalar(sym.sinh(v_x), np.sinh(v_x)) self._check_scalar(sym.cosh(v_x), np.cosh(v_x)) self._check_scalar(sym.tanh(v_x), np.tanh(v_x)) self._check_scalar(sym.min(v_x, v_y), min(v_x, v_y)) self._check_scalar(sym.max(v_x, v_y), max(v_x, v_y)) self._check_scalar(sym.ceil(v_x), np.ceil(v_x)) self._check_scalar(sym.floor(v_x), np.floor(v_x)) self._check_scalar( sym.if_then_else( sym.Expression(v_x) > sym.Expression(v_y), v_x, v_y), v_x if v_x > v_y else v_y)
def test_comparison(self): p = sym.Polynomial() numpy_compare.assert_equal(p, p) self.assertIsInstance(p == p, sym.Formula) self.assertEqual(p == p, sym.Formula.True_()) self.assertTrue(p.EqualTo(p)) q = sym.Polynomial(sym.Expression(10)) numpy_compare.assert_not_equal(p, q) self.assertIsInstance(p != q, sym.Formula) self.assertEqual(p != q, sym.Formula.True_()) self.assertFalse(p.EqualTo(q)) self.assertTrue( p.CoefficientsAlmostEqual(p + sym.Polynomial(1e-7), 1e-6)) self.assertTrue( p.CoefficientsAlmostEqual(p + sym.Polynomial(1e-7 * x), 1e-6)) self.assertFalse( p.CoefficientsAlmostEqual(p + sym.Polynomial(2e-6 * x), 1e-6))
def test(self): x = sym.Variable("x") a = sym.Variable("a") b = sym.Variable("b") f = [a + x, a*a*x*x] [W, alpha, w0] = sym.DecomposeLumpedParameters(f, [a, b]) numpy_compare.assert_equal(W, [[sym.Expression(1), sym.Expression(0)], [sym.Expression(0), x*x]]) numpy_compare.assert_equal(alpha, [sym.Expression(a), a*a]) numpy_compare.assert_equal(w0, [sym.Expression(x), sym.Expression(0)])
def test_add_product(self): p = sym.Polynomial() m = sym.Monomial(x) p.AddProduct(sym.Expression(3), m) # p += 3 * x self.assertEqualStructure(p.ToExpression(), 3 * x)
def test_default_constructor(self): p = sym.Polynomial() self.assertEqualStructure(p.ToExpression(), sym.Expression())
def test_default_constructor(self): p = sym.Polynomial() numpy_compare.assert_equal(p.ToExpression(), sym.Expression())
def test_add_product(self): p = sym.Polynomial() m = sym.Monomial(x) p.AddProduct(sym.Expression(3), m) # p += 3 * x numpy_compare.assert_equal(p.ToExpression(), 3 * x)
import pydrake.symbolic as sym from pydrake.test.algebra_test_util import ScalarAlgebra, VectorizedAlgebra from pydrake.util.containers import EqualToDict # TODO(eric.cousineau): Replace usages of `sym` math functions with the # overloads from `pydrake.math`. # Define global variables to make the tests less verbose. x = sym.Variable("x") y = sym.Variable("y") z = sym.Variable("z") w = sym.Variable("w") a = sym.Variable("a") b = sym.Variable("b") c = sym.Variable("c") e_x = sym.Expression(x) e_y = sym.Expression(y) TYPES = [ sym.Variable, sym.Expression, sym.Polynomial, sym.Monomial, ] RHS_TYPES = TYPES + [float, np.float64] class SymbolicTestCase(unittest.TestCase): def _check_operand_types(self, lhs, rhs): self.assertTrue(type(lhs) in TYPES, type(lhs))