refactor

Author: SwayamInSync

quaddtype/meson.build

@@ -177,6 +177,8 @@ srcs = [
     'numpy_quaddtype/src/constants.hpp',
     'numpy_quaddtype/src/lock.h',
     'numpy_quaddtype/src/lock.c',
+    'numpy_quaddtype/src/utilities.h',
+    'numpy_quaddtype/src/utilities.c',
 ]
 
 py.install_sources(

quaddtype/numpy_quaddtype/_quaddtype_main.pyi

@@ -8,7 +8,6 @@ _Backend: TypeAlias = Literal["sleef", "longdouble"]
 _IntoQuad: TypeAlias = (
     QuadPrecision
     | float
-    | int
     | str
     | bytes
     | np.floating[Any]

quaddtype/numpy_quaddtype/src/dtype.c

@@ -13,11 +13,13 @@
 #include "numpy/ndarraytypes.h"
 #include "numpy/dtype_api.h"
 
+#include "quad_common.h"
 #include "scalar.h"
 #include "casts.h"
 #include "dtype.h"
 #include "dragon4.h"
 #include "constants.hpp"
+#include "utilities.h"
 
 static inline int
 quad_load(void *x, char *data_ptr, QuadBackendType backend)
@@ -353,19 +355,16 @@ quadprec_scanfunc(FILE *fp, void *dptr, char *ignore, PyArray_Descr *descr_gener
 
     /* Convert string to quad precision */
     char *endptr;
+    quad_value val;
+    cstring_to_quad(buffer, descr->backend, &val, &endptr);
+    if (endptr == buffer) {
+        return 0;  /* Return 0 on parse error (no items read) */
+    }
     if (descr->backend == BACKEND_SLEEF) {
-        Sleef_quad val = Sleef_strtoq(buffer, &endptr);
-        if (endptr == buffer) {
-            return 0;  /* Return 0 on parse error (no items read) */
-        }
-        *(Sleef_quad *)dptr = val;
+        *(Sleef_quad *)dptr = val.sleef_value;
     }
     else {
-        long double val = strtold(buffer, &endptr);
-        if (endptr == buffer) {
-            return 0;  /* Return 0 on parse error (no items read) */
-        }
-        *(long double *)dptr = val;
+       *(long double *)dptr = val.longdouble_value;
     }
 
     return 1;  /* Return 1 on success (1 item read) */
@@ -375,22 +374,17 @@ static int
 quadprec_fromstr(char *s, void *dptr, char **endptr, PyArray_Descr *descr_generic)
 {
     QuadPrecDTypeObject *descr = (QuadPrecDTypeObject *)descr_generic;
-    
-    if (descr->backend == BACKEND_SLEEF) {
-        Sleef_quad val = Sleef_strtoq(s, endptr);
-        if (*endptr == s) {
-            return -1;
-        }
-        *(Sleef_quad *)dptr = val;
+    quad_value val;
+    cstring_to_quad(s, descr->backend, &val, endptr);
+    if (*endptr == s) {
+        return -1;
+    }
+    if(descr->backend == BACKEND_SLEEF) {
+        *(Sleef_quad *)dptr = val.sleef_value;
     }
     else {
-        long double val = strtold(s, endptr);
-        if (*endptr == s) {
-            return -1;
-        }
-        *(long double *)dptr = val;
+        *(long double *)dptr = val.longdouble_value;
     }
-    
     return 0;
 }
 

quaddtype/numpy_quaddtype/src/quad_common.h

@@ -5,12 +5,20 @@
 extern "C" {
 #endif
 
+#include <sleef.h>
+#include <sleefquad.h>
+
 typedef enum {
     BACKEND_INVALID = -1,
     BACKEND_SLEEF,
     BACKEND_LONGDOUBLE
 } QuadBackendType;
 
+typedef union {
+    Sleef_quad sleef_value;
+    long double longdouble_value;
+} quad_value;
+
 #ifdef __cplusplus
 }
 #endif

quaddtype/numpy_quaddtype/src/scalar.c

@@ -16,6 +16,7 @@
 #include "dragon4.h"
 #include "dtype.h"
 #include "lock.h"
+#include "utilities.h"
 
 // For IEEE 754 binary128 (quad precision), we need 36 decimal digits 
 // to guarantee round-trip conversion (string -> parse -> equals original value)
@@ -196,12 +197,7 @@ QuadPrecision_from_object(PyObject *value, QuadBackendType backend)
     else if (PyUnicode_Check(value)) {
         const char *s = PyUnicode_AsUTF8(value);
         char *endptr = NULL;
-        if (backend == BACKEND_SLEEF) {
-            self->value.sleef_value = Sleef_strtoq(s, &endptr);
-        }
-        else {
-            self->value.longdouble_value = strtold(s, &endptr);
-        }
+        cstring_to_quad(s, backend, &self->value, &endptr);
         if (*endptr != '\0' || endptr == s) {
             PyErr_SetString(PyExc_ValueError, "Unable to parse string to QuadPrecision");
             Py_DECREF(self);
@@ -215,12 +211,7 @@ QuadPrecision_from_object(PyObject *value, QuadBackendType backend)
             return NULL;
         }
         char *endptr = NULL;
-        if (backend == BACKEND_SLEEF) {
-            self->value.sleef_value = Sleef_strtoq(s, &endptr);
-        }
-        else {
-            self->value.longdouble_value = strtold(s, &endptr);
-        }
+        cstring_to_quad(s, backend, &self->value, &endptr);
         if (*endptr != '\0' || endptr == s) {
             PyErr_SetString(PyExc_ValueError, "Unable to parse bytes to QuadPrecision");
             Py_DECREF(self);

quaddtype/numpy_quaddtype/src/scalar.h

@@ -9,11 +9,6 @@ extern "C" {
 #include <sleef.h>
 #include "quad_common.h"
 
-typedef union {
-    Sleef_quad sleef_value;
-    long double longdouble_value;
-} quad_value;
-
 typedef struct {
     PyObject_HEAD
     quad_value value;

quaddtype/numpy_quaddtype/src/utilities.c

@@ -0,0 +1,13 @@
+#include "utilities.h"
+
+void cstring_to_quad(const char *str, QuadBackendType backend, quad_value *out_value, char **endptr)
+{
+  if(backend == BACKEND_SLEEF)
+  {
+    out_value->sleef_value = Sleef_strtoq(str, endptr);
+  }
+  else
+  {
+    out_value->longdouble_value = strtold(str, endptr);
+  }
+}

quaddtype/numpy_quaddtype/src/utilities.h

@@ -0,0 +1,10 @@
+#ifndef QUAD_UTILITIES_H
+#define QUAD_UTILITIES_H
+
+#include "quad_common.h"
+#include <sleef.h>
+#include <sleefquad.h>
+
+void cstring_to_quad(const char *str, QuadBackendType backend, quad_value *out_value, char **endptr);
+
+#endif