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