need to fix thread-safety

Author: SwayamInSync

quaddtype/numpy_quaddtype/src/scalar.c

@@ -422,10 +422,137 @@ QuadPrecision_is_integer(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored)
     }
 }
 
+// this is thread-unsafe
+PyObject* quad_to_pylong(Sleef_quad value)
+{
+    char buffer[128];
+    // Format as integer (%.0Qf gives integer with no decimal places)
+    // Q modifier means pass Sleef_quad by value
+    int written = Sleef_snprintf(buffer, sizeof(buffer), "%.0Qf", value);
+    if (written < 0 || written >= sizeof(buffer)) {
+        PyErr_SetString(PyExc_RuntimeError, "Failed to convert quad to string");
+        return NULL;
+    }
+
+    PyObject *result = PyLong_FromString(buffer, NULL, 10);
+    
+    if (result == NULL) {
+        PyErr_SetString(PyExc_RuntimeError, "Failed to parse integer string");
+        return NULL;
+    }
+    
+    return result;
+}
+
+// inspired by the CPython implementation
+// https://github.com/python/cpython/blob/ac1ffd77858b62d169a08040c08aa5de26e145ac/Objects/floatobject.c#L1503C1-L1572C2
+// NOTE: a 128-bit 
 static PyObject *
 QuadPrecision_as_integer_ratio(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored))
 {
+
+    Sleef_quad value;
+    Sleef_quad pos_inf = sleef_q(+0x1000000000000LL, 0x0000000000000000ULL, 16384);
+    const int FLOAT128_PRECISION = 113;
 
+    if (self->backend == BACKEND_SLEEF) {
+        value = self->value.sleef_value;
+    }
+    else {
+        // lets also tackle ld from sleef functions as well
+        value = Sleef_cast_from_doubleq1((double)self->value.longdouble_value);
+    }
+    
+    if(Sleef_iunordq1(value, value)) {
+      PyErr_SetString(PyExc_ValueError, "Cannot convert NaN to integer ratio");
+      return NULL;
+    }
+    if(Sleef_icmpgeq1(Sleef_fabsq1(value), pos_inf)) {
+      PyErr_SetString(PyExc_OverflowError, "Cannot convert infinite value to integer ratio");
+      return NULL;
+    }
+
+    // Sleef_value == float_part * 2**exponent exactly
+    int exponent;
+    Sleef_quad mantissa = Sleef_frexpq1(value, &exponent); // within [0.5, 1.0)
+
+    /*
+    CPython loops for 300 (some huge number) to make sure 
+    float_part gets converted to the floor(float_part) i.e. near integer as
+    
+    for (i=0; i<300 && float_part != floor(float_part) ; i++) {
+        float_part *= 2.0;
+        exponent--;
+    }
+
+    It seems highly inefficient from performance perspective, maybe they pick 300 for future-proof
+    or If FLT_RADIX != 2, the 300 steps may leave a tiny fractional part
+
+    Another way can be doing as:
+    ```
+    mantissa = ldexpq(mantissa, FLOAT128_PRECISION);
+    exponent -= FLOAT128_PRECISION;
+    ```
+    This should work but give non-simplified, huge integers (although they also come down to same representation)
+    We can also do gcd to find simplified values, but it'll add more O(log(N)) {which in theory seem better}
+    For the sake of simplicity and fixed 128-bit nature, we will loop till 113 only
+    */
+
+    for (int i = 0; i < FLOAT128_PRECISION && !Sleef_icmpeqq1(mantissa, Sleef_floorq1(mantissa)); i++) {
+        mantissa = Sleef_mulq1_u05(mantissa, Sleef_cast_from_doubleq1(2.0));
+        exponent--;
+    }
+
+
+    // numerator and denominators can't fit in int
+    // convert items to PyLongObject from string instead
+
+    PyObject *py_exp = PyLong_FromLongLong(Py_ABS(exponent));
+    if(py_exp == NULL)
+    {
+        return NULL;
+    }
+    
+    PyObject *numerator = quad_to_pylong(mantissa);
+    if(numerator == NULL)
+    {
+        Py_DECREF(numerator);
+        return NULL;
+    }
+    PyObject *denominator = PyLong_FromLong(1);
+    if (denominator == NULL) {
+        Py_DECREF(numerator);
+        return NULL;
+    }
+
+    // fold in 2**exponent
+    if(exponent > 0)
+    {
+        PyObject *new_num = PyNumber_Lshift(numerator, py_exp);
+        Py_DECREF(numerator);
+        if(new_num == NULL)
+        {
+            Py_DECREF(denominator);
+            Py_DECREF(py_exp);
+            return NULL;
+        }
+        numerator = new_num;
+    }
+    else
+    {
+        PyObject *new_denom = PyNumber_Lshift(denominator, py_exp);
+        Py_DECREF(denominator);
+        if(new_denom == NULL)
+        {
+            Py_DECREF(numerator);
+            Py_DECREF(py_exp);
+            return NULL;
+        }
+        denominator = new_denom;
+    }
+
+    Py_DECREF(py_exp);
+    return PyTuple_Pack(2, numerator, denominator);
 }
 
 static PyMethodDef QuadPrecision_methods[] = {

quaddtype/tests/test_quaddtype.py

@@ -3552,105 +3552,74 @@ def test_is_integer_compatibility_with_float(self, value):
         float_val = float(value)
         assert quad_val.is_integer() == float_val.is_integer()
 
-    # @pytest.mark.parametrize("value,expected_num,expected_denom", [
-    #     ("1.0", 1, 1),
-    #     ("42.0", 42, 1),
-    #     ("-5.0", -5, 1),
-    #     ("0.0", 0, 1),
-    # ])
-    # def test_as_integer_ratio_integers(self, value, expected_num, expected_denom):
-    #     """Test as_integer_ratio() for integer values."""
-    #     num, denom = QuadPrecision(value).as_integer_ratio()
-    #     assert num == expected_num and denom == expected_denom
-    
-    # @pytest.mark.parametrize("value,expected_ratio", [
-    #     ("0.5", 0.5),
-    #     ("0.25", 0.25),
-    #     ("1.5", 1.5),
-    #     ("-2.5", -2.5),
-    # ])
-    # def test_as_integer_ratio_fractional(self, value, expected_ratio):
-    #     """Test as_integer_ratio() for fractional values."""
-    #     num, denom = QuadPrecision(value).as_integer_ratio()
-    #     assert num / denom == expected_ratio
-    #     assert denom > 0  # Denominator should always be positive
-    
-    # @pytest.mark.parametrize("value", [
-    #     "3.14", "0.1", "1.414213562373095", "2.718281828459045",
-    #     "-1.23456789", "1000.001", "0.0001", "1e20", "1.23e15", "1e-30"
-    # ])
-    # def test_as_integer_ratio_reconstruction(self, value):
-    #     """Test that as_integer_ratio() can reconstruct the original value."""
-    #     quad_val = QuadPrecision(value)
-    #     num, denom = quad_val.as_integer_ratio()
-    #     reconstructed = QuadPrecision(num) / QuadPrecision(denom)
-    #     assert reconstructed == quad_val
-    
-    # def test_as_integer_ratio_return_types(self):
-    #     """Test that as_integer_ratio() returns Python ints."""
-    #     num, denom = QuadPrecision("3.14").as_integer_ratio()
-    #     assert isinstance(num, int)
-    #     assert isinstance(denom, int)
-    
-    # @pytest.mark.parametrize("value", ["-1.0", "-3.14", "-0.5", "1.0", "3.14", "0.5"])
-    # def test_as_integer_ratio_denominator_positive(self, value):
-    #     """Test that denominator is always positive."""
-    #     num, denom = QuadPrecision(value).as_integer_ratio()
-    #     assert denom > 0
-    
-    # @pytest.mark.parametrize("value,exception,match", [
-    #     ("inf", OverflowError, "cannot convert Infinity to integer ratio"),
-    #     ("-inf", OverflowError, "cannot convert Infinity to integer ratio"),
-    #     ("nan", ValueError, "cannot convert NaN to integer ratio"),
-    # ])
-    # def test_as_integer_ratio_special_values_raise(self, value, exception, match):
-    #     """Test that as_integer_ratio() raises appropriate errors for special values."""
-    #     with pytest.raises(exception, match=match):
-    #         QuadPrecision(value).as_integer_ratio()
-    
-    # @pytest.mark.parametrize("value", ["1.0", "0.5", "3.14", "-2.5", "0.0"])
-    # def test_as_integer_ratio_compatibility_with_float(self, value):
-    #     """Test as_integer_ratio() matches behavior of Python's float where possible."""
-    #     quad_val = QuadPrecision(value)
-    #     float_val = float(value)
-        
-    #     quad_num, quad_denom = quad_val.as_integer_ratio()
-    #     float_num, float_denom = float_val.as_integer_ratio()
-        
-    #     # The ratios should be equal
-    #     quad_ratio = quad_num / quad_denom
-    #     float_ratio = float_num / float_denom
-    #     assert abs(quad_ratio - float_ratio) < 1e-15
-    
-    # def test_methods_available_on_type_and_instance(self):
-    #     """Test that methods are available on the QuadPrecision class and instances."""
-    #     # Check on type
-    #     assert hasattr(QuadPrecision, 'is_integer') and callable(QuadPrecision.is_integer)
-    #     assert hasattr(QuadPrecision, 'as_integer_ratio') and callable(QuadPrecision.as_integer_ratio)
-        
-    #     # Check on instance
-    #     val = QuadPrecision("3.14")
-    #     assert hasattr(val, 'is_integer') and callable(val.is_integer)
-    #     assert hasattr(val, 'as_integer_ratio') and callable(val.as_integer_ratio)
-    
-    # @pytest.mark.parametrize("backend", ["sleef", "longdouble"])
-    # def test_is_integer_with_backends(self, backend):
-    #     """Test is_integer() with different backends."""
-    #     if backend == "longdouble" and not numpy_quaddtype.is_longdouble_128():
-    #         pytest.skip("longdouble backend not 128-bit")
-        
-    #     val = QuadPrecision("3.0", backend=backend)
-    #     assert val.is_integer()
-        
-    #     val2 = QuadPrecision("3.5", backend=backend)
-    #     assert not val2.is_integer()
-    
-    # @pytest.mark.parametrize("backend", ["sleef", "longdouble"])
-    # def test_as_integer_ratio_with_backends(self, backend):
-    #     """Test as_integer_ratio() with different backends."""
-    #     if backend == "longdouble" and not numpy_quaddtype.is_longdouble_128():
-    #         pytest.skip("longdouble backend not 128-bit")
-        
-    #     val = QuadPrecision("1.5", backend=backend)
-    #     num, denom = val.as_integer_ratio()
-    #     assert num / denom == 1.5
+    @pytest.mark.parametrize("value,expected_num,expected_denom", [
+        ("1.0", 1, 1),
+        ("42.0", 42, 1),
+        ("-5.0", -5, 1),
+        ("0.0", 0, 1),
+        ("-0.0", 0, 1),
+    ])
+    def test_as_integer_ratio_integers(self, value, expected_num, expected_denom):
+        """Test as_integer_ratio() for integer values."""
+        num, denom = QuadPrecision(value).as_integer_ratio()
+        assert num == expected_num and denom == expected_denom
+    
+    @pytest.mark.parametrize("value,expected_ratio", [
+        ("0.5", 0.5),
+        ("0.25", 0.25),
+        ("1.5", 1.5),
+        ("-2.5", -2.5),
+    ])
+    def test_as_integer_ratio_fractional(self, value, expected_ratio):
+        """Test as_integer_ratio() for fractional values."""
+        num, denom = QuadPrecision(value).as_integer_ratio()
+        assert QuadPrecision(str(num)) / QuadPrecision(str(denom)) == QuadPrecision(str(expected_ratio))
+        assert denom > 0  # Denominator should always be positive
+    
+    @pytest.mark.parametrize("value", [
+        "3.14", "0.1", "1.414213562373095", "2.718281828459045",
+        "-1.23456789", "1000.001", "0.0001", "1e20", "1.23e15", "1e-30", quad_pi
+    ])
+    def test_as_integer_ratio_reconstruction(self, value):
+        """Test that as_integer_ratio() can reconstruct the original value."""
+        quad_val = QuadPrecision(value)
+        num, denom = quad_val.as_integer_ratio()
+        # todo: can remove str converstion after merging PR #213
+        reconstructed = QuadPrecision(str(num)) / QuadPrecision(str(denom))
+        assert reconstructed == quad_val
+    
+    def test_as_integer_ratio_return_types(self):
+        """Test that as_integer_ratio() returns Python ints."""
+        num, denom = QuadPrecision("3.14").as_integer_ratio()
+        assert isinstance(num, int)
+        assert isinstance(denom, int)
+    
+    @pytest.mark.parametrize("value", ["-1.0", "-3.14", "-0.5", "1.0", "3.14", "0.5"])
+    def test_as_integer_ratio_denominator_positive(self, value):
+        """Test that denominator is always positive."""
+        num, denom = QuadPrecision(value).as_integer_ratio()
+        assert denom > 0
+    
+    @pytest.mark.parametrize("value,exception,match", [
+        ("inf", OverflowError, "Cannot convert infinite value to integer ratio"),
+        ("-inf", OverflowError, "Cannot convert infinite value to integer ratio"),
+        ("nan", ValueError, "Cannot convert NaN to integer ratio"),
+    ])
+    def test_as_integer_ratio_special_values_raise(self, value, exception, match):
+        """Test that as_integer_ratio() raises appropriate errors for special values."""
+        with pytest.raises(exception, match=match):
+            QuadPrecision(value).as_integer_ratio()
+    
+    @pytest.mark.parametrize("value", ["1.0", "0.5", "3.14", "-2.5", "0.0"])
+    def test_as_integer_ratio_compatibility_with_float(self, value):
+        """Test as_integer_ratio() matches behavior of Python's float where possible."""
+        quad_val = QuadPrecision(value)
+        float_val = float(value)
+        
+        quad_num, quad_denom = quad_val.as_integer_ratio()
+        float_num, float_denom = float_val.as_integer_ratio()
+        
+        # The ratios should be equal
+        quad_ratio = quad_num / quad_denom
+        float_ratio = float_num / float_denom
+        assert abs(quad_ratio - float_ratio) < 1e-15