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_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_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_variable(self):
self.assertEqual(str(sym.abs(x)), "abs(x)")
self.assertEqual(str(sym.exp(x)), "exp(x)")
self.assertEqual(str(sym.sqrt(x)), "sqrt(x)")
self.assertEqual(str(sym.pow(x, y)), "pow(x, y)")
self.assertEqual(str(sym.sin(x)), "sin(x)")
self.assertEqual(str(sym.cos(x)), "cos(x)")
self.assertEqual(str(sym.tan(x)), "tan(x)")
self.assertEqual(str(sym.asin(x)), "asin(x)")
self.assertEqual(str(sym.acos(x)), "acos(x)")
self.assertEqual(str(sym.atan(x)), "atan(x)")
self.assertEqual(str(sym.atan2(x, y)), "atan2(x, y)")
self.assertEqual(str(sym.sinh(x)), "sinh(x)")
self.assertEqual(str(sym.cosh(x)), "cosh(x)")
self.assertEqual(str(sym.tanh(x)), "tanh(x)")
self.assertEqual(str(sym.min(x, y)), "min(x, y)")
self.assertEqual(str(sym.max(x, y)), "max(x, y)")
self.assertEqual(str(sym.ceil(x)), "ceil(x)")
self.assertEqual(str(sym.floor(x)), "floor(x)")
self.assertEqual(str(sym.if_then_else(x > y, x, y)),
"(if (x > y) then x else y)")
def test_functions_with_variable(self):
self.assertEqual(str(sym.abs(x)), "abs(x)")
self.assertEqual(str(sym.exp(x)), "exp(x)")
self.assertEqual(str(sym.sqrt(x)), "sqrt(x)")
self.assertEqual(str(sym.pow(x, y)), "pow(x, y)")
self.assertEqual(str(sym.sin(x)), "sin(x)")
self.assertEqual(str(sym.cos(x)), "cos(x)")
self.assertEqual(str(sym.tan(x)), "tan(x)")
self.assertEqual(str(sym.asin(x)), "asin(x)")
self.assertEqual(str(sym.acos(x)), "acos(x)")
self.assertEqual(str(sym.atan(x)), "atan(x)")
self.assertEqual(str(sym.atan2(x, y)), "atan2(x, y)")
self.assertEqual(str(sym.sinh(x)), "sinh(x)")
self.assertEqual(str(sym.cosh(x)), "cosh(x)")
self.assertEqual(str(sym.tanh(x)), "tanh(x)")
self.assertEqual(str(sym.min(x, y)), "min(x, y)")
self.assertEqual(str(sym.max(x, y)), "max(x, y)")
self.assertEqual(str(sym.ceil(x)), "ceil(x)")
self.assertEqual(str(sym.floor(x)), "floor(x)")
self.assertEqual(str(sym.if_then_else(x > y, x, y)),
"(if (x > y) then x else y)")
def test_functions_with_expression(self):
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_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 _check_algebra(self, algebra):
xv = algebra.to_algebra(x)
yv = algebra.to_algebra(y)
zv = algebra.to_algebra(z)
wv = algebra.to_algebra(w)
av = algebra.to_algebra(a)
bv = algebra.to_algebra(b)
cv = algebra.to_algebra(c)
e_xv = algebra.to_algebra(e_x)
e_yv = algebra.to_algebra(e_y)
# Addition.
algebra.check_value(e_xv + e_yv, "(x + y)")
algebra.check_value(e_xv + yv, "(x + y)")
algebra.check_value(e_xv + 1, "(1 + x)")
algebra.check_value(xv + e_yv, "(x + y)")
algebra.check_value(1 + e_xv, "(1 + x)")
# - In place.
e = copy(xv)
e += e_yv
algebra.check_value(e, "(x + y)")
e += zv
algebra.check_value(e, "(x + y + z)")
e += 1
algebra.check_value(e, "(1 + x + y + z)")
# Subtraction.
algebra.check_value((e_xv - e_yv), "(x - y)")
algebra.check_value((e_xv - yv), "(x - y)")
algebra.check_value((e_xv - 1), "(-1 + x)")
algebra.check_value((xv - e_yv), "(x - y)")
algebra.check_value((1 - e_xv), "(1 - x)")
# - In place.
e = copy(xv)
e -= e_yv
algebra.check_value(e, (x - y))
e -= zv
algebra.check_value(e, (x - y - z))
e -= 1
algebra.check_value(e, (x - y - z - 1))
# Multiplication.
algebra.check_value((e_xv * e_yv), "(x * y)")
algebra.check_value((e_xv * yv), "(x * y)")
algebra.check_value((e_xv * 1), "x")
algebra.check_value((xv * e_yv), "(x * y)")
algebra.check_value((1 * e_xv), "x")
# - In place.
e = copy(xv)
e *= e_yv
algebra.check_value(e, "(x * y)")
e *= zv
algebra.check_value(e, "(x * y * z)")
e *= 1
algebra.check_value(e, "(x * y * z)")
# Division
algebra.check_value((e_xv / e_yv), (x / y))
algebra.check_value((e_xv / yv), (x / y))
algebra.check_value((e_xv / 1), "x")
algebra.check_value((xv / e_yv), (x / y))
algebra.check_value((1 / e_xv), (1 / x))
# - In place.
e = copy(xv)
e /= e_yv
algebra.check_value(e, (x / y))
e /= zv
algebra.check_value(e, (x / y / z))
e /= 1
algebra.check_value(e, ((x / y) / z))
# Unary
algebra.check_value((+e_xv), "x")
algebra.check_value((-e_xv), "(-1 * x)")
# Math functions.
algebra.check_value((algebra.abs(e_xv)), "abs(x)")
algebra.check_value((algebra.exp(e_xv)), "exp(x)")
algebra.check_value((algebra.sqrt(e_xv)), "sqrt(x)")
algebra.check_value((algebra.pow(e_xv, e_yv)), "pow(x, y)")
algebra.check_value((algebra.sin(e_xv)), "sin(x)")
algebra.check_value((algebra.cos(e_xv)), "cos(x)")
algebra.check_value((algebra.tan(e_xv)), "tan(x)")
algebra.check_value((algebra.arcsin(e_xv)), "asin(x)")
algebra.check_value((algebra.arccos(e_xv)), "acos(x)")
algebra.check_value((algebra.arctan2(e_xv, e_yv)), "atan2(x, y)")
algebra.check_value((algebra.sinh(e_xv)), "sinh(x)")
algebra.check_value((algebra.cosh(e_xv)), "cosh(x)")
algebra.check_value((algebra.tanh(e_xv)), "tanh(x)")
algebra.check_value((algebra.ceil(e_xv)), "ceil(x)")
algebra.check_value((algebra.floor(e_xv)), "floor(x)")
if isinstance(algebra, ScalarAlgebra):
# TODO(eric.cousineau): Uncomment these lines if we can teach numpy
# that reduction is not just selection.
algebra.check_value((algebra.min(e_xv, e_yv)), "min(x, y)")
algebra.check_value((algebra.max(e_xv, e_yv)), "max(x, y)")
# TODO(eric.cousineau): Add broadcasting functions for these
# operations.
algebra.check_value((sym.atan(e_xv)), "atan(x)")
algebra.check_value((sym.if_then_else(e_xv > e_yv, e_xv, e_yv)),
"(if (x > y) then x else y)")
return xv, e_xv
def _check_algebra(self, algebra):
xv = algebra.to_algebra(x)
yv = algebra.to_algebra(y)
zv = algebra.to_algebra(z)
wv = algebra.to_algebra(w)
av = algebra.to_algebra(a)
bv = algebra.to_algebra(b)
cv = algebra.to_algebra(c)
e_xv = algebra.to_algebra(e_x)
e_yv = algebra.to_algebra(e_y)
# Addition.
algebra.check_value(e_xv + e_yv, "(x + y)")
algebra.check_value(e_xv + yv, "(x + y)")
algebra.check_value(e_xv + 1, "(1 + x)")
algebra.check_value(xv + e_yv, "(x + y)")
algebra.check_value(1 + e_xv, "(1 + x)")
# - In place.
e = copy.copy(xv)
e += e_yv
algebra.check_value(e, "(x + y)")
e += zv
algebra.check_value(e, "(x + y + z)")
e += 1
algebra.check_value(e, "(1 + x + y + z)")
# Subtraction.
algebra.check_value((e_xv - e_yv), "(x - y)")
algebra.check_value((e_xv - yv), "(x - y)")
algebra.check_value((e_xv - 1), "(-1 + x)")
algebra.check_value((xv - e_yv), "(x - y)")
algebra.check_value((1 - e_xv), "(1 - x)")
# - In place.
e = copy.copy(xv)
e -= e_yv
algebra.check_value(e, (x - y))
e -= zv
algebra.check_value(e, (x - y - z))
e -= 1
algebra.check_value(e, (x - y - z - 1))
# Multiplication.
algebra.check_value((e_xv * e_yv), "(x * y)")
algebra.check_value((e_xv * yv), "(x * y)")
algebra.check_value((e_xv * 1), "x")
algebra.check_value((xv * e_yv), "(x * y)")
algebra.check_value((1 * e_xv), "x")
# - In place.
e = copy.copy(xv)
e *= e_yv
algebra.check_value(e, "(x * y)")
e *= zv
algebra.check_value(e, "(x * y * z)")
e *= 1
algebra.check_value(e, "(x * y * z)")
# Division
algebra.check_value((e_xv / e_yv), (x / y))
algebra.check_value((e_xv / yv), (x / y))
algebra.check_value((e_xv / 1), "x")
algebra.check_value((xv / e_yv), (x / y))
algebra.check_value((1 / e_xv), (1 / x))
# - In place.
e = copy.copy(xv)
e /= e_yv
algebra.check_value(e, (x / y))
e /= zv
algebra.check_value(e, (x / y / z))
e /= 1
algebra.check_value(e, ((x / y) / z))
# Unary
algebra.check_value((+e_xv), "x")
algebra.check_value((-e_xv), "(-1 * x)")
# Math functions.
algebra.check_value((algebra.abs(e_xv)), "abs(x)")
algebra.check_value((algebra.exp(e_xv)), "exp(x)")
algebra.check_value((algebra.sqrt(e_xv)), "sqrt(x)")
algebra.check_value((algebra.pow(e_xv, e_yv)), "pow(x, y)")
algebra.check_value((algebra.sin(e_xv)), "sin(x)")
algebra.check_value((algebra.cos(e_xv)), "cos(x)")
algebra.check_value((algebra.tan(e_xv)), "tan(x)")
algebra.check_value((algebra.arcsin(e_xv)), "asin(x)")
algebra.check_value((algebra.arccos(e_xv)), "acos(x)")
algebra.check_value((algebra.arctan2(e_xv, e_yv)), "atan2(x, y)")
algebra.check_value((algebra.sinh(e_xv)), "sinh(x)")
algebra.check_value((algebra.cosh(e_xv)), "cosh(x)")
algebra.check_value((algebra.tanh(e_xv)), "tanh(x)")
algebra.check_value((algebra.ceil(e_xv)), "ceil(x)")
algebra.check_value((algebra.floor(e_xv)), "floor(x)")
if isinstance(algebra, ScalarAlgebra):
# TODO(eric.cousineau): Uncomment these lines if we can teach numpy
# that reduction is not just selection.
algebra.check_value((algebra.min(e_xv, e_yv)), "min(x, y)")
algebra.check_value((algebra.max(e_xv, e_yv)), "max(x, y)")
# TODO(eric.cousineau): Add broadcasting functions for these
# operations.
algebra.check_value((sym.atan(e_xv)), "atan(x)")
algebra.check_value((sym.if_then_else(e_xv > e_yv, e_xv, e_yv)),
"(if (x > y) then x else y)")
return xv, e_xv
def _check_algebra(self, algebra):
xv = algebra.to_algebra(x)
yv = algebra.to_algebra(y)
zv = algebra.to_algebra(z)
wv = algebra.to_algebra(w)
av = algebra.to_algebra(a)
bv = algebra.to_algebra(b)
cv = algebra.to_algebra(c)
e_xv = algebra.to_algebra(e_x)
e_yv = algebra.to_algebra(e_y)
# Addition.
numpy_compare.assert_equal(e_xv + e_yv, "(x + y)")
numpy_compare.assert_equal(e_xv + yv, "(x + y)")
numpy_compare.assert_equal(e_xv + 1, "(1 + x)")
numpy_compare.assert_equal(xv + e_yv, "(x + y)")
numpy_compare.assert_equal(1 + e_xv, "(1 + x)")
# - In place.
e = copy.copy(xv)
e += e_yv
numpy_compare.assert_equal(e, "(x + y)")
e += zv
numpy_compare.assert_equal(e, "(x + y + z)")
e += 1
numpy_compare.assert_equal(e, "(1 + x + y + z)")
# Subtraction.
numpy_compare.assert_equal(e_xv - e_yv, "(x - y)")
numpy_compare.assert_equal(e_xv - yv, "(x - y)")
numpy_compare.assert_equal(e_xv - 1, "(-1 + x)")
numpy_compare.assert_equal(xv - e_yv, "(x - y)")
numpy_compare.assert_equal(1 - e_xv, "(1 - x)")
# - In place.
e = copy.copy(xv)
e -= e_yv
numpy_compare.assert_equal(e, (x - y))
e -= zv
numpy_compare.assert_equal(e, (x - y - z))
e -= 1
numpy_compare.assert_equal(e, (x - y - z - 1))
# Multiplication.
numpy_compare.assert_equal(e_xv * e_yv, "(x * y)")
numpy_compare.assert_equal(e_xv * yv, "(x * y)")
numpy_compare.assert_equal(e_xv * 1, "x")
numpy_compare.assert_equal(xv * e_yv, "(x * y)")
numpy_compare.assert_equal(1 * e_xv, "x")
# - In place.
e = copy.copy(xv)
e *= e_yv
numpy_compare.assert_equal(e, "(x * y)")
e *= zv
numpy_compare.assert_equal(e, "(x * y * z)")
e *= 1
numpy_compare.assert_equal(e, "(x * y * z)")
# Division
numpy_compare.assert_equal(e_xv / e_yv, (x / y))
numpy_compare.assert_equal(e_xv / yv, (x / y))
numpy_compare.assert_equal(e_xv / 1, "x")
numpy_compare.assert_equal(xv / e_yv, (x / y))
numpy_compare.assert_equal(1 / e_xv, (1 / x))
# - In place.
e = copy.copy(xv)
e /= e_yv
numpy_compare.assert_equal(e, (x / y))
e /= zv
numpy_compare.assert_equal(e, (x / y / z))
e /= 1
numpy_compare.assert_equal(e, ((x / y) / z))
# Unary
numpy_compare.assert_equal(+e_xv, "x")
numpy_compare.assert_equal(-e_xv, "(-1 * x)")
# Comparison. For `VectorizedAlgebra`, uses `np.vectorize` workaround
# for #8315.
# TODO(eric.cousineau): `BaseAlgebra.check_logical` is designed for
# AutoDiffXd (float-convertible), not for symbolic (not always
# float-convertible).
numpy_compare.assert_equal(algebra.lt(e_xv, e_yv), "(x < y)")
numpy_compare.assert_equal(algebra.le(e_xv, e_yv), "(x <= y)")
numpy_compare.assert_equal(algebra.eq(e_xv, e_yv), "(x == y)")
numpy_compare.assert_equal(algebra.ne(e_xv, e_yv), "(x != y)")
numpy_compare.assert_equal(algebra.ge(e_xv, e_yv), "(x >= y)")
numpy_compare.assert_equal(algebra.gt(e_xv, e_yv), "(x > y)")
# Math functions.
numpy_compare.assert_equal(algebra.abs(e_xv), "abs(x)")
numpy_compare.assert_equal(algebra.exp(e_xv), "exp(x)")
numpy_compare.assert_equal(algebra.sqrt(e_xv), "sqrt(x)")
numpy_compare.assert_equal(algebra.pow(e_xv, e_yv), "pow(x, y)")
numpy_compare.assert_equal(algebra.sin(e_xv), "sin(x)")
numpy_compare.assert_equal(algebra.cos(e_xv), "cos(x)")
numpy_compare.assert_equal(algebra.tan(e_xv), "tan(x)")
numpy_compare.assert_equal(algebra.arcsin(e_xv), "asin(x)")
numpy_compare.assert_equal(algebra.arccos(e_xv), "acos(x)")
numpy_compare.assert_equal(algebra.arctan2(e_xv, e_yv), "atan2(x, y)")
numpy_compare.assert_equal(algebra.sinh(e_xv), "sinh(x)")
numpy_compare.assert_equal(algebra.cosh(e_xv), "cosh(x)")
numpy_compare.assert_equal(algebra.tanh(e_xv), "tanh(x)")
numpy_compare.assert_equal(algebra.ceil(e_xv), "ceil(x)")
numpy_compare.assert_equal(algebra.floor(e_xv), "floor(x)")
if isinstance(algebra, ScalarAlgebra):
# TODO(eric.cousineau): Uncomment these lines if we can teach numpy
# that reduction is not just selection.
numpy_compare.assert_equal(algebra.min(e_xv, e_yv), "min(x, y)")
numpy_compare.assert_equal(algebra.max(e_xv, e_yv), "max(x, y)")
# TODO(eric.cousineau): Add broadcasting functions for these
# operations.
numpy_compare.assert_equal(sym.atan(e_xv), "atan(x)")
numpy_compare.assert_equal(
sym.if_then_else(e_xv > e_yv, e_xv, e_yv),
"(if (x > y) then x else y)")
return xv, e_xv
def _check_algebra(self, algebra):
xv = algebra.to_algebra(x)
yv = algebra.to_algebra(y)
zv = algebra.to_algebra(z)
wv = algebra.to_algebra(w)
av = algebra.to_algebra(a)
bv = algebra.to_algebra(b)
cv = algebra.to_algebra(c)
e_xv = algebra.to_algebra(e_x)
e_yv = algebra.to_algebra(e_y)
# Addition.
npc.assert_equal(e_xv + e_yv, "(x + y)")
npc.assert_equal(e_xv + yv, "(x + y)")
npc.assert_equal(e_xv + 1, "(1 + x)")
npc.assert_equal(xv + e_yv, "(x + y)")
npc.assert_equal(1 + e_xv, "(1 + x)")
# - In place.
e = copy.copy(xv)
e += e_yv
npc.assert_equal(e, "(x + y)")
e += zv
npc.assert_equal(e, "(x + y + z)")
e += 1
npc.assert_equal(e, "(1 + x + y + z)")
# Subtraction.
npc.assert_equal(e_xv - e_yv, "(x - y)")
npc.assert_equal(e_xv - yv, "(x - y)")
npc.assert_equal(e_xv - 1, "(-1 + x)")
npc.assert_equal(xv - e_yv, "(x - y)")
npc.assert_equal(1 - e_xv, "(1 - x)")
# - In place.
e = copy.copy(xv)
e -= e_yv
npc.assert_equal(e, (x - y))
e -= zv
npc.assert_equal(e, (x - y - z))
e -= 1
npc.assert_equal(e, (x - y - z - 1))
# Multiplication.
npc.assert_equal(e_xv * e_yv, "(x * y)")
npc.assert_equal(e_xv * yv, "(x * y)")
npc.assert_equal(e_xv * 1, "x")
npc.assert_equal(xv * e_yv, "(x * y)")
npc.assert_equal(1 * e_xv, "x")
# - In place.
e = copy.copy(xv)
e *= e_yv
npc.assert_equal(e, "(x * y)")
e *= zv
npc.assert_equal(e, "(x * y * z)")
e *= 1
npc.assert_equal(e, "(x * y * z)")
# Division
npc.assert_equal(e_xv / e_yv, (x / y))
npc.assert_equal(e_xv / yv, (x / y))
npc.assert_equal(e_xv / 1, "x")
npc.assert_equal(xv / e_yv, (x / y))
npc.assert_equal(1 / e_xv, (1 / x))
# - In place.
e = copy.copy(xv)
e /= e_yv
npc.assert_equal(e, (x / y))
e /= zv
npc.assert_equal(e, (x / y / z))
e /= 1
npc.assert_equal(e, ((x / y) / z))
# Unary
npc.assert_equal(+e_xv, "x")
npc.assert_equal(-e_xv, "(-1 * x)")
# Comparison. For `VectorizedAlgebra`, uses `np.vectorize` workaround
# for #8315.
# TODO(eric.cousineau): `BaseAlgebra.check_logical` is designed for
# AutoDiffXd (float-convertible), not for symbolic (not always
# float-convertible).
npc.assert_equal(algebra.lt(e_xv, e_yv), "(x < y)")
npc.assert_equal(algebra.le(e_xv, e_yv), "(x <= y)")
npc.assert_equal(algebra.eq(e_xv, e_yv), "(x == y)")
npc.assert_equal(algebra.ne(e_xv, e_yv), "(x != y)")
npc.assert_equal(algebra.ge(e_xv, e_yv), "(x >= y)")
npc.assert_equal(algebra.gt(e_xv, e_yv), "(x > y)")
# Math functions.
npc.assert_equal(algebra.abs(e_xv), "abs(x)")
npc.assert_equal(algebra.exp(e_xv), "exp(x)")
npc.assert_equal(algebra.sqrt(e_xv), "sqrt(x)")
npc.assert_equal(algebra.pow(e_xv, e_yv), "pow(x, y)")
npc.assert_equal(algebra.sin(e_xv), "sin(x)")
npc.assert_equal(algebra.cos(e_xv), "cos(x)")
npc.assert_equal(algebra.tan(e_xv), "tan(x)")
npc.assert_equal(algebra.arcsin(e_xv), "asin(x)")
npc.assert_equal(algebra.arccos(e_xv), "acos(x)")
npc.assert_equal(algebra.arctan2(e_xv, e_yv), "atan2(x, y)")
npc.assert_equal(algebra.sinh(e_xv), "sinh(x)")
npc.assert_equal(algebra.cosh(e_xv), "cosh(x)")
npc.assert_equal(algebra.tanh(e_xv), "tanh(x)")
npc.assert_equal(algebra.ceil(e_xv), "ceil(x)")
npc.assert_equal(algebra.floor(e_xv), "floor(x)")
if isinstance(algebra, ScalarAlgebra):
# TODO(eric.cousineau): Uncomment these lines if we can teach numpy
# that reduction is not just selection.
npc.assert_equal(algebra.min(e_xv, e_yv), "min(x, y)")
npc.assert_equal(algebra.max(e_xv, e_yv), "max(x, y)")
# TODO(eric.cousineau): Add broadcasting functions for these
# operations.
npc.assert_equal(sym.atan(e_xv), "atan(x)")
npc.assert_equal(sym.if_then_else(e_xv > e_yv, e_xv, e_yv),
"(if (x > y) then x else y)")
return xv, e_xv
