FEAT: degrees and rad2deg ufuncs implementation

quaddtype/numpy_quaddtype/src/ops.hpp

@@ -243,6 +243,15 @@ quad_atanh(const Sleef_quad *op)
     return Sleef_atanhq1_u10(*op);
 }
 
+static inline Sleef_quad
+quad_degrees(const Sleef_quad *op)
+{
+    // degrees = radians * 180 / π
+    static const Sleef_quad one_eighty = Sleef_strtoq("180.0", NULL);
+    Sleef_quad ratio = Sleef_divq1_u05(one_eighty, SLEEF_M_PIq);
+    return Sleef_mulq1_u05(*op, ratio);
+}
+
 // Unary long double operations
 typedef long double (*unary_op_longdouble_def)(const long double *);
 
@@ -446,6 +455,16 @@ ld_atanh(const long double *op)
     return atanhl(*op);
 }
 
+static inline long double
+ld_degrees(const long double *op)
+{
+    // degrees = radians * 180 / π
+    #ifndef M_PI
+    #define M_PI 3.14159265358979323846
+    #endif
+    return (*op) * (180.0L / static_cast<long double>(M_PI));
+}
+
 // Unary Quad properties
 typedef npy_bool (*unary_prop_quad_def)(const Sleef_quad *);
 

quaddtype/numpy_quaddtype/src/umath/unary_ops.cpp

@@ -250,5 +250,11 @@ init_quad_unary_ops(PyObject *numpy)
     if (create_quad_unary_ufunc<quad_atanh, ld_atanh>(numpy, "arctanh") < 0) {
         return -1;
     }
+    if (create_quad_unary_ufunc<quad_degrees, ld_degrees>(numpy, "degrees") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_degrees, ld_degrees>(numpy, "rad2deg") < 0) {
+        return -1;
+    }
     return 0;
 }

quaddtype/release_tracker.md

@@ -54,10 +54,10 @@
 | arcsinh       | ✅    | ✅                                                                   |
 | arccosh       | ✅    | ✅                                                                   |
 | arctanh       | ✅    | ✅                                                                   |
-| degrees       |       |                                                                      |
+| degrees       | ✅    | ✅                                                                   |
 | radians       |       |                                                                      |
 | deg2rad       |       |                                                                      |
-| rad2deg       |       |                                                                      |
+| rad2deg       | ✅    | ✅                                                                   |
 | bitwise_and   |       |                                                                      |
 | bitwise_or    |       |                                                                      |
 | bitwise_xor   |       |                                                                      |

quaddtype/tests/test_quaddtype.py

@@ -1905,3 +1905,44 @@ def test_hypot(x1, x2, expected):
     else:
         np.testing.assert_allclose(float(result), expected, rtol=1e-13)
 
+
+@pytest.mark.parametrize("op", [np.degrees, np.rad2deg])
+@pytest.mark.parametrize("radians,expected_degrees", [
+    # Basic conversions
+    (0.0, 0.0),
+    (np.pi / 6, 30.0),
+    (np.pi / 4, 45.0),
+    (np.pi / 3, 60.0),
+    (np.pi / 2, 90.0),
+    (np.pi, 180.0),
+    (3 * np.pi / 2, 270.0),
+    (2 * np.pi, 360.0),
+    # Negative values
+    (-np.pi / 2, -90.0),
+    (-np.pi, -180.0),
+    # Special values
+    (np.inf, np.inf),
+    (-np.inf, -np.inf),
+    (np.nan, np.nan),
+    # Edge cases
+    (0.0, 0.0),
+    (-0.0, -0.0),
+])
+def test_degrees_rad2deg(op, radians, expected_degrees):
+    """Test degrees and rad2deg ufuncs convert radians to degrees"""
+    q_rad = QuadPrecision(radians)
+    result = op(q_rad)
+
+    assert isinstance(result, QuadPrecision)
+
+    if np.isnan(expected_degrees):
+        assert np.isnan(float(result))
+    elif np.isinf(expected_degrees):
+        assert np.isinf(float(result))
+        if expected_degrees > 0:
+            assert float(result) > 0
+        else:
+            assert float(result) < 0
+    else:
+        np.testing.assert_allclose(float(result), expected_degrees, rtol=1e-13)
+