use snsprintf for longdouble

Author: SwayamInSync

src/csrc/scalar.c

@@ -2,6 +2,7 @@
 #include <sleef.h>
 #include <sleefquad.h>
 #include <stdlib.h>
+#include <float.h>
 
 #define PY_ARRAY_UNIQUE_SYMBOL QuadPrecType_ARRAY_API
 #define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION
@@ -620,10 +621,15 @@ QuadPrecision_reduce(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored))
                                                  opt.trim_mode, opt.digits_left, opt.exp_digits);
     }
     else {
-        Sleef_quad sleef_val = Sleef_cast_from_doubleq1(self->value.longdouble_value);
-        str_value = Dragon4_Scientific_QuadDType(&sleef_val, opt.digit_mode, opt.precision,
-                                                 opt.min_digits, opt.sign, opt.trim_mode,
-                                                 opt.digits_left, opt.exp_digits);
+        char buffer[128];
+        int written = snprintf(buffer, sizeof(buffer), "%.*Le",
+                               LDBL_DECIMAL_DIG - 1, self->value.longdouble_value);
+        if (written < 0 || written >= (int)sizeof(buffer)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "Failed to format long double for pickle");
+            return NULL;
+        }
+        str_value = PyUnicode_FromString(buffer);
     }
     if (str_value == NULL) {
         return NULL;

tests/test_quaddtype.py

@@ -5412,6 +5412,24 @@ def test_pickle_scalar_preserves_type(self):
         loaded = pickle.loads(pickle.dumps(QuadPrecision("1.0")))
         assert type(loaded) is QuadPrecision
 
+    @pytest.mark.parametrize("backend", ["sleef", "longdouble"])
+    def test_pickle_scalar_preserves_full_precision(self, backend):
+        """Diagnostic precision-loss test. Two values with the same printed
+        repr can still differ at the full bit width, so check via subtraction
+        (which preserves precision) — `loaded - original` must be exactly zero.
+        Catches the regression where the longdouble path went through (double)."""
+        import pickle
+        # A value with more than 16 significant digits — exercises precision
+        # beyond what double can represent.
+        original = QuadPrecision("3.14159265358979323846264338327950288",
+                                 backend=backend)
+        loaded = pickle.loads(pickle.dumps(original))
+        diff = loaded - original
+        assert diff == QuadPrecision("0.0", backend=backend), (
+            f"pickle round-trip lost precision on {backend}: "
+            f"loaded - original = {diff!r}"
+        )
+
     def test_pickle_scalar_preserves_backend_across_mix(self):
         """Each backend pickle must come back as the same backend, not silently
         defaulting to sleef."""