fixing conflicts

Author: SwayamInSync

quaddtype/numpy_quaddtype/src/ops.hpp

@@ -252,6 +252,15 @@ quad_degrees(const Sleef_quad *op)
     return Sleef_mulq1_u05(*op, ratio);
 }
 
+static inline Sleef_quad
+quad_radians(const Sleef_quad *op)
+{
+    // radians = degrees * π / 180
+    static const Sleef_quad one_eighty = sleef_q(+0x1680000000000LL, 0x0000000000000000ULL, 7);
+    Sleef_quad ratio = Sleef_divq1_u05(SLEEF_M_PIq, one_eighty);
+    return Sleef_mulq1_u05(*op, ratio);
+}
+
 // Unary long double operations
 typedef long double (*unary_op_longdouble_def)(const long double *);
 
@@ -465,6 +474,16 @@ ld_degrees(const long double *op)
     return (*op) * (180.0L / static_cast<long double>(M_PI));
 }
 
+static inline long double
+ld_radians(const long double *op)
+{
+    // radians = degrees * π / 180
+    #ifndef M_PI
+    #define M_PI 3.14159265358979323846
+    #endif
+    return (*op) * (static_cast<long double>(M_PI) / 180.0L);
+}
+
 // Unary Quad properties
 typedef npy_bool (*unary_prop_quad_def)(const Sleef_quad *);
 

quaddtype/numpy_quaddtype/src/umath/unary_ops.cpp

@@ -256,5 +256,11 @@ init_quad_unary_ops(PyObject *numpy)
     if (create_quad_unary_ufunc<quad_degrees, ld_degrees>(numpy, "rad2deg") < 0) {
         return -1;
     }
+    if (create_quad_unary_ufunc<quad_radians, ld_radians>(numpy, "radians") < 0) {
+        return -1;
+    }
+    if (create_quad_unary_ufunc<quad_radians, ld_radians>(numpy, "deg2rad") < 0) {
+        return -1;
+    }
     return 0;
 }

quaddtype/release_tracker.md

@@ -55,8 +55,8 @@
 | arccosh       | ✅    | ✅                                                                   |
 | arctanh       | ✅    | ✅                                                                   |
 | degrees       | ✅    | ✅                                                                   |
-| radians       |       |                                                                      |
-| deg2rad       |       |                                                                      |
+| radians       | ✅    | ✅                                                                   |
+| deg2rad       | ✅    | ✅                                                                   |
 | rad2deg       | ✅    | ✅                                                                   |
 | greater       | ✅    | ✅                                                                   |
 | greater_equal | ✅    | ✅                                                                   |

quaddtype/tests/test_quaddtype.py

@@ -1931,9 +1931,9 @@ 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):
@@ -1945,3 +1945,44 @@ def test_degrees_rad2deg(op, radians, expected_degrees):
     else:
         np.testing.assert_allclose(float(result), expected_degrees, rtol=1e-13)
 
+
+@pytest.mark.parametrize("op", [np.radians, np.deg2rad])
+@pytest.mark.parametrize("degrees,expected_radians", [
+    # Basic conversions
+    (0.0, 0.0),
+    (30.0, np.pi / 6),
+    (45.0, np.pi / 4),
+    (60.0, np.pi / 3),
+    (90.0, np.pi / 2),
+    (180.0, np.pi),
+    (270.0, 3 * np.pi / 2),
+    (360.0, 2 * np.pi),
+    # Negative values
+    (-90.0, -np.pi / 2),
+    (-180.0, -np.pi),
+    # 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_radians(op, degrees, expected_radians):
+    """Test radians and deg2rad ufuncs convert degrees to radians"""
+    q_deg = QuadPrecision(degrees)
+    result = op(q_deg)
+
+    assert isinstance(result, QuadPrecision)
+
+    if np.isnan(expected_radians):
+        assert np.isnan(float(result))
+    elif np.isinf(expected_radians):
+        assert np.isinf(float(result))
+        if expected_radians > 0:
+            assert float(result) > 0
+        else:
+            assert float(result) < 0
+    else:
+        np.testing.assert_allclose(float(result), expected_radians, rtol=1e-13)
+