refactoring finfo support

Author: SwayamInSync

quaddtype/numpy_quaddtype/__init__.py

@@ -8,14 +8,18 @@
     get_quadblas_version
 )
 
+from dataclasses import dataclass
+
 __all__ = [
     'QuadPrecision', 'QuadPrecDType', 'SleefQuadPrecision', 'LongDoubleQuadPrecision',
     'SleefQuadPrecDType', 'LongDoubleQuadPrecDType', 'is_longdouble_128', 
     # Constants
     'pi', 'e', 'log2e', 'log10e', 'ln2', 'ln10', 'max_value', 'epsilon',
     'smallest_normal', 'smallest_subnormal', 'bits', 'precision', 'resolution',
     # QuadBLAS related functions
-    'set_num_threads', 'get_num_threads', 'get_quadblas_version'
+    'set_num_threads', 'get_num_threads', 'get_quadblas_version',
+    # finfo class
+    'QuadPrecFinfo'
 ]
 
 def SleefQuadPrecision(value):
@@ -43,3 +47,39 @@ def LongDoubleQuadPrecDType():
 bits = get_sleef_constant("bits")
 precision = get_sleef_constant("precision")
 resolution = get_sleef_constant("resolution")
+
+@dataclass
+class QuadPrecFinfo:
+    """Floating-point information for quadruple precision dtype.
+    
+    This class provides information about the floating-point representation
+    used by the QuadPrecDType, similar to numpy.finfo but customized for
+    quad precision arithmetic.
+    """
+    bits: int = int(bits)
+    eps: float = float(epsilon)
+    epsneg: float = float(epsilon)
+    iexp: int = int(precision)
+    machar: object = None
+    machep: float = float(epsilon)
+    max: float = float(max_value)
+    maxexp: float = float(max_value)
+    min: float = float(smallest_normal)
+    minexp: float = float(smallest_normal)
+    negep: float = float(epsilon)
+    nexp: int = int(bits) - int(precision) - 1
+    nmant: int = int(precision)
+    precision: int = int(precision)
+    resolution: float = float(resolution)
+    tiny: float = float(smallest_normal)
+    smallest_normal: float = float(smallest_normal)
+    smallest_subnormal: float = float(smallest_subnormal)
+
+    def get(self, attr):
+        return getattr(self, attr, None)
+    
+    def __str__(self):
+        return f"QuadPrecFinfo(precision={self.precision}, resolution={self.resolution})"
+    
+    def __repr__(self):
+        return f"QuadPrecFinfo(max={self.max}, min={self.min}, eps={self.eps}, bits={self.bits})"

quaddtype/numpy_quaddtype/src/dtype.c

@@ -176,38 +176,6 @@ quadprec_default_descr(PyArray_DTypeMeta *cls)
     return (PyArray_Descr *)temp;
 }
 
-static PyObject *
-quad_finfo(PyArray_Descr *descr, NPY_DTYPE_INFO_TYPE info_type)
-{
-    
-    // Handle the different info types
-   switch (info_type) {
-       case NPY_DTYPE_INFO_FLOAT:
-           {
-               PyObject *finfo_dict = PyDict_New();
-               if (!finfo_dict) return NULL;
-               
-               PyDict_SetItemString(finfo_dict, "precision", PyLong_FromLong(34));
-               PyDict_SetItemString(finfo_dict, "bits", PyLong_FromLong(128));
-               //  more fields
-               return finfo_dict;
-           }
-       case NPY_DTYPE_INFO_INTEGER:
-           // Not implemented yet, could add iinfo support later
-           PyErr_SetString(PyExc_NotImplementedError, 
-                          "Integer info not implemented for this dtype");
-           return NULL;
-       case NPY_DTYPE_INFO_GENERIC:
-           // Not implemented yet, could add generic info later
-           PyErr_SetString(PyExc_NotImplementedError, 
-                          "Generic info not implemented for this dtype");
-           return NULL;
-       default:
-           PyErr_SetString(PyExc_ValueError, "Unknown dtype info type");
-           return NULL;
-   }
-}
-
 static PyType_Slot QuadPrecDType_Slots[] = {
         {NPY_DT_ensure_canonical, &ensure_canonical},
         {NPY_DT_common_instance, &common_instance},
@@ -217,7 +185,6 @@ static PyType_Slot QuadPrecDType_Slots[] = {
         {NPY_DT_getitem, &quadprec_getitem},
         {NPY_DT_default_descr, &quadprec_default_descr},
         {NPY_DT_PyArray_ArrFuncs_dotfunc, NULL},
-        {NPY_DT_get_dtype_info, &quad_finfo},
         {0, NULL}};
 
 static PyObject *
@@ -257,13 +224,42 @@ QuadPrecDType_str(QuadPrecDTypeObject *self)
     return PyUnicode_FromFormat("QuadPrecDType(backend='%s')", backend_str);
 }
 
+static PyObject *
+QuadPrecDType_finfo(QuadPrecDTypeObject *self, PyObject *args)
+{
+    PyObject *numpy_quaddtype_module = PyImport_ImportModule("numpy_quaddtype");
+    if (numpy_quaddtype_module == NULL) {
+        return NULL;
+    }
+    
+    PyObject *finfo_class = PyObject_GetAttrString(numpy_quaddtype_module, "QuadPrecFinfo");
+    Py_DECREF(numpy_quaddtype_module);
+    
+    if (finfo_class == NULL) {
+        PyErr_SetString(PyExc_AttributeError, "Could not find QuadPrecFinfo class in numpy_quaddtype module.");
+        return NULL;
+    }
+    
+    PyObject *finfo_instance = PyObject_CallNoArgs(finfo_class);
+    Py_DECREF(finfo_class);
+    
+    return finfo_instance;
+}
+
+static PyMethodDef QuadPrecDType_methods[] = {
+    {"finfo", (PyCFunction)QuadPrecDType_finfo, METH_NOARGS, 
+     "Return floating-point information for this QuadPrecDType"},
+    {NULL, NULL, 0, NULL}
+};
+
 PyArray_DTypeMeta QuadPrecDType = {
         {{
                 PyVarObject_HEAD_INIT(NULL, 0).tp_name = "numpy_quaddtype.QuadPrecDType",
                 .tp_basicsize = sizeof(QuadPrecDTypeObject),
                 .tp_new = QuadPrecDType_new,
                 .tp_repr = (reprfunc)QuadPrecDType_repr,
                 .tp_str = (reprfunc)QuadPrecDType_str,
+                .tp_methods = QuadPrecDType_methods,
         }},
 };