merge conf

Author: SwayamInSync

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: github-actions
+  directory: /
+  schedule:
+    interval: weekly
+  labels: [dependabot]
+  commit-message:
+    prefix: "🤖"
+  groups:
+    actions:
+      patterns: ["*"]

quaddtype/numpy_quaddtype/__init__.py

@@ -8,6 +8,8 @@
     get_quadblas_version
 )
 
+__version__ = "0.2.0"
+
 __all__ = [
     'QuadPrecision', 'QuadPrecDType', 'SleefQuadPrecision', 'LongDoubleQuadPrecision',
     'SleefQuadPrecDType', 'LongDoubleQuadPrecDType', 'is_longdouble_128', 

quaddtype/numpy_quaddtype/_quaddtype_main.pyi

@@ -4,8 +4,14 @@ import numpy as np
 from typing_extensions import Never, Self, override
 
 _Backend: TypeAlias = Literal["sleef", "longdouble"]
-_IntoQuad: TypeAlias = QuadPrecision | float | str
-_CastsQuad: TypeAlias = _IntoQuad | np.floating[Any] | np.integer[Any] | np.bool_
+_IntoQuad: TypeAlias = (
+    QuadPrecision
+    | float
+    | str
+    | np.floating[Any]
+    | np.integer[Any]
+    | np.bool_
+)  # fmt: skip
 
 @final
 class QuadPrecDType(np.dtype[QuadPrecision]):  # type: ignore[misc, type-var]  # pyright: ignore[reportGeneralTypeIssues, reportInvalidTypeArguments]
@@ -64,8 +70,15 @@ class QuadPrecDType(np.dtype[QuadPrecision]):  # type: ignore[misc, type-var]  #
     @override
     def __getitem__(self, key: Never, /) -> Self: ...  # type: ignore[override]
 
+# NOTE: Until `QuadPrecision` will become a subclass of `np.generic`, this class cannot
+# be considered "type-safe".
 @final
-class QuadPrecision:  # NOTE: It doesn't inherit from `np.generic` which is type-unsafe
+class QuadPrecision:
+    # NOTE: At runtime this constructor also accepts array-likes, for which it returns
+    # `np.ndarray` instances with `dtype=QuadPrecDType()`.
+    # But because of mypy limitations, it is currently impossible to annotate
+    # constructors that do no return instances of their class (or a subclass thereof).
+    # See https://github.com/python/mypy/issues/18343#issuecomment-2571784915
     def __new__(cls, /, value: _IntoQuad, backend: _Backend = "sleef") -> Self: ...
 
     # Rich comparison operators
@@ -80,16 +93,16 @@ class QuadPrecision:  # NOTE: It doesn't inherit from `np.generic` which is type
     def __ge__(self, other: _IntoQuad, /) -> bool: ...
 
     # Binary operators
-    def __add__(self, other: _CastsQuad, /) -> Self: ...
-    def __radd__(self, other: _CastsQuad, /) -> Self: ...
-    def __sub__(self, other: _CastsQuad, /) -> Self: ...
-    def __rsub__(self, other: _CastsQuad, /) -> Self: ...
-    def __mul__(self, other: _CastsQuad, /) -> Self: ...
-    def __rmul__(self, other: _CastsQuad, /) -> Self: ...
-    def __pow__(self, other: _CastsQuad, mod: None = None, /) -> Self: ...
-    def __rpow__(self, other: _CastsQuad, mod: None = None, /) -> Self: ...
-    def __truediv__(self, other: _CastsQuad, /) -> Self: ...
-    def __rtruediv__(self, other: _CastsQuad, /) -> Self: ...
+    def __add__(self, other: _IntoQuad, /) -> Self: ...
+    def __radd__(self, other: _IntoQuad, /) -> Self: ...
+    def __sub__(self, other: _IntoQuad, /) -> Self: ...
+    def __rsub__(self, other: _IntoQuad, /) -> Self: ...
+    def __mul__(self, other: _IntoQuad, /) -> Self: ...
+    def __rmul__(self, other: _IntoQuad, /) -> Self: ...
+    def __pow__(self, other: _IntoQuad, mod: None = None, /) -> Self: ...
+    def __rpow__(self, other: _IntoQuad, mod: None = None, /) -> Self: ...
+    def __truediv__(self, other: _IntoQuad, /) -> Self: ...
+    def __rtruediv__(self, other: _IntoQuad, /) -> Self: ...
 
     # Unary operators
     def __neg__(self, /) -> Self: ...

quaddtype/numpy_quaddtype/src/scalar.c

@@ -87,6 +87,24 @@ QuadPrecision_from_object(PyObject *value, QuadBackendType backend)
             }
             return self;
         }
+        // Try as boolean
+        else if (PyArray_IsScalar(value, Bool)) {
+            PyObject *py_int = PyNumber_Long(value);
+            if (py_int == NULL) {
+                Py_DECREF(self);
+                return NULL;
+            }
+            long long lval = PyLong_AsLongLong(py_int);
+            Py_DECREF(py_int);
+            
+            if (backend == BACKEND_SLEEF) {
+                self->value.sleef_value = Sleef_cast_from_int64q1(lval);
+            }
+            else {
+                self->value.longdouble_value = (long double)lval;
+            }
+            return self;
+        }
         // For other scalar types, fall through to error handling
         Py_DECREF(self);
     }
@@ -351,6 +369,26 @@ static PyBufferProcs QuadPrecision_as_buffer = {
     .bf_releasebuffer = NULL,
 };
 
+static PyObject *
+QuadPrecision_get_real(QuadPrecisionObject *self, void *closure)
+{
+    Py_INCREF(self);
+    return (PyObject *)self;
+}
+
+static PyObject *
+QuadPrecision_get_imag(QuadPrecisionObject *self, void *closure)
+{
+    // For real floating-point types, the imaginary part is always 0
+    return (PyObject *)QuadPrecision_raw_new(self->backend);
+}
+
+static PyGetSetDef QuadPrecision_getset[] = {
+    {"real", (getter)QuadPrecision_get_real, NULL, "Real part of the scalar", NULL},
+    {"imag", (getter)QuadPrecision_get_imag, NULL, "Imaginary part of the scalar (always 0 for real types)", NULL},
+    {NULL}  /* Sentinel */
+};
+
 PyTypeObject QuadPrecision_Type = {
         PyVarObject_HEAD_INIT(NULL, 0).tp_name = "numpy_quaddtype.QuadPrecision",
         .tp_basicsize = sizeof(QuadPrecisionObject),
@@ -362,6 +400,7 @@ PyTypeObject QuadPrecision_Type = {
         .tp_as_number = &quad_as_scalar,
         .tp_as_buffer = &QuadPrecision_as_buffer,
         .tp_richcompare = (richcmpfunc)quad_richcompare,
+        .tp_getset = QuadPrecision_getset,
 };
 
 int

quaddtype/tests/test_quaddtype.py

@@ -134,6 +134,18 @@ def test_create_from_numpy_float_scalars(self):
         assert isinstance(result, QuadPrecision)
         assert abs(float(result) - 1.5) < 1e-3
 
+    def test_create_from_numpy_bool_scalars(self):
+        """Test that QuadPrecision can create scalars from numpy boolean types."""
+        # Test np.bool_(True) converts to 1.0
+        result = QuadPrecision(np.bool_(True))
+        assert isinstance(result, QuadPrecision)
+        assert float(result) == 1.0
+        
+        # Test np.bool_(False) converts to 0.0
+        result = QuadPrecision(np.bool_(False))
+        assert isinstance(result, QuadPrecision)
+        assert float(result) == 0.0
+
     def test_create_from_zero_dimensional_array(self):
         """Test that QuadPrecision can create from 0-d numpy arrays."""
         # 0-d array from scalar
@@ -3076,4 +3088,11 @@ def test_frexp_very_small(self):
         # Verify reconstruction using ldexp (preserves full quad precision)
         reconstructed = np.ldexp(quad_m, int(quad_e))
         assert reconstructed == quad_x, \
-            f"Reconstruction failed for small value: {reconstructed} != {quad_x}"
+            f"Reconstruction failed for small value: {reconstructed} != {quad_x}"
+# testng buffer
+def test_buffer():
+    a = QuadPrecision(1.0)
+    buff = a.data
+
+    reconstructed = np.frombuffer(buff, dtype=QuadPrecDType())[0]
+    assert reconstructed == a, "Buffer reconstruction failed"