pickle from raw bytes and reconstruct

Author: SwayamInSync

src/csrc/quaddtype_main.c

@@ -68,6 +68,9 @@ get_sleef_constant(PyObject *self, PyObject *args)
 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)."},
         {"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

@@ -620,68 +620,130 @@ QuadPrecision_as_integer_ratio(QuadPrecisionObject *self, PyObject *Py_UNUSED(ig
     return PyTuple_Pack(2, numerator, denominator);
 }
 
-static PyObject *
-QuadPrecision_reduce(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored))
+static int
+quad_host_is_big_endian(void)
 {
-    Dragon4_Options opt = {.scientific = 1,
-                           .digit_mode = DigitMode_Unique,
-                           .cutoff_mode = CutoffMode_TotalLength,
-                           .precision = SLEEF_QUAD_DECIMAL_DIG,
-                           .sign = 1,
-                           .trim_mode = TrimMode_LeaveOneZero,
-                           .digits_left = 1,
-                           .exp_digits = 4};
+    uint16_t probe = 1;
+    return ((const unsigned char *)&probe)[0] == 0;
+}
 
-    PyObject *str_value;
-    if (self->backend == BACKEND_SLEEF) {
-        str_value = Dragon4_Scientific_QuadDType(&self->value.sleef_value, opt.digit_mode,
-                                                 opt.precision, opt.min_digits, opt.sign,
-                                                 opt.trim_mode, opt.digits_left, opt.exp_digits);
+
+static void
+quad_copy_canonical(unsigned char *dst, const unsigned char *src, size_t n)
+{
+    if (quad_host_is_big_endian()) {
+        for (size_t i = 0; i < n; i++) {
+            dst[i] = src[n - 1 - i];
+        }
     }
     else {
-        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);
+        memcpy(dst, src, n);
     }
-    if (str_value == NULL) {
+}
+
+
+static PyObject *
+QuadPrecision_reduce(QuadPrecisionObject *self, PyObject *Py_UNUSED(ignored))
+{
+    size_t nbytes = (self->backend == BACKEND_SLEEF)
+                            ? sizeof(self->value.sleef_value)
+                            : sizeof(self->value.longdouble_value);
+    const unsigned char *src = (self->backend == BACKEND_SLEEF)
+                                       ? (const unsigned char *)&self->value.sleef_value
+                                       : (const unsigned char *)&self->value.longdouble_value;
+
+    unsigned char raw[sizeof(quad_value)];
+    quad_copy_canonical(raw, src, nbytes);
+
+    PyObject *data = PyBytes_FromStringAndSize((const char *)raw, (Py_ssize_t)nbytes);
+    if (data == NULL) {
         return NULL;
     }
 
     PyObject *backend_obj = PyUnicode_FromString(
             self->backend == BACKEND_SLEEF ? "sleef" : "longdouble");
     if (backend_obj == NULL) {
-        Py_DECREF(str_value);
+        Py_DECREF(data);
         return NULL;
     }
 
-    PyObject *args = PyTuple_Pack(2, str_value, backend_obj);
-    Py_DECREF(str_value);
+    PyObject *module = PyImport_ImportModule("numpy_quaddtype._quaddtype_main");
+    if (module == NULL) {
+        Py_DECREF(data);
+        Py_DECREF(backend_obj);
+        return NULL;
+    }
+    PyObject *reconstruct = PyObject_GetAttrString(module, "from_raw_bytes");
+    Py_DECREF(module);
+    if (reconstruct == NULL) {
+        Py_DECREF(data);
+        Py_DECREF(backend_obj);
+        return NULL;
+    }
+
+    PyObject *args = PyTuple_Pack(2, data, backend_obj);
+    Py_DECREF(data);
     Py_DECREF(backend_obj);
     if (args == NULL) {
+        Py_DECREF(reconstruct);
         return NULL;
     }
 
-    PyObject *type_obj = (PyObject *)Py_TYPE(self);
-    Py_INCREF(type_obj);
-    PyObject *result = PyTuple_Pack(2, type_obj, args);
-    Py_DECREF(type_obj);
+    PyObject *result = PyTuple_Pack(2, reconstruct, args);
+    Py_DECREF(reconstruct);
     Py_DECREF(args);
     return result;
 }
 
+PyObject *
+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)) {
+        return NULL;
+    }
+
+    QuadBackendType backend = BACKEND_SLEEF;
+    if (strcmp(backend_str, "longdouble") == 0) {
+        backend = BACKEND_LONGDOUBLE;
+    }
+    else if (strcmp(backend_str, "sleef") != 0) {
+        PyBuffer_Release(&view);
+        PyErr_SetString(PyExc_ValueError, "Invalid backend. Use 'sleef' or 'longdouble'.");
+        return NULL;
+    }
+
+    size_t expected = (backend == BACKEND_SLEEF) ? sizeof(Sleef_quad) : sizeof(long double);
+    if (view.len != (Py_ssize_t)expected) {
+        PyErr_Format(PyExc_ValueError,
+                     "QuadPrecision.from_raw_bytes expected %zu bytes for the '%s' "
+                     "backend, got %zd",
+                     expected, backend_str, view.len);
+        PyBuffer_Release(&view);
+        return NULL;
+    }
+
+    QuadPrecisionObject *self = QuadPrecision_raw_new(backend);
+    if (self == NULL) {
+        PyBuffer_Release(&view);
+        return NULL;
+    }
+    unsigned char *dst = (backend == BACKEND_SLEEF)
+                                 ? (unsigned char *)&self->value.sleef_value
+                                 : (unsigned char *)&self->value.longdouble_value;
+    quad_copy_canonical(dst, (const unsigned char *)view.buf, expected);
+    PyBuffer_Release(&view);
+    return (PyObject *)self;
+}
+
 static PyMethodDef QuadPrecision_methods[] = {
     {"is_integer", (PyCFunction)QuadPrecision_is_integer, METH_NOARGS,
      "Return True if the value is an integer."},
     {"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 (QuadPrecision, (str_value, backend))."},
+     "Support pickling: return (from_raw_bytes, (raw_bytes, backend))."},
     {NULL, NULL, 0, NULL}  /* Sentinel */
 };
 

src/include/constants.hpp

@@ -9,15 +9,6 @@ extern "C" {
 #include <sleefquad.h>
 #include <stdint.h>
 #include <string.h>
-#include <float.h>
-
-/* LDBL_DECIMAL_DIG: minimum decimal digits needed for a lossless
- * long-double → string → long-double round-trip. Standard C11 constant in
- * <float.h>, but MSVC omits it. On MSVC long double is the same width as
- * double, so DBL_DECIMAL_DIG (17) is the exact correct fallback. */
-#ifndef LDBL_DECIMAL_DIG
-#  define LDBL_DECIMAL_DIG DBL_DECIMAL_DIG
-#endif
 
 // Quad precision constants using sleef_q macro
 #define QUAD_PRECISION_ZERO sleef_q(+0x0000000000000LL, 0x0000000000000000ULL, -16383)