pytorch · Chillee · May 30, 2019 · May 30, 2019 · May 30, 2019 · May 30, 2019
diff --git a/test/test_jit.py b/test/test_jit.py
@@ -6122,7 +6122,7 @@ def func(a, b):
 
         unary_float_ops = ["log", "log1p", "log10", "exp", "sqrt", "gamma", "lgamma", "erf",
                            "erfc", "expm1", "fabs", "acos", "asin", "atan", "cos", "sin", "tan",
-                           "asinh", "atanh", "acosh", "sinh", "cosh", "tanh"]
+                           "asinh", "atanh", "acosh", "sinh", "cosh", "tanh", "degrees", "radians"]
         binary_float_ops = ["atan2", "fmod", "copysign"]
         for op in unary_float_ops:
             checkMathWrap(op, 1)
@@ -6133,6 +6133,8 @@ def func(a, b):
         checkMath("frexp", 1, ret_type="Tuple[float, int]")
         checkMath("isnan", 1, ret_type="bool")
         checkMath("isinf", 1, ret_type="bool")
+        checkMath("ldexp", 2, is_float=False, ret_type="float", args_type="(float, int)",
+                  vals=[(i, j) for i in float_vals for j in range(-10, 10)])
         checkMath("pow", 2, is_float=False, ret_type="int")
         checkMath("pow", 2, is_float=True, ret_type="float")
         if not PY2:
@@ -6142,20 +6144,7 @@ def func(a, b):
             checkMath("isfinite", 1, ret_type="bool")
         if PY37:
             checkMathWrap("remainder", 2)
-        checkMathWrap("factorial", 1, is_float=False, ret_type="int", vals=[(i, i) for i in range(-2, 10)])
-
-    @unittest.skipIf(PY2, "Requires python 3")
-    def test_math_gcd(self):
-        def test_gcd(x, y):
-            # type: (int, int) -> int
-            return math.gcd(x, y)
-
-        max_int = 2147483647
-        min_int = -2147483647 - 1
-        int_vals = list(range(-5, 5, 1)) + [max_int + 5, max_int * 2, min_int - 5, min_int * 2]
-        vals = [(i, j) for i in int_vals for j in int_vals]
-        for inputs in vals:
-            self.checkScript(test_gcd, inputs)
+        checkMathWrap("factorial", 1, is_float=False, ret_type="int", vals=[(i, 0) for i in range(-2, 10)])
 
     def test_if_nest_while(self):
         def func(a, b):

diff --git a/torch/csrc/jit/register_prim_ops.cpp b/torch/csrc/jit/register_prim_ops.cpp
@@ -161,6 +161,14 @@ int64_t factorial(int n) {
   loop(n, p, r);
   return r << nminussumofbits(n);
 }
+static const double degToRad = std::acos(-1.0) / 180.0;
+static const double radToDeg = 180.0 / std::acos(-1.0);
+double degrees(double x) {
+  return x * radToDeg;
+}
+double radians(double x) {
+  return x * degToRad;
+}
 
 // reference function THPVariable_to in python_variable_methods.cpp
 static at::Tensor to_dispatch(
@@ -2208,6 +2216,8 @@ RegisterOperators reg2({
     DEFINE_UNARY_OP(aten::sinh, std::sinh(a), float, float),
     DEFINE_UNARY_OP(aten::cosh, std::cosh(a), float, float),
     DEFINE_UNARY_OP(aten::tanh, std::tanh(a), float, float),
+    DEFINE_UNARY_OP(aten::degrees, degrees(a), float, float),
+    DEFINE_UNARY_OP(aten::radians, radians(a), float, float),
     DEFINE_BINARY_FLOAT_OP(aten::fmod, std::fmod(a, b)),
     DEFINE_UNARY_INT_OP(aten::factorial, factorial(a), int),
     DEFINE_UNARY_FLOAT_OP(aten::isnan, std::isnan(a), bool),
@@ -2234,6 +2244,15 @@ RegisterOperators reg2({
           push(stack, m, e);
           return 0;
         }),
+    Operator(
+        "aten::ldexp(float x, int i) -> float",
+        [](Stack& stack) {
+          double a;
+          int64_t b;
+          pop(stack, a, b);
+          push(stack, std::ldexp(a, b));
+          return 0;
+        }),
     DEFINE_BINARY_FLOAT_OP(aten::mathremainder, std::remainder(a, b)),
 
     // TODO: move abs to aten namespace because it's schematized!

diff --git a/torch/jit/__init__.py b/torch/jit/__init__.py
@@ -1912,6 +1912,9 @@ def register_all(mod):
         (math.frexp, "aten::frexp"),
         (math.isnan, "aten::isnan"),
         (math.isinf, "aten::isinf"),
+        (math.degrees, "aten::degrees"),
+        (math.radians, "aten::radians"),
+        (math.ldexp, "aten::ldexp"),
         (torch._C._infer_size, "aten::_infer_size"),
         (torch.nn.functional._no_grad_embedding_renorm_, "aten::_no_grad_embedding_renorm_"),
         (torch.nn.functional.assert_int_or_pair, "aten::_assert_int_or_pair"),