initial commit, adding Float128 dtype

Author: SwayamInSync

quaddtype2/README.md

@@ -0,0 +1,25 @@
+[build-system]
+requires = [
+    "meson>=1.3.2",
+    "meson-python",
+    "patchelf",
+    "wheel",
+    "numpy"
+]
+build-backend = "mesonpy"
+
+[project]
+name = "quaddtype"
+description = "Quad (128-bit) float dtype for numpy"
+version = "0.0.1"
+readme = 'README.md'
+author = "Swayam Singh"
+requires-python = ">=3.9.0"
+dependencies = [
+    "numpy"
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+]

quaddtype2/pyproject.toml

@@ -0,0 +1,4 @@
+from .scalar import QuadScalar
+from ._quaddtype_main import QuadDType
+
+__all__ = ["QuadScalar", "QuadDType"]

quaddtype2/quaddtype/__init__.py

@@ -0,0 +1,11 @@
+"""Quad scalar floating point type for numpy."""
+
+
+class QuadScalar:
+    """Quad scalar floating point type."""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __repr__(self):
+        return f"{self.value}"

quaddtype2/quaddtype/scalar.py

@@ -0,0 +1,87 @@
+#include <Python.h>
+
+#define PY_ARRAY_UNIQUE_SYMBOL quaddtype_ARRAY_API
+#define PY_UFUNC_UNIQUE_SYMBOL quaddtype_UFUNC_API
+#define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION
+#define NPY_TARGET_VERSION NPY_2_0_API_VERSION
+#define NO_IMPORT_ARRAY
+#define NO_IMPORT_UFUNC
+#include "numpy/ndarraytypes.h"
+#include "numpy/arrayobject.h"
+#include "numpy/dtype_api.h"
+
+#include "dtype.h"
+
+
+PyTypeObject *QuadScalar_Type = NULL;
+
+QuadDTypeObject *new_quaddtype_instance(void)
+{
+    QuadDTypeObject *new =
+            (QuadDTypeObject *)PyArrayDescr_Type.tp_new((PyTypeObject *)&QuadDType, NULL, NULL);
+    if (new == NULL) {
+        return NULL;
+    }
+
+    new->base.elsize = sizeof(__float128);
+    new->base.alignment = _Alignof(__float128);
+    return new;
+}
+
+static PyObject *quaddtype_new(PyTypeObject *NPY_UNUSED(cls), PyObject *args, PyObject *kwargs)
+{
+    return (PyObject *)new_quaddtype_instance();
+}
+
+static void quaddtype_dealloc(QuadDTypeObject *self)
+{
+    PyArrayDescr_Type.tp_dealloc((PyObject *)self);
+}
+
+static PyObject *quaddtype_repr(QuadDTypeObject *self)
+{
+    PyObject *res = PyUnicode_FromString("This is a quad (128-bit float) dtype.");
+    return res;
+}
+
+PyArray_DTypeMeta QuadDType = {
+        {{
+                PyVarObject_HEAD_INIT(NULL, 0).tp_name = "quaddtype.QuadDType",
+                .tp_basicsize = sizeof(QuadDTypeObject),
+                .tp_new = quaddtype_new,
+                .tp_dealloc = (destructor)quaddtype_dealloc,
+                .tp_repr = (reprfunc)quaddtype_repr,
+                .tp_str = (reprfunc)quaddtype_repr,
+        }},
+};
+
+int init_quad_dtype(void)
+{
+    PyArrayMethod_Spec *casts[] = {
+            NULL,
+    };
+
+    PyArrayDTypeMeta_Spec QuadDType_DTypeSpec = {
+            .flags = NPY_DT_NUMERIC,
+            .casts = casts,
+            .typeobj = QuadScalar_Type,
+            .slots = NULL,
+    };
+
+    ((PyObject *)&QuadDType)->ob_type = &PyArrayDTypeMeta_Type;
+    ((PyTypeObject *)&QuadDType)->tp_base = &PyArrayDescr_Type;
+    if (PyType_Ready((PyTypeObject *)&QuadDType) < 0) {
+        return -1;
+    }
+
+    if (PyArrayInitDTypeMeta_FromSpec(&QuadDType, &QuadDType_DTypeSpec) < 0) {
+        return -1;
+    }
+
+    QuadDType.singleton = PyArray_GetDefaultDescr(&QuadDType);
+    return 0;
+}
+
+
+
+

quaddtype2/quaddtype/src/dtype.c

@@ -0,0 +1,21 @@
+#ifndef _NPY_DTYPE_H
+#define _NPY_DTYPE_H
+
+#include<Python.h>
+#include<numpy/ndarraytypes.h>
+#include<numpy/dtype_api.h>
+
+typedef struct
+{
+    PyArray_Descr base;
+    
+} QuadDTypeObject;
+
+extern PyArray_DTypeMeta QuadDType;
+extern PyTypeObject *QuadScalar_Type;
+
+QuadDTypeObject * new_quaddtype_instance(void);
+
+int init_quad_dtype(void);
+
+#endif

quaddtype2/quaddtype/src/dtype.h

@@ -0,0 +1,57 @@
+#include <Python.h>
+
+#define PY_ARRAY_UNIQUE_SYMBOL quaddtype_ARRAY_API
+#define PY_UFUNC_UNIQUE_SYMBOL quaddtype_UFUNC_API
+#define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION
+#include "numpy/arrayobject.h"
+#include "numpy/dtype_api.h"
+
+#include "dtype.h"
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        .m_name = "quaddtype_main",
+        .m_doc = "Quad (128-bit) floating point Data Type for Numpy",
+        .m_size = -1,
+};
+
+PyMODINIT_FUNC
+PyInit__quaddtype_main(void)
+{
+    import_array();
+
+    PyObject *m = PyModule_Create(&moduledef);
+    if (m == NULL) {
+        PyErr_SetString(PyExc_ImportError, "Unable to create the quaddtype_main module.");
+        return NULL;
+    }
+
+    PyObject *mod = PyImport_ImportModule("quaddtype");
+    if (mod == NULL) {
+        PyErr_SetString(PyExc_ImportError, "Unable to import the quaddtype module.");
+        goto error;
+    }
+    QuadScalar_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "QuadScalar");
+    Py_DECREF(mod);
+    if (QuadScalar_Type == NULL) {
+        PyErr_SetString(PyExc_AttributeError,
+                        "Unable to find QuadScalar attribute in the "
+                        "quaddtype_main module.");
+        goto error;
+    }
+    if (init_quad_dtype() < 0) {
+        PyErr_SetString(PyExc_AttributeError, "QuadDType failed to initialize.");
+        goto error;
+    }
+    if (PyModule_AddObject(m, "QuadDType", (PyObject *)&QuadDType) < 0) {
+        PyErr_SetString(PyExc_TypeError, "Failed to add QuadDType to the quaddtype_main module.");
+        goto error;
+    }
+
+
+    return m;
+
+error:
+    Py_DECREF(m);
+    return NULL;
+}