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