tag ldbl and error in incompat platform

Author: SwayamInSync

src/csrc/quaddtype_main.c

@@ -69,8 +69,10 @@ static PyMethodDef module_methods[] = {
         {"is_longdouble_128", py_is_longdouble_128, METH_NOARGS, "Check if long double is 128-bit"},
         {"get_sleef_constant", get_sleef_constant, METH_VARARGS, "Get Sleef constant by name"},
         {"from_raw_bytes", QuadPrecision_from_raw_bytes, METH_VARARGS,
-         "Reconstruct a QuadPrecision scalar from its raw little-endian bytes "
-         "(used by pickle)."},
+         "from_raw_bytes(data, backend='sleef', ld_format=-1): reconstruct a "
+         "QuadPrecision scalar from its raw little-endian bytes (used by pickle). "
+         "For the 'longdouble' backend ld_format is the source LDBL_MANT_DIG and, "
+         "if given, must match this platform's."},
         {"set_num_threads", py_quadblas_set_num_threads, METH_VARARGS,
          "Set number of threads for QuadBLAS"},
         {"get_num_threads", py_quadblas_get_num_threads, METH_NOARGS,

src/csrc/scalar.c

@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
+#include <float.h>
 
 #define PY_ARRAY_UNIQUE_SYMBOL QuadPrecType_ARRAY_API
 #define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION
@@ -684,7 +685,22 @@ QuadPrecision_reduce(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored))
         return NULL;
     }
 
-    PyObject *args = PyTuple_Pack(2, data, backend_obj);
+    PyObject *args;
+    if (self->backend == BACKEND_LONGDOUBLE) {
+        // Tag longdouble payloads with the platform's LDBL_MANT_DIG
+        PyObject *fmt = PyLong_FromLong((long)LDBL_MANT_DIG);
+        if (fmt == NULL) {
+            Py_DECREF(data);
+            Py_DECREF(backend_obj);
+            Py_DECREF(reconstruct);
+            return NULL;
+        }
+        args = PyTuple_Pack(3, data, backend_obj, fmt);
+        Py_DECREF(fmt);
+    }
+    else {
+        args = PyTuple_Pack(2, data, backend_obj);
+    }
     Py_DECREF(data);
     Py_DECREF(backend_obj);
     if (args == NULL) {
@@ -703,7 +719,8 @@ QuadPrecision_from_raw_bytes(PyObject *Py_UNUSED(module), PyObject *args)
 {
     Py_buffer view;
     const char *backend_str = "sleef";
-    if (!PyArg_ParseTuple(args, "y*|s", &view, &backend_str)) {
+    int ld_format = -1;  // source LDBL_MANT_DIG for longdouble; -1 = not provided
+    if (!PyArg_ParseTuple(args, "y*|si", &view, &backend_str, &ld_format)) {
         return NULL;
     }
 
@@ -727,6 +744,17 @@ QuadPrecision_from_raw_bytes(PyObject *Py_UNUSED(module), PyObject *args)
         return NULL;
     }
 
+    if (backend == BACKEND_LONGDOUBLE && ld_format != -1 &&
+            ld_format != LDBL_MANT_DIG) {
+        PyErr_Format(PyExc_ValueError,
+                     "Cannot unpickle a 'longdouble' QuadPrecision created on a "
+                     "platform with a different long double format "
+                     "(LDBL_MANT_DIG=%d) than this one (LDBL_MANT_DIG=%d).",
+                     ld_format, (int)LDBL_MANT_DIG);
+        PyBuffer_Release(&view);
+        return NULL;
+    }
+
     QuadPrecisionObject *self = QuadPrecision_raw_new(backend);
     if (self == NULL) {
         PyBuffer_Release(&view);
@@ -746,7 +774,7 @@ static PyMethodDef QuadPrecision_methods[] = {
     {"as_integer_ratio", (PyCFunction)QuadPrecision_as_integer_ratio, METH_NOARGS,
      "Return a pair of integers whose ratio is exactly equal to the original value."},
     {"__reduce__", (PyCFunction)QuadPrecision_reduce, METH_NOARGS,
-     "Support pickling: return (from_raw_bytes, (raw_bytes, backend))."},
+     "Support pickling: return (from_raw_bytes, (raw_bytes, backend[, ld_format]))."},
     {NULL, NULL, 0, NULL}  /* Sentinel */
 };
 

tests/test_quaddtype.py

@@ -5739,9 +5739,9 @@ def test_from_raw_bytes_roundtrip_matches_reduce(self):
         for backend in ("sleef", "longdouble"):
             original = QuadPrecision("3.14159265358979323846264338327950288",
                                      backend=backend)
-            _, (data, be) = original.__reduce__()
-            assert be == backend
-            rebuilt = from_raw_bytes(data, backend)
+            _, reduce_args = original.__reduce__()
+            assert reduce_args[1] == backend
+            rebuilt = from_raw_bytes(*reduce_args)
             assert self._raw_bytes(rebuilt) == self._raw_bytes(original)
             assert rebuilt == original
 
@@ -5772,6 +5772,26 @@ def test_pickle_scalar_longdouble_padding_zeroed(self):
         assert raw2[10:] == b"\x00" * 6, raw2.hex()
         assert raw2 == raw
 
+    def test_reduce_longdouble_carries_format_tag(self):
+        """longdouble __reduce__ carries a format tag (LDBL_MANT_DIG) so a
+        cross-format pickle can be rejected; sleef (always binary128) omits it."""
+        _, sl_args = QuadPrecision("1.5", backend="sleef").__reduce__()
+        _, ld_args = QuadPrecision("1.5", backend="longdouble").__reduce__()
+        assert len(sl_args) == 2 and sl_args[1] == "sleef"
+        assert len(ld_args) == 3 and ld_args[1] == "longdouble"
+        assert isinstance(ld_args[2], int)
+
+    def test_from_raw_bytes_rejects_wrong_longdouble_format(self):
+        """A longdouble payload tagged with a different platform's format must be
+        rejected, not silently reinterpreted."""
+        from numpy_quaddtype._quaddtype_main import from_raw_bytes
+        _, (data, be, fmt) = QuadPrecision("1.5", backend="longdouble").__reduce__()
+        with pytest.raises(ValueError):
+            from_raw_bytes(data, "longdouble", fmt + 1)
+        # The matching tag (and omitting it) still reconstruct fine.
+        assert from_raw_bytes(data, "longdouble", fmt) == QuadPrecision("1.5", backend="longdouble")
+        assert from_raw_bytes(data, "longdouble") == QuadPrecision("1.5", backend="longdouble")
+
 
 @pytest.mark.parametrize("dtype", [
     "bool",