numpy-quaddtype 1.0.0__cp314-cp314t-macosx_15_0_arm64.whl

numpy_quaddtype/__init__.py

@@ -0,0 +1,61 @@
+import enum
+from importlib.metadata import version, PackageNotFoundError
+
+from ._quaddtype_main import (
+    QuadPrecision,
+    QuadPrecDType,
+    is_longdouble_128,
+    get_sleef_constant,
+    set_num_threads,
+    get_num_threads,
+    get_quadblas_version
+)
+
+try:
+    __version__ = version("numpy_quaddtype")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+
+class QuadBackend(enum.IntEnum):
+    """Backend type for QuadPrecision computations."""
+    SLEEF = 0
+    LONGDOUBLE = 1
+
+
+__all__ = [
+    'QuadPrecision', 'QuadPrecDType', 'QuadBackend',
+    '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'
+]
+
+def SleefQuadPrecision(value):
+    return QuadPrecision(value, backend='sleef')
+
+def LongDoubleQuadPrecision(value):
+    return QuadPrecision(value, backend='longdouble')
+
+def SleefQuadPrecDType():
+    return QuadPrecDType(backend='sleef')
+
+def LongDoubleQuadPrecDType():
+    return QuadPrecDType(backend='longdouble')
+
+pi = get_sleef_constant("pi")
+e = get_sleef_constant("e")
+log2e = get_sleef_constant("log2e")
+log10e = get_sleef_constant("log10e")
+ln2 = get_sleef_constant("ln2")
+ln10 = get_sleef_constant("ln10")
+max_value = get_sleef_constant("max_value")
+epsilon = get_sleef_constant("epsilon")
+smallest_normal = get_sleef_constant("smallest_normal")
+smallest_subnormal = get_sleef_constant("smallest_subnormal")
+bits = get_sleef_constant("bits")
+precision = get_sleef_constant("precision")
+resolution = get_sleef_constant("resolution")

numpy_quaddtype/__init__.pyi

@@ -0,0 +1,64 @@
+from typing import Final
+import enum
+
+from ._quaddtype_main import (
+    QuadPrecDType,
+    QuadPrecision,
+    _IntoQuad,  # type-check only  # pyright: ignore[reportPrivateUsage]
+    get_num_threads,
+    get_quadblas_version,
+    is_longdouble_128,
+    set_num_threads,
+)
+
+class QuadBackend(enum.IntEnum):
+    SLEEF = 0
+    LONGDOUBLE = 1
+
+__all__ = [
+    "QuadPrecision",
+    "QuadPrecDType",
+    "QuadBackend",
+    "SleefQuadPrecision",
+    "LongDoubleQuadPrecision",
+    "SleefQuadPrecDType",
+    "LongDoubleQuadPrecDType",
+    "is_longdouble_128",
+    "pi",
+    "e",
+    "log2e",
+    "log10e",
+    "ln2",
+    "ln10",
+    "max_value",
+    "epsilon",
+    "smallest_normal",
+    "smallest_subnormal",
+    "bits",
+    "precision",
+    "resolution",
+    "set_num_threads",
+    "get_num_threads",
+    "get_quadblas_version",
+]
+
+__version__: Final[str] = ...
+
+def SleefQuadPrecision(value: _IntoQuad) -> QuadPrecision: ...
+def LongDoubleQuadPrecision(value: _IntoQuad) -> QuadPrecision: ...
+def SleefQuadPrecDType() -> QuadPrecDType: ...
+def LongDoubleQuadPrecDType() -> QuadPrecDType: ...
+
+pi: Final[QuadPrecision] = ...
+e: Final[QuadPrecision] = ...
+log2e: Final[QuadPrecision] = ...
+log10e: Final[QuadPrecision] = ...
+ln2: Final[QuadPrecision] = ...
+ln10: Final[QuadPrecision] = ...
+max_value: Final[QuadPrecision] = ...
+epsilon: Final[QuadPrecision] = ...
+smallest_normal: Final[QuadPrecision] = ...
+smallest_subnormal: Final[QuadPrecision] = ...
+resolution: Final[QuadPrecision] = ...
+bits: Final = 128
+precision: Final = 33

numpy_quaddtype/_quaddtype_main.pyi

@@ -0,0 +1,197 @@
+from typing import Any, Literal, TypeAlias, final, overload
+import builtins
+import numpy as np
+from numpy._typing import _128Bit  # pyright: ignore[reportPrivateUsage]
+from typing_extensions import Never, Self, override
+
+from numpy_quaddtype import QuadBackend
+
+_Backend: TypeAlias = Literal["sleef", "longdouble"]
+_IntoQuad: TypeAlias = (
+    QuadPrecision
+    | float
+    | str
+    | bytes
+    | np.floating[Any]
+    | np.integer[Any]
+    | np.bool_
+)  # fmt: skip
+_ScalarItemArg: TypeAlias = Literal[0, -1] | tuple[Literal[0, -1]] | tuple[()]
+
+@final
+class QuadPrecDType(np.dtype[QuadPrecision]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    def __new__(cls, /, backend: _Backend = "sleef") -> Self: ...
+
+    # QuadPrecDType specific attributes
+    @property
+    def backend(self) -> QuadBackend: ...
+
+    # `numpy.dtype` overrides
+    names: None  # pyright: ignore[reportIncompatibleVariableOverride]
+    @property
+    @override
+    def alignment(self) -> Literal[16]: ...
+    @property
+    @override
+    def itemsize(self) -> Literal[16]: ...
+    @property
+    @override
+    def name(self) -> Literal["QuadPrecDType128"]: ...
+    @property
+    @override
+    def byteorder(self) -> Literal["|"]: ...
+    @property
+    @override
+    def char(self) -> Literal["\x00"]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @property
+    @override
+    def kind(self) -> Literal["\x00"]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @property
+    @override
+    def num(self) -> Literal[-1]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @property
+    @override
+    def shape(self) -> tuple[()]: ...
+    @property
+    @override
+    def ndim(self) -> Literal[0]: ...
+    @property
+    @override
+    def fields(self) -> None: ...
+    @property
+    @override
+    def base(self) -> Self: ...
+    @property
+    @override
+    def subdtype(self) -> None: ...
+    @property
+    @override
+    def hasobject(self) -> Literal[False]: ...
+    @property
+    @override
+    def isbuiltin(self) -> Literal[0]: ...
+    @property
+    @override
+    def isnative(self) -> Literal[True]: ...
+    @property
+    @override
+    def isalignedstruct(self) -> Literal[False]: ...
+    @override
+    def __getitem__(self, key: Never, /) -> Self: ...  # type: ignore[override]
+
+@final
+class QuadPrecision(np.floating[_128Bit]):
+    # 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 not return instances of their class (or a subclass thereof).
+    # See https://github.com/python/mypy/issues/18343#issuecomment-2571784915
+    @override
+    def __new__(cls, /, value: _IntoQuad, backend: _Backend = "sleef") -> Self: ...
+
+    # numpy.floating property overrides
+
+    @property
+    @override
+    def dtype(self) -> QuadPrecDType: ...
+    @property
+    @override
+    def real(self) -> Self: ...
+    @property
+    @override
+    def imag(self) -> Self: ...
+
+    # numpy.floating method overrides
+
+    @override
+    def item(self, arg0: _ScalarItemArg = ..., /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def tolist(self, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # Equality operators
+    @override
+    def __eq__(self, other: object, /) -> bool: ...
+    @override
+    def __ne__(self, other: object, /) -> bool: ...
+
+    # Rich comparison operators
+    # NOTE: Unlike other numpy scalars, these return `builtins.bool`, not `np.bool`.
+    @override
+    def __lt__(self, other: _IntoQuad, /) -> bool: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __le__(self, other: _IntoQuad, /) -> bool: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __gt__(self, other: _IntoQuad, /) -> bool: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __ge__(self, other: _IntoQuad, /) -> bool: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # Binary arithmetic operators
+    @override
+    def __add__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __radd__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override, misc]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __sub__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __rsub__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __mul__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __rmul__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __pow__(self, other: _IntoQuad, mod: None = None, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __rpow__(self, other: _IntoQuad, mod: None = None, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __truediv__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __rtruediv__(self, other: _IntoQuad, /) -> Self: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    # Binary modulo operators
+    @override
+    def __floordiv__(self, other: _IntoQuad, /) -> Self: ...
+    @override
+    def __rfloordiv__(self, other: _IntoQuad, /) -> Self: ...
+    @override
+    def __mod__(self, other: _IntoQuad, /) -> Self: ...
+    @override
+    def __rmod__(self, other: _IntoQuad, /) -> Self: ...
+    @override
+    def __divmod__(self, other: _IntoQuad, /) -> tuple[Self, Self]: ...
+    @override
+    def __rdivmod__(self, other: _IntoQuad, /) -> tuple[Self, Self]: ...
+
+    # NOTE: is_integer() and as_integer_ratio() are defined on numpy.floating in the
+    # stubs, but don't exist at runtime. And because QuadPrecision does not implement
+    # them, we use this hacky workaround to emulate their absence.
+    @override
+    def is_integer(self, /) -> builtins.bool: ...
+    @override
+    def as_integer_ratio(self, /) -> tuple[int, int]: ...
+
+#
+def is_longdouble_128() -> bool: ...
+
+@overload
+def get_sleef_constant(constant_name: Literal["bits", "precision"], /) -> int: ...
+@overload
+def get_sleef_constant(
+    constant_name: Literal[
+        "pi",
+        "e",
+        "log2e",
+        "log10e",
+        "ln2",
+        "ln10",
+        "max_value",
+        "epsilon",
+        "smallest_normal",
+        "smallest_subnormal",
+        "resolution",
+    ],
+    /,
+) -> QuadPrecision: ...
+
+def set_num_threads(num_threads: int, /) -> None: ...
+def get_num_threads() -> int: ...
+def get_quadblas_version() -> str: ...

numpy_quaddtype-1.0.0.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: numpy_quaddtype
+Version: 1.0.0
+Summary: Quad (128-bit) float dtype for numpy
+Author-Email: Swayam Singh <singhswayam008@gmail.com>
+Maintainer-Email: NumPy Developers <numpy-discussion@python.org>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading
+Classifier: Typing :: Typed
+Project-URL: Repository, https://github.com/numpy/numpy-quaddtype
+Project-URL: Documentation, https://numpy.org/numpy-quaddtype/
+Project-URL: Issues, https://github.com/numpy/numpy-quaddtype/issues
+Requires-Python: >=3.11.0
+Requires-Dist: numpy>=2.4
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: mpmath; extra == "test"
+Requires-Dist: pytest-run-parallel; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: pydata-sphinx-theme; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx-design; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: sphinxcontrib-katex; extra == "docs"
+Description-Content-Type: text/markdown
+
+# NumPy-QuadDType
+
+[![PyPI](https://img.shields.io/pypi/v/numpy-quaddtype.svg)](https://pypi.org/project/numpy-quaddtype/)
+[![PyPI Downloads](https://static.pepy.tech/badge/numpy-quaddtype/month)](https://pepy.tech/project/numpy-quaddtype)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/numpy_quaddtype.svg?label=Conda%20downloads)](https://anaconda.org/conda-forge/numpy_quaddtype)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://numpy.org/numpy-quaddtype/)
+[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+
+A cross-platform Quad (128-bit) float Data-Type for NumPy.
+
+**[📖 Read the full documentation](https://numpy.org/numpy-quaddtype/)**
+
+## Table of Contents
+
+- [NumPy-QuadDType](#numpy-quaddtype)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Installation from source](#installation-from-source)
+    - [Linux/Unix/macOS](#linuxunixmacos)
+    - [Windows](#windows)
+  - [Build Options](#build-options)
+    - [Disabling FMA (Fused Multiply-Add)](#disabling-fma-fused-multiply-add)
+  - [Building with ThreadSanitizer (TSan)](#building-with-threadsanitizer-tsan)
+  - [Building the documentation](#building-the-documentation)
+    - [Serving the documentation](#serving-the-documentation)
+  - [Development Tips](#development-tips)
+    - [Cleaning the Build Directory](#cleaning-the-build-directory)
+
+## Installation
+
+```bash
+pip install "numpy>=2.4"
+pip install numpy-quaddtype
+```
+
+Or with conda-forge:
+
+```bash
+conda install numpy_quaddtype
+```
+
+Or with mamba:
+
+```bash
+mamba install numpy_quaddtype
+```
+
+Or grab the development version with
+
+```bash
+pip install git+https://github.com/numpy/numpy-quaddtype.git
+```
+
+## Usage
+
+```python
+import numpy as np
+from numpy_quaddtype import QuadPrecDType, QuadPrecision
+
+# using sleef backend (default)
+np.array([1,2,3], dtype=QuadPrecDType())
+np.array([1,2,3], dtype=QuadPrecDType("sleef"))
+
+# using longdouble backend
+np.array([1,2,3], dtype=QuadPrecDType("longdouble"))
+```
+
+## Installation from source
+
+### Linux/Unix/macOS
+
+**Prerequisites:** gcc/clang, CMake (≥3.15), Python 3.11+, Git, NumPy ≥ 2.4
+
+```bash
+# setup the virtual env
+python3 -m venv temp
+source temp/bin/activate
+
+# Install build and test dependencies
+pip install pytest meson meson-python "numpy>=2.4"
+
+# To build without QBLAS (default for MSVC)
+# export CFLAGS="-DDISABLE_QUADBLAS"
+# export CXXFLAGS="-DDISABLE_QUADBLAS"
+
+python -m pip install ".[test]" -v
+
+# Run the tests
+python -m pytest tests
+```
+
+### Windows
+
+**Prerequisites:** Visual Studio 2017+ (with MSVC), CMake (≥3.15), Python 3.11+, Git
+
+1. **Setup Development Environment**
+
+   Open a **Developer Command Prompt for VS** or **Developer PowerShell for VS** to ensure MSVC is properly configured.
+
+2. **Setup Python Environment**
+
+   ```powershell
+   # Create and activate virtual environment
+   python -m venv numpy_quad_env
+   .\numpy_quad_env\Scripts\Activate.ps1
+
+   # Install build dependencies
+   pip install -U pip
+   pip install numpy pytest ninja meson
+   ```
+
+3. **Set Environment Variables**
+
+   ```powershell
+   # Note: QBLAS is disabled on Windows due to MSVC compatibility issues
+   $env:CFLAGS = "/DDISABLE_QUADBLAS"
+   $env:CXXFLAGS = "/DDISABLE_QUADBLAS"
+   ```
+
+4. **Build and Install numpy-quaddtype**
+
+   ```powershell
+   # Build and install the package
+   python -m pip install ".[test]" -v
+   ```
+
+5. **Test Installation**
+
+   ```powershell
+   # Run tests
+   pytest -s tests
+   ```
+
+6. **QBLAS Disabled**: QuadBLAS optimization is automatically disabled on Windows builds due to MSVC compatibility issues. This is handled by the `-DDISABLE_QUADBLAS` compiler flag.
+
+7. **Visual Studio Version**: The instructions assume Visual Studio 2022. For other versions, adjust the generator string:
+   - VS 2019: `"Visual Studio 16 2019"`
+   - VS 2017: `"Visual Studio 15 2017"`
+
+8. **Architecture**: The instructions are for x64. For x86 builds, change `-A x64` to `-A Win32`.
+
+## Build Options
+
+### Disabling FMA (Fused Multiply-Add)
+
+On older x86-64 CPUs without FMA support (e.g., Sandy Bridge / x86_64-v2), the SLEEF's `PURECFMA` scalar code path will cause illegal instruction errors. By default, FMA support is auto-detected at build time, but you can explicitly disable it:
+
+```bash
+pip install . -Csetup-args=-Ddisable_fma=true
+```
+
+This is a workaround for a [SLEEF issue](https://github.com/shibatch/sleef/issues/707) where `PURECFMA` scalar functions are unconditionally compiled with FMA instructions even on systems that don't support them.
+
+**When to use this option:**
+- Building on or for x86_64-v2 (Sandy Bridge era) CPUs
+- Cross-compiling for older x86_64 targets
+- Running in emulators/VMs that don't expose FMA capability
+
+## Building with ThreadSanitizer (TSan)
+
+This is a development feature to help detect threading issues. To build `numpy-quaddtype` with TSan enabled, follow these steps:
+
+> Use of clang is recommended with machine NOT supporting `libquadmath` (like ARM64). Set the compiler to clang/clang++ before proceeding.
+>
+> ```bash
+> export CC=clang
+> export CXX=clang++
+> ```
+
+1. Compile free-threaded CPython with TSan support. Follow the [Python Free-Threading Guide](https://py-free-threading.github.io/thread_sanitizer/#compile-free-threaded-cpython-with-tsan) for detailed instructions.
+2. Create and activate a virtual environment using the TSan-enabled Python build.
+3. Installing dependencies:
+
+```bash
+python -m pip install meson meson-python wheel ninja
+# Need NumPy built with TSan as well
+python -m pip install "numpy @ git+https://github.com/numpy/numpy" -C'setup-args=-Db_sanitize=thread'
+```
+
+4. Building SLEEF with TSan:
+
+```bash
+# clone the repository
+git clone https://github.com/shibatch/sleef.git
+cd sleef
+git checkout 43a0252ba9331adc7fb10755021f802863678c38
+
+# Build SLEEF with TSan
+cmake \
+-DCMAKE_C_COMPILER=clang \
+-DCMAKE_CXX_COMPILER=clang++ \
+-DCMAKE_C_FLAGS="-fsanitize=thread -g -O1" \
+-DCMAKE_CXX_FLAGS="-fsanitize=thread -g -O1" \
+-DCMAKE_EXE_LINKER_FLAGS="-fsanitize=thread" \
+-DCMAKE_SHARED_LINKER_FLAGS="-fsanitize=thread" \
+-DSLEEF_BUILD_QUAD=ON \
+-DSLEEF_BUILD_TESTS=OFF \
+-DCMAKE_INSTALL_PREFIX=/usr/local
+-S . -B build
+
+cmake --build build -j --clean-first
+cmake --install build
+```
+
+5. Build and install `numpy-quaddtype` with TSan:
+
+```bash
+# SLEEF is already installed with TSan, we need to provide proper flags to numpy-quaddtype's meson file
+# So that it does not build SLEEF again and use the installed one.
+
+export CFLAGS="-fsanitize=thread -g -O0"
+export CXXFLAGS="-fsanitize=thread -g -O0"
+export LDFLAGS="-fsanitize=thread"
+python -m pip install . -vv -Csetup-args=-Db_sanitize=thread
+```
+
+## Building the documentation
+
+The documentation for the `numpy-quaddtype` package is built using Sphinx. To build the documentation, follow these steps:
+
+1. Install the required dependencies:
+
+   ```bash
+   pip install ."[docs]"
+   ```
+
+2. Navigate to the `docs` directory and build the documentation:
+
+   ```bash
+   cd docs/
+   make html
+   ```
+
+3. The generated HTML documentation can be found in the `_build/html` directory within the `docs` folder. Open the `index.html` file in a web browser to view the documentation, or use a local server to serve the files:
+
+   ```bash
+   python3 -m http.server --directory _build/html
+   ```
+
+### Serving the documentation
+
+The documentation is automatically built and served using GitHub Pages. Every time changes are pushed to the `main` branch, the documentation is rebuilt and deployed to the `gh-pages` branch of the repository. You can access the documentation at:
+
+```
+https://numpy.org/numpy-quaddtype/
+```
+
+Check the `.github/workflows/build_docs.yml` file for details.
+
+## Development Tips
+
+### Cleaning the Build Directory
+
+The subproject folders (`subprojects/sleef`, `subprojects/qblas`) are cloned as git repositories. To fully clean them, use double force:
+
+```bash
+git clean -ffxd
+```

numpy_quaddtype-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+numpy_quaddtype/_quaddtype_main.cpython-314t-darwin.so,sha256=hvzbu3bLbfsu3JLomu_r-g_MHkLbvaHdKK5MCUzGMGM,1076000
+numpy_quaddtype/__init__.pyi,sha256=yiVUoVNMvUh41UVKsPPJy4jCy3rcxAjU99u_GXj3WcQ,1528
+numpy_quaddtype/__init__.py,sha256=F0jXK4SmI9_THAqa1CBi2_57hzFVxTRixKIi83IQ1jY,1799
+numpy_quaddtype/_quaddtype_main.pyi,sha256=TTddOAJtCZl19SohaGcMqEUqnKz_7QfYpnUar7ebfzk,7377
+numpy_quaddtype/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy_quaddtype/.dylibs/libomp.dylib,sha256=kf00qtEcVwyqr-UCkqao-HdIfpW0xskc93tohUJ0HS0,743200
+numpy_quaddtype-1.0.0.dist-info/RECORD,,
+numpy_quaddtype-1.0.0.dist-info/WHEEL,sha256=gWtW3fuEzXgMJhpOAm-oHttlk20PAeGIikqksd28VwI,123
+numpy_quaddtype-1.0.0.dist-info/METADATA,sha256=1tdiWtNDQLklFqF0WoZj_L3Uiqrk87oKWGWpQuvxMCU,9445
+numpy_quaddtype-1.0.0.dist-info/licenses/LICENSE,sha256=R89YvpdHKGUqld_OR6jHwcDC34rEF7bEHy8FHu6wX7E,1538

numpy_quaddtype-1.0.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp314-cp314t-macosx_15_0_arm64
+Generator: delocate 0.13.0
+

numpy_quaddtype-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2022, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials provided
+       with the distribution.
+
+    * Neither the name of the NumPy Developers nor the names of any
+       contributors may be used to endorse or promote products derived
+       from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.