mparray 0.1.0__tar.gz

mparray-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matt Haberland
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mparray-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.3
+Name: mparray
+Version: 0.1.0
+Summary: Array API-compatible, arbitrary-precision arrays
+Author: Matt Haberland
+Author-email: Matt Haberland <matt.haberland@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2026 Matt Haberland
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: numpy
+Requires-Dist: mpmath
+Requires-Dist: scipy
+Requires-Dist: jupyter-book ; extra == 'docs'
+Requires-Dist: ghp-import ; extra == 'docs'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Python: >=3.13
+Project-URL: Home, https://github.com/mdhaber/mparray
+Provides-Extra: docs
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+MPArray is an [Array API Standard](https://data-apis.org/array-api/latest/) compatible array library that features arbitrary precision arithmetic.
+
+Install with `pip`:
+
+```shell
+pip install mparray
+```
+
+Import to access the array namespace:
+
+```shell
+import mparray as xp
+```
+
+Use any feature defined by the 2025.12 version of the standard:
+
+```shell
+x = xp.arange(5)
+# MPArray([0, 1, 2, 3, 4], dtype=int64)
+```
+
+Integer arrays are filled with Python `int`s; consequently, elements never overflow.
+
+```shell
+x = x[:2] + 10**50
+# MPArray([100000000000000000000000000000000000000000000000000,
+#          100000000000000000000000000000000000000000000000001],
+#         dtype=int64)
+```
+
+Dtypes follow array API promotion rules for compatibility, but do not limit the underlying representation. For instance, `int32` arrays also use Python `int`s.
+
+```shell
+xp.astype(x, xp.int32)
+# MPArray([100000000000000000000000000000000000000000000000000,
+#          100000000000000000000000000000000000000000000000001],
+#         dtype=int32)
+```
+
+Real and complex floating point arrays are backed by [`mpmath`](https://github.com/mpmath/mpmath).
+
+```shell
+from mpmath import mp
+mp.dps = 55  # set the desired precision
+y = xp.astype(x, xp.float64)
+# MPArray([mpf('100000000000000000000000000000000000000000000000000.0'),
+#          mpf('100000000000000000000000000000000000000000000000001.0')],
+#         dtype=float64)
+xp.exp(y)
+# MPArray([mpf('4.535356657536074105363661926352788592352627616652483210606e+43429448190325182765112891891660508229439700580366'),
+#          mpf('1.232837758776106335937289338644047193491770865081040599056e+43429448190325182765112891891660508229439700580367')],
+#         dtype=float64)
+```
+
+Arbitrary-precision equivalents of some SciPy special functions are available:
+
+```shell
+xp.special.ndtr(-y)
+# MPArray([mpf('8.998129248551223738202088675072137970394711995443364311445e-2171472409516259138255644594583025411471985029018332830572230087781144236110599295949020894164292471'),
+#          mpf('6.461085845597172042837958170074610008600868697345677551181e-2171472409516259138255644594583025411471985029018376260020420755455996799425617236333573042128793971')],
+#         dtype=float64)
+```

mparray-0.1.0/README.md

@@ -0,0 +1,62 @@
+MPArray is an [Array API Standard](https://data-apis.org/array-api/latest/) compatible array library that features arbitrary precision arithmetic.
+
+Install with `pip`:
+
+```shell
+pip install mparray
+```
+
+Import to access the array namespace:
+
+```shell
+import mparray as xp
+```
+
+Use any feature defined by the 2025.12 version of the standard:
+
+```shell
+x = xp.arange(5)
+# MPArray([0, 1, 2, 3, 4], dtype=int64)
+```
+
+Integer arrays are filled with Python `int`s; consequently, elements never overflow.
+
+```shell
+x = x[:2] + 10**50
+# MPArray([100000000000000000000000000000000000000000000000000,
+#          100000000000000000000000000000000000000000000000001],
+#         dtype=int64)
+```
+
+Dtypes follow array API promotion rules for compatibility, but do not limit the underlying representation. For instance, `int32` arrays also use Python `int`s.
+
+```shell
+xp.astype(x, xp.int32)
+# MPArray([100000000000000000000000000000000000000000000000000,
+#          100000000000000000000000000000000000000000000000001],
+#         dtype=int32)
+```
+
+Real and complex floating point arrays are backed by [`mpmath`](https://github.com/mpmath/mpmath).
+
+```shell
+from mpmath import mp
+mp.dps = 55  # set the desired precision
+y = xp.astype(x, xp.float64)
+# MPArray([mpf('100000000000000000000000000000000000000000000000000.0'),
+#          mpf('100000000000000000000000000000000000000000000000001.0')],
+#         dtype=float64)
+xp.exp(y)
+# MPArray([mpf('4.535356657536074105363661926352788592352627616652483210606e+43429448190325182765112891891660508229439700580366'),
+#          mpf('1.232837758776106335937289338644047193491770865081040599056e+43429448190325182765112891891660508229439700580367')],
+#         dtype=float64)
+```
+
+Arbitrary-precision equivalents of some SciPy special functions are available:
+
+```shell
+xp.special.ndtr(-y)
+# MPArray([mpf('8.998129248551223738202088675072137970394711995443364311445e-2171472409516259138255644594583025411471985029018332830572230087781144236110599295949020894164292471'),
+#          mpf('6.461085845597172042837958170074610008600868697345677551181e-2171472409516259138255644594583025411471985029018376260020420755455996799425617236333573042128793971')],
+#         dtype=float64)
+```

mparray-0.1.0/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["uv_build>=0.10.8,<0.11.0"]
+build-backend = "uv_build"
+
+[project]
+name = "mparray"
+authors = [{ name = "Matt Haberland", email = "matt.haberland@gmail.com" }]
+readme = "README.md"
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+]
+version = "0.1.0"
+requires-python = ">=3.13"
+dependencies = ["numpy", "mpmath", "scipy"]
+description = "Array API-compatible, arbitrary-precision arrays"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+]
+docs = ["jupyter-book", "ghp-import"]
+
+[project.urls]
+Home = "https://github.com/mdhaber/mparray"
+
+[tool.ruff]
+target-version = "py313"
+builtins = ["ellipsis"]
+exclude = [".git", ".eggs", "build", "dist", "__pycache__"]
+line-length = 100
+
+[tool.ruff.lint]
+ignore = [
+    "E402", # module level import not at top of file
+    # "E501",  # line too long - let black worry about that
+    "E731",  # do not assign a lambda expression, use a def
+    "UP038", # type union instead of tuple for isinstance etc
+]
+select = [
+    "F",   # Pyflakes
+    "E",   # Pycodestyle
+    "I",   # isort
+    "UP",  # Pyupgrade
+    "TID", # flake8-tidy-imports
+    "W",
+]
+extend-safe-fixes = [
+    "TID252", # absolute imports
+]
+fixable = ["I", "TID252", "UP"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["mparray"]
+
+[tool.ruff.lint.flake8-tidy-imports]
+# Disallow all relative imports.
+ban-relative-imports = "all"
+
+[tool.coverage.run]
+source = ["mparray"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+exclude_lines = ["pragma: no cover", "if TYPE_CHECKING"]
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "error",
+    "ignore:invalid value encountered:RuntimeWarning",
+    "ignore:divide by zero encountered:RuntimeWarning",
+    "ignore:overflow encountered:RuntimeWarning",
+]

mparray-0.1.0/src/mparray/__init__.py

@@ -0,0 +1,9 @@
+"""Array API compatible, arbitrary-precision arrays."""
+from importlib.metadata import version as _get_version
+__version__ = _get_version("mparray")
+del _get_version
+
+from ._mparray import *
+from ._mparray import __array_api_version__, __array_namespace_info__
+from . import special
+bool = np.bool

mparray-0.1.0/src/mparray/_mparray.py

@@ -0,0 +1,730 @@
+import collections
+import inspect
+import sys
+import numpy as np
+import mpmath
+from mpmath import mp
+import functools
+import warnings
+
+
+class MPArray:
+
+    def __init__(self, obj, *, dtype=None, device=None, copy=None):
+        # TODO: fast path if input is MPArray and nothing is changing
+
+        if isinstance(obj, MPArray):
+            data = np.asarray(obj._data, device=device, copy=copy)
+        elif isinstance(obj, bool):
+            data = np.asarray(obj)
+        elif isinstance(obj, (int, mp.mpf, mp.mpc)):
+            data = np.asarray(obj, dtype=object, device=device, copy=copy)
+        else:
+            data = np.asarray(obj, device=device, copy=copy)
+            dtype = data.dtype if dtype is None else dtype
+
+        dtype = _get_dtype(obj) if dtype is None else _get_dtype(dtype)
+        dtype = result_type(dtype)
+        shape = data.shape
+
+        dtype_ = object
+        if np.isdtype(dtype, 'bool'):
+            type_ = bool
+            dtype_ = np.bool
+        elif np.isdtype(dtype, 'integral'):
+            type_ = int
+        elif np.isdtype(dtype, 'real floating'):
+            def type_(x):
+                try:
+                    return mp.mpf(x) if isinstance(x, (int, mp.mpf, mp.mpc)) else mp.mpf(float(x))
+                except TypeError:
+                    return mp.mpf(np.nan)
+        elif np.isdtype(dtype, 'complex floating'):
+            type_ = lambda x: mp.mpc(x) if isinstance(x, (mp.mpf, mp.mpc)) else mp.mpc(complex(x))
+        else:
+            type_ = mp.mpf
+            dtype = result_type(float64)
+
+        try:
+            data = np.asarray([type_(el) for el in data.ravel()], dtype=dtype_)
+        except TypeError:
+            type_ = mp.mpc
+            dtype = result_type(complex128)
+            data = np.asarray([type_(el) for el in data.ravel()], dtype=dtype_)
+
+        data = np.reshape(data, shape)
+
+        self._data = data
+        self._dtype = dtype
+        self._device = data.device
+        self._ndim = data.ndim
+        self._shape = data.shape
+        self._size = data.size
+
+    __array_priority__ = 1  # make reflected operators work with NumPy
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @property
+    def device(self):
+        return self._device
+
+    @property
+    def ndim(self):
+        return self._ndim
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def size(self):
+        return self._size
+
+    def __array_namespace__(self, api_version=None):
+        if api_version is None or api_version == '2024.12':
+            import mparray as xp
+            return xp
+        else:
+            message = (f"MPArray interface for Array API version '{api_version}' "
+                       "is not implemented.")
+            raise NotImplementedError(message)
+
+    def _call_super_method(self, method_name, *args, **kwargs):
+        method = getattr(self._data, method_name)
+        args = [_get_data(arg) for arg in args]
+        return method(*args, **kwargs)
+
+    def _validate_key(self, key):
+        if isinstance(key, tuple):
+            return tuple(self._validate_key(key_i) for key_i in key)
+
+        if isinstance(key, MPArray):
+            if np.isdtype(key.dtype, 'integral'):
+                return key._data.tolist()
+            return key._data
+
+        return key
+
+    # ## Indexing ##
+
+    def __getitem__(self, key):
+        key = self._validate_key(key)
+        return asarray(self._data[key], dtype=self.dtype, device=self.device)
+
+    def __setitem__(self, key, other):
+        key = self._validate_key(key)
+        other = asarray(other, dtype=self.dtype, device=self.device)
+        self._data.__setitem__(key, other._data[()])
+
+    def __deepcopy__(self, memo=None):
+        return asarray(self, copy=True)
+
+    # ## Visualization ##
+    def __repr__(self):
+        s = repr(self._data)
+        s = s.replace('array', 'MPArray')
+        return s.replace("dtype=object", f"dtype={self.dtype}")
+
+    def __str__(self):
+        # TODO: refine to show full precision?
+        return str(np.asarray(self._data, dtype=self.dtype))
+
+    # ## Linear Algebra Methods ##
+    def __matmul__(self, other):
+        return matmul(self, other)
+
+    def __imatmul__(self, other):
+        res = matmul(self, other)
+        self._data[...] = res.data[...]
+        return
+
+    def __rmatmul__(self, other):
+        other = asarray(other)
+        return matmul(other, self)
+
+    ## Attributes ##
+
+    @property
+    def T(self):
+        return asarray(self._data.T, dtype=self.dtype)
+
+    @property
+    def mT(self):
+        return matrix_transpose(self)
+
+    # dlpack
+    def __dlpack_device__(self):
+        return self._data.__dlpack_device__()
+
+    def __dlpack__(self, *, stream, max_version, dl_device, copy):
+        # really not sure how to define this
+        return self._data.__dlpack__(stream=stream, max_version=max_version,
+                                     dl_device=dl_device, copy=copy)
+
+    def to_device(self, device, /, *, stream=None):
+        self._data = self._data.to_device(device, stream=stream)
+
+    def __index__(self):
+        if self.shape == () and np.isdtype(self.dtype, 'integral'):
+            return self._data[()]
+        else:
+            message = "Only integer scalar arrays can be converted to a scalar index."
+            raise ValueError(message)
+
+
+## Methods ##
+
+# Methods that return the result of a unary operation as an array
+unary_names = (['__abs__', '__invert__', '__neg__', '__pos__'])
+for name in unary_names:
+    def fun(self, name=name):
+        data = self._call_super_method(name)
+        dtype = self.dtype
+        dtype = ((np.float64 if "128" in str(dtype) else np.float32)
+                 if ((name == '__abs__') and (dtype in [np.complex64, np.complex128]))
+                 else dtype)
+        return asarray(data, dtype=dtype)
+    setattr(MPArray, name, fun)
+
+# Methods that return the result of a unary operation as a Python scalar
+unary_names_py = ['__bool__', '__complex__', '__float__', '__int__']
+for name in unary_names_py:
+    def fun(self, name=name):
+        return self._call_super_method(name)
+    setattr(MPArray, name, fun)
+
+# Methods that return the result of an elementwise binary operation
+binary_names = ['__add__', '__sub__', '__and__', '__eq__', '__ge__', '__gt__',
+                '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__',
+                '__or__', '__rshift__', '__sub__', '__xor__']
+# Methods that return the result of an elementwise binary operation (reflected)
+rbinary_names = ['__radd__', '__rand__',
+                 '__rlshift__', '__rmul__', '__ror__', '__rpow__',
+                 '__rrshift__', '__rsub__', '__rxor__']
+ensure_output_dtype = ['__eq__', '__ge__', '__gt__', '__le__', '__lt__',
+                       '__ne__', '__rand__', '__ror__', '__rxor__']
+for name in binary_names + rbinary_names:
+    def fun(self, other, name=name):
+        self, other = _promote(self, other)
+        dtype = None if name in ensure_output_dtype else self.dtype
+        data = self._call_super_method(name, other)
+        return asarray(data, dtype=dtype)
+    setattr(MPArray, name, fun)
+
+
+# In-place methods
+desired_names = ['__iadd__', '__iand__', '__ilshift__',
+                 '__imul__', '__ior__', '__irshift__',
+                 '__isub__', '__ixor__']
+for name in desired_names:
+    def fun(self, other, name=name, **kwargs):
+        other = astype(other, self.dtype)
+        self._call_super_method(name, other)
+        return self
+    setattr(MPArray, name, fun)
+
+mod = sys.modules[__name__].__dict__
+
+## Constants ##
+constant_names = ['e', 'inf', 'nan', 'pi']
+for name in constant_names:
+    mod[name] = mp.mpf(getattr(mpmath, name))
+newaxis = np.newaxis
+
+
+## Creation Functions ##
+def asarray(obj, /, *, dtype=None, device=None, copy=None):
+    if (isinstance(obj, MPArray) and not copy
+            and ((device is None) or (obj.device == device))
+            and ((dtype is None) or (obj.dtype == dtype))):
+        return obj
+    return MPArray(obj, dtype=dtype, device=device, copy=copy)
+
+
+creation_functions = ['arange', 'empty', 'eye', 'from_dlpack',
+                      'linspace', 'ones', 'zeros']
+creation_functions_like = ['empty_like', 'ones_like', 'zeros_like']
+# `full` and `full_like` created separately
+#  'tril', 'triu', 'meshgrid' handled with array manipulation functions
+for name in creation_functions:
+    def fun(*args, name=name, **kwargs):
+        data = getattr(np, name)(*args, **kwargs)
+        return asarray(data)
+    mod[name] = fun
+
+for name in creation_functions_like:
+    def fun(x, /, name=name, **kwargs):
+        name = name.split("_")[0]
+        kwds = dict(shape=x.shape,
+                    dtype=kwargs.get('dtype', None) or x.dtype,
+                    device=kwargs.get('device', None) or x.device)
+        data = getattr(np, name)(**kwds)
+        return asarray(data)
+    mod[name] = fun
+
+
+def full(shape, fill_value, *, dtype=None, device=None):
+    dtype = result_type(fill_value) if dtype is None else dtype
+    res = ones(shape, dtype=dtype, device=device)
+    res[...] = fill_value
+    return res
+
+
+def full_like(x, /, fill_value, **kwargs):
+    dtype=kwargs.get('dtype', None) or x.dtype
+    device=kwargs.get('device', None) or x.device
+    return full(x.shape, fill_value, dtype=dtype, device=device)
+
+
+## Data Type Functions and Data Types ##
+def result_type(*args):
+    return np.result_type(*(_get_dtype(arg) for arg in args if arg is not None))
+
+
+dtype_fun_names = ['can_cast', 'finfo', 'iinfo']
+for name in dtype_fun_names:
+    # TODO: consider these more carefully
+    def fun(*args, name=name, **kwargs):
+        args = [_get_dtype(arg) for arg in args]
+        return getattr(np, name)(*args, **kwargs)
+    mod[name] = fun
+
+dtype_names = ['int8', 'int16', 'int32', 'int64', 'uint8', 'uint16',
+               'uint32', 'uint64', 'float32', 'float64', 'complex64', 'complex128',
+               'isdtype']  # not really a dtype, but OK to treat it like one here
+inspection_fun_names = ['__array_namespace_info__']  # TODO: replace this?
+version_attribute_names = ['__array_api_version__']
+for name in (dtype_names + inspection_fun_names + version_attribute_names):
+    mod[name] = getattr(np, name)
+
+def astype(x, dtype, /, *, copy=True, device=None):
+    if device is None and not copy and dtype == x.dtype:
+        return x
+    # TODO: take care of copy=False error if impossible to satisfy
+    return asarray(x, dtype=dtype, device=device, copy=copy)
+
+
+## Elementwise Functions ##
+# TODO: fix `logical_` functions for non-boolean dtype
+elementwise_numpy = ['equal', 'greater', 'greater_equal', 'less', 'less_equal',
+                     'logical_and', 'logical_not', 'logical_or', 'logical_xor',
+                     'not_equal']
+for name in elementwise_numpy:
+    def fun(*args, name=name, **kwargs):
+        args = (_get_data(arg) for arg in args)
+        return asarray(getattr(np, name)(*args, **kwargs))
+    mod[name] = fun
+
+# TODO: fix `bitwise_` functions for inappropriate dtypes
+elementwise_no_dtype = ['abs', 'bitwise_and', 'bitwise_left_shift', 'bitwise_invert',
+                        'bitwise_or', 'bitwise_right_shift', 'bitwise_xor', 'negative',
+                        'positive', 'square']
+elementwise_promote_numpy = ['add', 'remainder', 'multiply',
+                             'maximum', 'minimum', 'subtract']
+for name in elementwise_no_dtype + elementwise_promote_numpy:
+    def fun(*args, name=name, **kwargs):
+        args = _promote(*args)
+        dtype = args[0].dtype
+        args = tuple(_get_data(arg) for arg in args)
+        dtype = ((np.float64 if "128" in str(dtype) else np.float32)
+                 if ((name == 'abs') and (dtype in [np.complex64, np.complex128]))
+                 else dtype)
+        return asarray(getattr(np, name)(*args, **kwargs), dtype=dtype)
+    mod[name] = fun
+
+
+def _dividelike_special_case(x1, x2, *, op):
+    return op(np.astype(x1._data, x1.dtype), np.astype(x2._data, x2.dtype))
+
+
+def _dividelike(x1, x2, *, op):
+    # mpmath division by zero raises,
+    x1, x2 = _promote(x1, x2)
+    x1, x2 = broadcast_arrays(x1, x2)
+    res = empty(x1.shape, dtype=x1.dtype)
+    i = (x2 != 0)._data & isfinite(x2)._data
+    res._data[i] = op(x1[i]._data, x2[i]._data)
+    res._data[~i] = _dividelike_special_case(x1[~i], x2[~i], op=op)
+    return res
+
+
+def divide(x1, x2, /):
+    return _dividelike(x1, x2, op=lambda x1, x2: x1 / x2)
+
+
+def floor_divide(x1, x2, /):
+    return _dividelike(x1, x2, op=lambda x1, x2: x1 // x2)
+
+
+def remainder(x1, x2, /):
+    return _dividelike(x1, x2, op=lambda x1, x2: x1 % x2)
+
+
+def pow(x1, x2, /):
+    x1, x2 = _promote(x1, x2)
+    x1, x2 = broadcast_arrays(x1, x2)
+    res = empty(x1.shape, dtype=x1.dtype)
+    i =  (x1 != 0)._data
+    res._data[i] = x1[i]._data ** x2[i]._data
+    res._data[~i] = np.astype(x1[~i]._data, x1.dtype) ** np.astype(x2[~i]._data, x2.dtype)
+    return res
+
+
+setattr(MPArray, "__truediv__", divide)
+setattr(MPArray, "__floordiv__", floor_divide)
+setattr(MPArray, "__mod__", remainder)
+setattr(MPArray, "__rtruediv__", lambda x, y: divide(y, x))
+setattr(MPArray, "__rfloordiv__", lambda x, y: floor_divide(y, x))
+setattr(MPArray, "__rmod__", lambda x, y: remainder(y, x))
+setattr(MPArray, "__pow__", pow)
+reciprocal = lambda x, /: divide(1, x)
+
+mp.logaddexp = lambda x, y: mp.log(mp.exp(x) + mp.exp(y))
+mp.imag = lambda x: x.imag
+mp.real = lambda x: x.real
+mp.round = lambda x: mp.nint(x)
+mp.trunc = lambda x: mp.floor(x) if x > 0 else mp.ceil(x)
+elementwise_mp = ['acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cos',
+                  'cosh', 'exp', 'expm1', 'hypot', 'log', 'log1p', 'log2',
+                  'log10', 'logaddexp', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
+elementwise_mp_float = ['ceil', 'conj', 'floor', 'imag', 'real', 'round', 'trunc']
+for name in elementwise_mp + elementwise_mp_float:
+    def fun(*args, name=name, **kwargs):
+        atleast = bool if name in elementwise_mp_float else 1.0
+        args = _promote(*args, atleast=atleast)
+
+        if name in elementwise_mp_float and np.isdtype(args[0].dtype, ('bool', 'integral')):
+            return args[0]  # TODO: fix imag
+
+        data = (_get_data(arg) for arg in args)
+        out = np.vectorize(getattr(mp, name), otypes=[object])(*data, **kwargs)
+        # TODO: preserve complex output dtype for funcs like acos
+
+        dtype = (np.float64 if "128" in str(args[0].dtype) else np.float32) if name in {'imag', 'real'} else args[0].dtype
+        return asarray(out, dtype=dtype)
+    mod[name] = fun
+
+
+def _mimum(x1, x2, /, op):
+    res = op(x1, x2)
+    i = isnan(x1) | isnan(x2)
+    res[i] = nan
+    return res
+
+
+def maximum(x1, x2, maximum=maximum):
+    return _mimum(x1, x2, op=maximum)
+
+
+def minimum(x1, x2, minimum=minimum):
+    return _mimum(x1, x2, op=minimum)
+
+
+elementwise_is = ['isfinite', 'isinf', 'isnan']
+for name in elementwise_is:
+    def fun(arg, name=name, **kwargs):
+        arg = asarray(arg)
+        if np.isdtype(arg.dtype, ('bool', 'integral')):
+            return full_like(arg, name=='isfinite', dtype=np.bool)
+
+        out = np.vectorize(getattr(mp, name), otypes=[bool])(_get_data(arg), **kwargs)
+        return asarray(out, dtype=np.bool)
+    mod[name] = fun
+
+
+def sign(x, /):
+    x = asarray(x)
+    if isdtype(x.dtype, ('bool', 'integral')):
+        return asarray(np.sign(x._data), dtype=x.dtype)
+    return asarray(_vectorize(mp.sign)(x), dtype=x.dtype)
+
+
+def signbit(x, /):
+    return x < 0  # Python int/mp.mpf don't have -0 or signed NaNs
+
+
+def copysign(x1, x2, /):
+    dtype = result_type(x1, x2)
+    return asarray(abs(x1) * sign(x2), dtype=dtype)
+
+
+def nextafter(x1, x2, /):
+    x1, x2 = _promote(x1, x2)
+    inc = 10 ** (floor(log10(x1)) - mp.dps)  # TODO: defined for other types
+    return x1 + sign(x2 - x1)*inc
+
+
+def clip(x, /, min=None, max=None):
+    x, min, max = _promote(x, min, max)
+    dtype = x.dtype
+    x, min, max = _get_data(x, min, max)
+    out = np.clip(x, min=min, max=max)
+    return asarray(out, dtype=dtype)
+
+## Indexing Functions
+take_like = ['take', 'take_along_axis']
+for name in take_like:
+    def fun(x, indices, name=name, **kwargs):
+        x = asarray(x)
+        dtype = x.dtype
+        x, indices = _get_data(x, indices)
+        indices = np.astype(indices, np.int64)
+        return asarray(getattr(np, name)(x, indices, **kwargs), dtype=dtype)
+    mod[name] = fun
+
+## Inspection ##
+# Included with dtype functions above
+
+## Linear Algebra Functions ##
+linalg_names = ['matmul', 'tensordot', 'vecdot']
+for name in linalg_names:
+    def fun(x1, x2, /, name=name, **kwargs):
+        x1, x2 = _promote(x1, x2)
+        dtype = x1.dtype
+        x1, x2 = _get_data(x1, x2)
+        out = getattr(np, name)(x1, x2, **kwargs)
+        out = (getattr(np, name)(x1.astype(int), x2.astype(int), **kwargs)
+               if np.any(out == None) else out)  # see gh-31019
+        return asarray(out, dtype=dtype)
+    mod[name] = fun
+
+matrix_transpose = lambda x: asarray(_get_data(x).mT, dtype=x.dtype)
+
+## Manipulation Functions ##
+output_arrays = {'broadcast_arrays', 'unstack', 'meshgrid'}
+
+manip_array_in_out = ['broadcast_arrays', 'meshgrid']
+for name in manip_array_in_out:
+    def fun(*args, name=name, **kwargs):
+        res = getattr(np, name)(*(_get_data(arg) for arg in args), **kwargs)
+        return tuple(asarray(resi, dtype=_get_dtype(arg))
+                     for resi, arg in zip(res, args))
+    mod[name] = fun
+
+manip_tuple_in = ['concat', 'stack']
+for name in manip_tuple_in:
+    def fun(args, name=name, **kwargs):
+        args = tuple(_promote(*args))
+        dtype = args[0].dtype
+        res = getattr(np, name)(tuple(_get_data(arg) for arg in args), **kwargs)
+        return asarray(res, dtype=dtype)
+    mod[name] = fun
+
+manip_names = ['broadcast_to', 'expand_dims', 'flip', 'moveaxis', 'permute_dims',
+               'reshape', 'roll', 'squeeze', 'tile', 'tril', 'triu']
+for name in manip_names:
+    def fun(x, *args, name=name, **kwargs):
+        x = asarray(x)
+        res = getattr(np, name)(_get_data(x), *args, **kwargs)
+        return asarray(res, dtype=x.dtype)
+    mod[name] = fun
+
+
+def repeat(x, repeats, /, *, axis=None):
+    x = asarray(x)
+    repeats = np.asarray(_get_data(repeats), dtype=np.int64)
+    res = np.repeat(x._data, repeats, axis=axis)
+    return asarray(res, dtype=x.dtype)
+
+
+def unstack(x, /, *, axis=0):
+    x = asarray(x)
+    res = np.unstack(x._data, axis=axis)
+    return tuple(asarray(resi, dtype=x.dtype) for resi in res)
+
+
+broadcast_shapes = np.broadcast_shapes
+
+## Searching Functions
+def searchsorted(x1, x2, /, *, side='left', sorter=None):
+    x1, x2 = _promote(x1, x2)
+    x1, x2 = _get_data(x1, x2)
+    j = np.searchsorted(x1, x2, side=side,
+                        sorter=_get_data(sorter).astype(int)
+                        if sorter is not None else sorter)
+    return asarray(j)
+
+
+def nonzero(x, /):
+    x = asarray(x)
+    res = np.nonzero(x._data)
+    return tuple(asarray(resi) for resi in res)
+
+
+def where(condition, x1, x2, /):
+    condition = asarray(condition)
+    x1, x2 = _promote(x1, x2)
+    data = np.where(condition._data, x1._data, x2._data)
+    return asarray(data, dtype=x1.dtype)
+
+# Defined below, in Statistical Functions
+# argmax
+# argmin
+# count_nonzero
+
+## Set Functions ##
+unique_names = ['unique_values', 'unique_counts', 'unique_inverse', 'unique_all']
+for name in unique_names:
+    def fun(x, /, name=name):
+        x = asarray(x)
+        res = getattr(np, name)(x._data)
+        if name == 'unique_values':
+            return asarray(res, dtype=x.dtype)
+
+        fields = res._fields
+        name_tuple = res.__class__.__name__
+        result_class = collections.namedtuple(name_tuple, fields)
+
+        result_list = []
+        for res_i, field_i in zip(res, fields):
+            dtype = x._dtype if field_i == 'values' else None
+            result_list.append(asarray(res_i, dtype=dtype))
+        return result_class(*result_list)
+    mod[name] = fun
+
+
+def isin(x1, x2, /, *, invert=False):
+    x1, x2 = _promote(x1, x2)
+    data = np.isin(x1._data, x2._data, invert=invert)
+    return asarray(data, dtype=bool)
+
+
+## Sorting Functions ##
+sort_names = ['sort', 'argsort']
+for name in sort_names:
+    def fun(x, /, *, name=name, axis=-1, descending=False, stable=True):
+        x = asarray(x)
+        x = -x if descending else x
+        res = getattr(np, name)(x._data, axis=axis, stable=stable)
+        res = -res if (descending and name == 'sort') else res
+        return asarray(res, dtype=x.dtype if name == 'sort' else None)
+    mod[name] = fun
+
+## Statistical Functions and Utility Functions ##
+statistical_names_float = ['mean', 'var', 'std']
+statistical_names_dtype = ['max', 'min', 'sum', 'prod',
+                           'cumulative_sum', 'cumulative_prod']
+statistical_names_none = ['argmax', 'argmin', 'count_nonzero', 'all', 'any']
+for name in statistical_names_float + statistical_names_dtype + statistical_names_none:
+    def fun(x, *args, name=name, **kwargs):
+        dtype = kwargs.pop('dtype', float if name in statistical_names_float else bool)
+        x, = _promote(x, atleast=dtype)  # TODO: follow standard precisely?
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            res = getattr(np, name)(x._data, *args, **kwargs)
+        return asarray(res, dtype=None if name in statistical_names_none else x.dtype)
+    mod[name] = fun
+
+
+def _minmax(x1, /, *, axis=None, keepdims=False, op):
+    res = op(x1, axis=axis, keepdims=keepdims)
+    if isdtype(x1.dtype, ("real floating", "complex floating")):
+        i = any(isnan(x1), axis=axis, keepdims=keepdims)
+        res[i] = nan
+    return res
+
+
+def min(x1, /, *, axis=None, keepdims=False, min=min):
+    return _minmax(x1, axis=axis, keepdims=keepdims, op=min)
+
+
+def max(x1, /, *, axis=None, keepdims=False, max=max):
+    return _minmax(x1, axis=axis, keepdims=keepdims, op=max)
+
+
+def diff(x, /, *, axis=-1, n=1, prepend=None, append=None):
+    x, prepend, append = _promote(x, prepend, append)
+    prepend = prepend._data if prepend is not None else np._NoValue
+    append = append._data if append is not None else np._NoValue
+    res = np.diff(x._data, axis=axis, n=n, prepend=prepend, append=append)
+    return asarray(res, dtype=x.dtype)
+
+
+_dont_mod_signature = {'clip', 'sort', 'argsort'}
+preface = ["The following is the documentation for the corresponding "
+           f"attribute of NumPy.",
+           "MPArray behavior is the same except that the calculation is "
+           "carried out in the appropriate precision.\n\n"]
+preface = "\n".join(preface)
+mod_keys = list(mod.keys())
+for attribute in mod_keys:
+    # Add documentation if it is not already present
+    if mod[attribute].__doc__:
+        continue
+
+    np_attr = getattr(np, attribute, None)
+    mod_attr = mod.get(attribute, None)
+    if np_attr is not None and mod_attr is not None:
+
+        if hasattr(np_attr, "__doc__"):
+            try:
+                np_doc = getattr(np_attr, "__doc__")
+                mod[attribute].__doc__ = preface + np_doc
+            except (AttributeError, TypeError):
+                pass
+
+        if attribute not in _dont_mod_signature:
+            try:
+                mod_attr.__signature__ = inspect.signature(np_attr)
+            except (ValueError, TypeError):
+                pass
+
+        try:
+            mod_attr.__name__ = np_attr.__name__
+        except (AttributeError, TypeError):
+            pass
+
+
+def _xinfo(x):
+    np = x._np
+    if np.isdtype(x.dtype, 'integral'):
+        return np.iinfo(x.dtype)
+    elif np.isdtype(x.dtype, 'bool'):
+        binfo = dataclasses.make_dataclass("binfo", ['min', 'max'])
+        return binfo(min=False, max=True)
+    else:
+        return np.finfo(x.dtype)
+
+
+def _get_data(*args):
+    if len(args) == 1:
+        x = args[0]
+        return x._data if isinstance(x, MPArray) else x
+    return tuple(_get_data(arg) for arg in args)
+
+
+def _get_dtype(x):
+    if isinstance(x, bool) or x is np.bool:
+        return np.bool
+    elif isinstance(x, mp.mpf):
+        return np.float64
+    elif isinstance(x, mp.mpc):
+        return np.complex128
+    elif isinstance(x, type) and not ((x is bool) or (x is int)
+                                      or (x is float) or (x is complex)):
+        return x(0).dtype
+    elif (x is int) or (x is float) or (x is complex):
+        return x(1)
+
+    return getattr(x, "dtype", x)
+
+
+def _promote(*args, atleast=bool):
+    dtype = result_type(*args, atleast)
+    return tuple((astype(arg, dtype) if arg is not None else arg) for arg in args)
+
+
+def _vectorize(f):
+
+    @functools.wraps(f)
+    def wrapped(*args, **kwargs):
+        args = list(_promote(*args, atleast=float))
+        data = (_get_data(arg) for arg in args)
+        out = np.vectorize(f, otypes=[object])(*data, **kwargs)
+        # TODO: preserve complex output dtype for funcs like acos
+        return asarray(out, dtype=args[0].dtype)
+
+    return wrapped

mparray-0.1.0/src/mparray/special/__init__.py

@@ -0,0 +1 @@
+from ._special import *

mparray-0.1.0/src/mparray/special/_special.py

@@ -0,0 +1,230 @@
+import sys as sys
+import numpy as np
+from mpmath import mp
+import mparray as xp
+from mparray._mparray import _vectorize as vectorize
+from scipy import special
+
+# add imported names to `_imports` to avoid altering their documentation and exposing
+# as public members of `mparray.special`.
+_imports = {'sys', 'np', 'mp', 'xp', 'vectorize', 'special'}
+
+expm1 = vectorize(mp.expm1)
+log1p = vectorize(mp.log1p)
+factorial2 = vectorize(mp.fac2)
+psi = vectorize(mp.digamma)
+digamma = psi
+ndtr = vectorize(mp.ncdf)
+gamma = vectorize(mp.gamma)
+gammaln = vectorize(mp.loggamma)
+erf = vectorize(mp.erf)
+erfc = vectorize(mp.erfc)
+zeta = vectorize(mp.zeta)
+poch = vectorize(mp.rf)
+binom = vectorize(mp.binomial)
+comb = binom
+powm1 = vectorize(mp.powm1)
+hyp1f1 = vectorize(mp.hyp1f1)
+hyp2f1 = vectorize(mp.hyp2f1)
+iv = vectorize(mp.besseli)
+kv = vectorize(mp.besselk)
+
+
+@vectorize
+def gammainc(a, x):
+    return mp.gammainc(a, a=0, b=x, regularized=True)
+
+
+@vectorize
+def gammaincc(a, x):
+    return mp.gammainc(a, a=x, b=mp.inf, regularized=True)
+
+
+@vectorize
+def ndtri(x):
+    if x == 0:
+        return -mp.inf
+    if x == 1:
+        return mp.inf
+    if x < 0 or x > 1:
+        return mp.nan
+
+    extra_dps = int(mp.ceil(-mp.log10(x)))
+    with mp.workdps(mp.dps + extra_dps):
+        return mp.sqrt(2) * mp.erfinv(2 * x - mp.one)
+
+
+@vectorize
+def log_ndtr(x):
+    if x <= 0:
+        return mp.log(mp.ncdf(x))
+    else:
+        complement = mp.ncdf(-x)
+        return mp.log1p(-complement)
+
+
+@vectorize
+def betaln(x, y):
+    return mp.log(mp.beta(x, y))
+
+
+@vectorize
+def betainc(a, b, x):
+    return mp.betainc(a, b, 0, x, regularized=True)
+
+
+@vectorize
+def fdtr(dn, dd, x):
+    return mp.betainc(dn/2, dd/2, 0, x*dn/(dd + x*dn), regularized=True)
+
+
+@vectorize
+def fdtrc(dn, dd, x):
+    return mp.betainc(dn/2, dd/2, x*dn/(dd + x*dn), 1, regularized=True)
+
+
+@vectorize
+def xlogy(x, y):  # needs accuracy review
+    return x*mp.log(y)
+
+
+@vectorize
+def xlog1py(x, y):  # needs accuracy review
+    return x*mp.log1p(y)
+
+
+@vectorize
+def cosm1(x):
+    if x == 0:
+        # Handle this case separately to avoid blow up in extra_dps calculation.
+        return mp.zero
+    # second term in cosine series is x**2/2
+    # catastrophic cancellation also occurs near nonzero multiples of 2*pi,
+    # but doubling precision is enough here. We are being conservative by
+    # always at least doubling the precision.
+    extra_dps = max(mp.dps, 2*int(mp.ceil(-mp.log10(x))) + 1)
+    with mp.workdps(mp.dps + extra_dps):
+        return mp.cos(x) - mp.one
+
+
+@vectorize
+def logit(x):  # needs accuracy review
+    res = mp.log(x) - mp.log1p(-x)
+    return res
+
+
+@vectorize
+def expit(x):  # needs accuracy review
+    return mp.exp(x - mp.log1p(mp.exp(x)))
+
+
+def _boxcox_scalar(x, lmbda):
+    """
+    y = (x**lmbda - 1) / lmbda  if lmbda != 0
+        log(x)                  if lmbda == 0
+    """
+    if x < 0:
+        return mp.nan
+    if lmbda != 0:
+        return mp.powm1(x, lmbda) / lmbda
+    else:
+        return mp.log(x)
+
+
+@vectorize
+def boxcox(x, lmbda):
+    return _boxcox_scalar(x, lmbda)
+
+
+@vectorize
+def boxcox1p(x, lmbda):
+    if x == 0:
+        # Handle x = 0 separately to avoid blow up in extra_dps calculation.
+        return mp.zero
+    extra_dps = max(0, int(mp.ceil(-mp.log10(abs(x)))))
+    with mp.workdps(mp.dps + extra_dps):
+        return _boxcox_scalar(mp.one + x, lmbda)
+
+
+def logsumexp(a, axis=None, b=None):
+    # As far as I know, logsumexp is to avoid overflow, not to improve precision.
+    # mpmath doesn't overflow, so naive implementation should be OK.
+    return xp.log(xp.sum(b*xp.exp(a), axis=axis))
+
+
+@vectorize
+def ive(v, z):
+    return iv(v, z) * xp.exp(-xp.abs(xp.real(z)))
+
+
+@vectorize
+def i0e(x):
+    return ive(0, x)
+
+
+@vectorize
+def i1e(x):
+    return ive(1, x)
+
+
+@vectorize
+def kve(v, z):
+    return kv(v, z) * xp.exp(z)
+
+
+@vectorize
+def k0e(x):
+    return kve(0, x)
+
+
+@vectorize
+def k1e(x):
+    return kve(1, x)
+
+
+@vectorize
+def chdtr(v, x):
+    return gammainc(v / 2, x / 2)
+
+
+@vectorize
+def chdtrc(v, x):
+    return gammaincc(v / 2, x / 2)
+
+
+@vectorize
+def stdtr(df, t):
+    x = df / (t**2 + df)
+    p = betainc(df/2, mp.one/2, x)/2
+    return np.where(t < 0, p, mp.one - p)
+
+
+# others to be added
+# gammaincinv
+# gammainccinv
+# chdtri
+# chndtr
+# chndtrix
+# stdtrit
+# ndtri_exp
+# tklmbda
+# inv_boxcox
+# inv_boxcox1p
+# kolmogorov, smirnov
+# erfcinv
+# erfinv
+# lambertw
+
+
+# generate rough documentation
+_preface = ["The following is the documentation for the corresponding "
+            f"attribute of `scipy.special`.",
+            "MPArray behavior is the same except that the calculation is "
+            "carried out in the appropriate precision.\n\n"]
+_preface = "\n".join(_preface)
+function_names = list(sys.modules[__name__].__dict__.keys())
+for key in function_names:
+    if key in _imports or '_' in key:
+        continue
+    special_doc = getattr(special, key).__doc__
+    sys.modules[__name__].__dict__[key].__doc__ = _preface + special_doc

mparray-0.1.0/src/mparray/testing/__init__.py

@@ -0,0 +1 @@
+from ._testing import *

mparray-0.1.0/src/mparray/testing/_testing.py

@@ -0,0 +1,14 @@
+import numpy as np
+import mparray as xp
+
+
+def assert_allclose(res, ref, *args, strict=True, **kwargs):
+    if isinstance(res, xp.MPArray):
+        res = np.asarray(res._data, dtype=res.dtype)
+    return np.testing.assert_allclose(res, ref, *args, strict, **kwargs)
+
+
+def assert_equal(res, ref, *args, strict=True, **kwargs):
+    if isinstance(res, xp.MPArray):
+        res = np.asarray(res._data, dtype=res.dtype)
+    return np.testing.assert_equal(res, ref, *args, strict, **kwargs)