post-cleaning

Author: SwayamInSync

quaddtype/meson.build

@@ -1,10 +1,11 @@
 from ._quaddtype_main import (
     QuadPrecision,
-    QuadPrecDType
+    QuadPrecDType,
+    is_longdouble_128
 )
 
 __all__ = ['QuadPrecision', 'QuadPrecDType', 'SleefQuadPrecision', 'LongDoubleQuadPrecision',
-           'SleefQuadPrecDType', 'LongDoubleQuadPrecDType']
+           'SleefQuadPrecDType', 'LongDoubleQuadPrecDType', 'is_longdouble_128']
 
 
 def SleefQuadPrecision(value):

quaddtype/numpy_quaddtype/__init__.py

@@ -272,15 +272,15 @@ numpy_to_quad_resolve_descriptors(PyObject *NPY_UNUSED(self), PyArray_DTypeMeta
                                   PyArray_Descr *given_descrs[2], PyArray_Descr *loop_descrs[2],
                                   npy_intp *view_offset)
 {
-    printf("cast.cpp: numpy_to_quad_resolve_descriptors is called\n");
+
     if (given_descrs[1] == NULL) {
         loop_descrs[1] = (PyArray_Descr *)new_quaddtype_instance(BACKEND_SLEEF);
         if (loop_descrs[1] == nullptr) {
             return (NPY_CASTING)-1;
         }
     }
     else {
-        printf("cast.cpp: numpy_to_quad_resolve_descriptors, I am in ELSE condition\n");
+
         Py_INCREF(given_descrs[1]);
         loop_descrs[1] = given_descrs[1];
     }
@@ -299,12 +299,8 @@ numpy_to_quad_strided_loop(PyArrayMethod_Context *context, char *const data[],
     char *in_ptr = data[0];
     char *out_ptr = data[1];
 
-    QuadPrecDTypeObject *descr_out1 = (QuadPrecDTypeObject *)context->descriptors[0];
-    printf("The type of context->descriptor[0] is: %s\n", Py_TYPE(descr_out1)->tp_name);
     QuadPrecDTypeObject *descr_out = (QuadPrecDTypeObject *)context->descriptors[1];
-    printf("The type of context->descriptor[1] is: %s\n", Py_TYPE(descr_out)->tp_name);
     QuadBackendType backend = descr_out->backend;
-    printf("cast.cpp: numpy_to_quad_strided_loop with backend: %d\n", backend);
     size_t elem_size = (backend == BACKEND_SLEEF) ? sizeof(Sleef_quad) : sizeof(long double);
 
     while (N--) {

quaddtype/numpy_quaddtype/src/casts.cpp

@@ -49,13 +49,13 @@ quad_store(char *data_ptr, void *x, QuadBackendType backend)
 QuadPrecDTypeObject *
 new_quaddtype_instance(QuadBackendType backend)
 {
-    // if (backend != BACKEND_SLEEF && backend != BACKEND_LONGDOUBLE)
-    // {
-    //     PyErr_SetString(PyExc_TypeError,
-    //                     "Backend must be sleef or longdouble");
-    //     return NULL;
-    // }
-    printf("New Quandtype instance is created with backend: %d\n", backend);
+    if (backend != BACKEND_SLEEF && backend != BACKEND_LONGDOUBLE)
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "Backend must be sleef or longdouble");
+        return NULL;
+    }
+
     QuadPrecDTypeObject *new = (QuadPrecDTypeObject *)PyArrayDescr_Type.tp_new(
             (PyTypeObject *)&QuadPrecDType, NULL, NULL);
     if (new == NULL) {
@@ -70,15 +70,15 @@ new_quaddtype_instance(QuadBackendType backend)
 static QuadPrecDTypeObject *
 ensure_canonical(QuadPrecDTypeObject *self)
 {
-    printf("Ensure Canonical is called\n");
+
     Py_INCREF(self);
     return self;
 }
 
 static QuadPrecDTypeObject *
 common_instance(QuadPrecDTypeObject *dtype1, QuadPrecDTypeObject *dtype2)
 {
-    printf("Common Instance is called\n");
+
     if (dtype1->backend != dtype2->backend) {
         PyErr_SetString(PyExc_TypeError,
                         "Cannot find common instance for QuadPrecDTypes with different backends");
@@ -91,7 +91,7 @@ common_instance(QuadPrecDTypeObject *dtype1, QuadPrecDTypeObject *dtype2)
 static PyArray_DTypeMeta *
 common_dtype(PyArray_DTypeMeta *cls, PyArray_DTypeMeta *other)
 {
-    printf("Common dtype is called\n");
+
     // Promote integer and floating-point types to QuadPrecDType
     if (other->type_num >= 0 &&
         (PyTypeNum_ISINTEGER(other->type_num) || PyTypeNum_ISFLOAT(other->type_num))) {
@@ -117,7 +117,7 @@ quadprec_discover_descriptor_from_pyobject(PyArray_DTypeMeta *NPY_UNUSED(cls), P
     }
 
     QuadPrecisionObject *quad_obj = (QuadPrecisionObject *)obj;
-    printf("dtype.c: quadprec_discover_descriptor_from_pyobject is called with backend %d\n", quad_obj->backend);
+
     return (PyArray_Descr *)new_quaddtype_instance(quad_obj->backend);
 }
 
@@ -168,10 +168,7 @@ quadprec_getitem(QuadPrecDTypeObject *descr, char *dataptr)
 static PyArray_Descr *
 quadprec_default_descr(PyArray_DTypeMeta *cls)
 {
-    QuadPrecDTypeObject * a = (QuadPrecDTypeObject *)cls;
-     printf("Default descriptor called with backend: %d\n", a->backend);
-    QuadPrecDTypeObject * temp = new_quaddtype_instance(a->backend);
-    printf("Default descriptor made backend: %d\n", temp->backend);
+    QuadPrecDTypeObject * temp = new_quaddtype_instance(BACKEND_SLEEF);
     return (PyArray_Descr *)temp;
 }
 

quaddtype/numpy_quaddtype/src/dtype.c

@@ -13,12 +13,29 @@
 #include "dtype.h"
 #include "umath.h"
 #include "quad_common.h"
+#include "float.h"
+
+static PyObject* py_is_longdouble_128(PyObject* self, PyObject* args) {
+    if(sizeof(long double) == 16 && 
+        LDBL_MANT_DIG == 113 && 
+        LDBL_MAX_EXP == 16384) {
+        Py_RETURN_TRUE;
+    } else {
+        Py_RETURN_FALSE;
+    }
+}
+
+static PyMethodDef module_methods[] = {
+    {"is_longdouble_128", py_is_longdouble_128, METH_NOARGS, "Check if long double is 128-bit"},
+    {NULL, NULL, 0, NULL} 
+};
 
 static struct PyModuleDef moduledef = {
         PyModuleDef_HEAD_INIT,
         .m_name = "_quaddtype_main",
         .m_doc = "Quad (128-bit) floating point Data Type for NumPy with multiple backends",
         .m_size = -1,
+        .m_methods = module_methods
 };
 
 PyMODINIT_FUNC

quaddtype/numpy_quaddtype/src/quaddtype_main.c

@@ -227,26 +227,21 @@ quad_binary_op_resolve_descriptors(PyObject *self, PyArray_DTypeMeta *const dtyp
                                    PyArray_Descr *const given_descrs[],
                                    PyArray_Descr *loop_descrs[], npy_intp *NPY_UNUSED(view_offset))
 {
-    printf("Descriptor Resolver is called\n");
 
     QuadPrecDTypeObject *descr_in1 = (QuadPrecDTypeObject *)given_descrs[0];
     QuadPrecDTypeObject *descr_in2 = (QuadPrecDTypeObject *)given_descrs[1];
     QuadBackendType target_backend;
 
     const char *s1 = (descr_in1->backend == BACKEND_SLEEF) ? "SLEEF" : "LONGDOUBLE";
     const char *s2 = (descr_in2->backend == BACKEND_SLEEF) ? "SLEEF" : "LONGDOUBLE";
-    printf("1: %s   %d  %s\n", s1, descr_in1->backend, Py_TYPE(given_descrs[0])->tp_name);
-    printf("2: %s   %d  %s\n", s2, descr_in2->backend, Py_TYPE(given_descrs[1])->tp_name);
 
     // Determine target backend and if casting is needed
     NPY_CASTING casting = NPY_NO_CASTING;
     if (descr_in1->backend != descr_in2->backend) {
         target_backend = BACKEND_LONGDOUBLE;
         casting = NPY_SAFE_CASTING;
-        printf("Different backends detected. Casting to LONGDOUBLE.\n");
     } else {
         target_backend = descr_in1->backend;
-        printf("Unified backend: %s\n", (target_backend == BACKEND_SLEEF) ? "SLEEF" : "LONGDOUBLE");
     }
 
     // Set up input descriptors, casting if necessary
@@ -280,8 +275,6 @@ quad_binary_op_resolve_descriptors(PyObject *self, PyArray_DTypeMeta *const dtyp
             loop_descrs[2] = given_descrs[2];
         }
     }
-
-    printf("Casting result: %d\n", casting);
     return casting;
 }
 
@@ -291,7 +284,6 @@ quad_generic_binop_strided_loop(PyArrayMethod_Context *context, char *const data
                                 npy_intp const dimensions[], npy_intp const strides[],
                                 NpyAuxData *auxdata)
 {
-    printf("Umath: Generic Strided loop is calledn\n");
     npy_intp N = dimensions[0];
     char *in1_ptr = data[0], *in2_ptr = data[1];
     char *out_ptr = data[2];
@@ -326,10 +318,6 @@ static int
 quad_ufunc_promoter(PyUFuncObject *ufunc, PyArray_DTypeMeta *op_dtypes[],
                     PyArray_DTypeMeta *signature[], PyArray_DTypeMeta *new_op_dtypes[])
 {
-    printf("quad_ufunc_promoter called for ufunc: %s\n", ufunc->name);
-    printf("Entering quad_ufunc_promoter\n");
-    printf("Ufunc name: %s\n", ufunc->name);
-    printf("nin: %d, nargs: %d\n", ufunc->nin, ufunc->nargs);
 
     int nin = ufunc->nin;
     int nargs = ufunc->nargs;
@@ -343,52 +331,51 @@ quad_ufunc_promoter(PyUFuncObject *ufunc, PyArray_DTypeMeta *op_dtypes[],
         for (int i = 0; i < 3; i++) {
             Py_INCREF(op_dtypes[1]);
             new_op_dtypes[i] = op_dtypes[1];
-            printf("new_op_dtypes[%d] set to %s\n", i, get_dtype_name(new_op_dtypes[i]));
+
         }
         return 0;
     }
 
     // Check if any input or signature is QuadPrecision
     for (int i = 0; i < nin; i++) {
-        printf("iterating on dtype : %s\n", get_dtype_name(op_dtypes[i]));
+
         if (op_dtypes[i] == &QuadPrecDType) {
             has_quad = true;
-            printf("QuadPrecision detected in input %d\n", i);
+
         }
     }
 
     if (has_quad) {
         common = &QuadPrecDType;
-        printf("Using QuadPrecDType as common type\n");
+
     }
     else {
         for (int i = nin; i < nargs; i++) {
             if (signature[i] != NULL) {
                 if (common == NULL) {
                     Py_INCREF(signature[i]);
                     common = signature[i];
-                    printf("Common type set to %s from signature\n", get_dtype_name(common));
+
                 }
                 else if (common != signature[i]) {
                     Py_CLEAR(common);  // Not homogeneous, unset common
-                    printf("Output signature not homogeneous, cleared common type\n");
+
                     break;
                 }
             }
         }
     }
     // If no common output dtype, use standard promotion for inputs
     if (common == NULL) {
-        printf("Using standard promotion for inputs\n");
         common = PyArray_PromoteDTypeSequence(nin, op_dtypes);
         if (common == NULL) {
             if (PyErr_ExceptionMatches(PyExc_TypeError)) {
                 PyErr_Clear();  // Do not propagate normal promotion errors
             }
-            printf("Exiting quad_ufunc_promoter (promotion failed)\n");
+
             return -1;
         }
-        printf("Common type after promotion: %s\n", get_dtype_name(common));
+
     }
 
     // Set all new_op_dtypes to the common dtype
@@ -397,20 +384,16 @@ quad_ufunc_promoter(PyUFuncObject *ufunc, PyArray_DTypeMeta *op_dtypes[],
             // If signature is specified for this argument, use it
             Py_INCREF(signature[i]);
             new_op_dtypes[i] = signature[i];
-            printf("new_op_dtypes[%d] set to %s (from signature)\n", i,
-                   get_dtype_name(new_op_dtypes[i]));
         }
         else {
             // Otherwise, use the common dtype
             Py_INCREF(common);
             new_op_dtypes[i] = common;
-            printf("new_op_dtypes[%d] set to %s (from common)\n", i,
-                   get_dtype_name(new_op_dtypes[i]));
         }
     }
 
     Py_XDECREF(common);
-    printf("Exiting quad_ufunc_promoter\n");
+
     return 0;
 }