crival 0.2.0__tar.gz

crival-0.2.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 anun333
+
+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.
+
+The CORE-MATH source files included here (the .c and .h files carrying their
+own copyright notices, and the tables copied into crmvec-*-tab.h) are
+distributed under their own MIT license and copyright notices.

crival-0.2.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: crival
+Version: 0.2.0
+Summary: Tight IEEE 1788.1 interval arithmetic over NumPy arrays, on crnumerics' libival (CORE-MATH's correctly rounded functions)
+License: MIT
+Project-URL: Source, https://github.com/anun333/crnumerics/tree/main/ival
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# ival for Python
+
+Interval arithmetic over NumPy arrays: every result is the tightest
+interval of doubles around the exact one (IEEE 1788.1). It calls
+crnumerics' C library `libival`, whose functions are CORE-MATH's,
+correctly rounded.
+
+```python
+import ival, numpy as np
+
+x = ival.Interval(1, 2)
+ival.exp(x) * x + 1                # Interval(3.718281828459045, 15.7781121978613)
+ival.Interval(0.1) + 0.2           # Interval(0.3, 0.30000000000000004): the exact sum inside
+ival.Interval.from_text("[0.1]")   # Interval(0.09999999999999999, 0.1): the decimal 0.1 inside
+X = ival.Interval(np.linspace(0, 1, 10**6), np.linspace(0, 1, 10**6) + 1e-3)
+ival.sin(X)                        # a million intervals in one call
+```
+
+## Installing
+
+On Linux x86-64 and aarch64 (glibc 2.26 or later), the wheels on PyPI
+carry the library, so nothing else needs installing. The package is
+`crival` on PyPI; the module is `ival`:
+
+```sh
+pip install crival
+python3 -c 'import ival; print(ival.exp(ival.Interval(1)))'
+```
+
+Elsewhere, or to use a libival you installed, install `libival` first,
+from the root of crnumerics, then the package:
+
+```sh
+make install-ival PREFIX=$HOME/.local     # or /usr/local; installs libival.so.0 and ival.pc
+pip install ./ival/python                 # numpy is the one dependency
+```
+
+`ival/python/build-wheel.sh` builds a wheel that carries the library,
+for the glibc it was built on and newer. The wheels on PyPI are built in
+the manylinux_2_28 containers by `.github/workflows/wheels.yml`.
+
+The binding finds the library through `IVAL_LIBRARY` (a path), then a
+copy inside the package (a wheel's), then the system's linker paths, then `pkg-config --variable=libdir ival` (for a
+prefix like `$HOME/.local`, `PKG_CONFIG_PATH` must include its
+`lib/pkgconfig`).
+`ival.library_path` says which it loaded, and `ival.version()` the
+library's version. It works with libival 0.1.0 and later; 0.2.0 fixes sinRev, cosRev
+and tanRev, which in 0.1.0 could miss a set. Python 3.9 or
+later; tested on Linux x86-64 and aarch64.
+
+## What there is
+
+- **`Interval(lo, hi)`**, or `Interval(a)` for the smallest interval
+  holding `a`. One interval holds two Python floats; an array of them two
+  float64 arrays, broadcast as NumPy does. The empty interval is
+  `[nan, nan]`; `Interval(lo, hi)` is empty unless `lo <= hi`
+  (1788's numsToInterval). `Interval.from_text("[0.1, 0.2]")` reads 1788's
+  text forms, a string or an array of strings, rounding each decimal
+  outward.
+- **Numbers that are not doubles round outward.** A Python int beyond
+  2^53, a `Fraction`, a `Decimal`, a long double, an int64 array: each
+  becomes the two doubles around it, never the nearest one, as an end,
+  as an operand (`x + Fraction(1, 3)`) or as a member to test
+  (`2**53 + 1 in x`). A float is taken as the double it is, so `0.1` is
+  already rounded: give decimals as text or `Decimal`.
+- **Arithmetic:** `+ - * /`, unary `-`, `abs`, `**` (an integer power
+  is `pown`, tight; any other `pow`), `&` (intersection), `|` (hull).
+- **40 functions:** `exp exp2 exp10 expm1 log log2 log10 log1p sqrt cbrt
+  rsqrt sin cos tan sinpi cospi tanpi asin acos atan asinpi acospi atanpi
+  sinh cosh tanh asinh acosh atanh erf erfc tgamma sqr recip sign ceil
+  floor trunc round roundeven`, and `atan2 hypot pow min max cancelminus
+  cancelplus pown rootn fma`.
+- **The accurate mode:** `acc_exp`, `acc_sin`, ... (the first 32 above,
+  and `acc_atan2`, `acc_hypot`, `acc_pow`) are at most one ulp wider than
+  the tight result, and faster on arrays, when the environment variable
+  `IVAL_CRMVEC` names crmvec's `libmvec.so.1` (x86-64 with AVX2 and FMA).
+  Without it they give the tight result.
+- **Reverse operations** (the tightest interval around
+  `{x in X : f(x) in C}`, X the whole line if omitted): `sqrrev absrev
+  coshrev sinrev cosrev tanrev pownrev mulrev powrev1 powrev2`.
+- **Measures and tests:** `.inf .sup .mid .wid .rad .mag .mig`,
+  `is_empty() is_entire() is_singleton()`, `subset interior disjoint
+  equal`, `contains(X, v)` and `v in X`.
+
+The rounding mode is the library's business: it sets what it needs and
+restores the caller's, so nothing here changes how the rest of a program
+rounds. A call releases the GIL, and the library is thread-safe.
+
+## Speed, and pyinterval
+
+pyinterval (on CRlibm) was Python's correctly rounded interval library.
+Its last release was in March 2017, and `pip install pyinterval` fails on
+Python 3.12: its crlibm imports `distutils.command.upload`, which Python
+3.12 lacks and setuptools 75 dropped. Built with setuptools 74 and no
+build isolation, it and this binding were run on the same inputs by
+`bench/pyinterval_compare.py`, on an AMD Ryzen 5 PRO 5650U, 2026-10-09:
+
+- **Bounds:** on 2,000 points each of exp, log, sin, cos, tan, atan,
+  sqrt, sinh, cosh, expm1 and log1p, both tight and the same, bound for
+  bound. pyinterval's tanh is a quotient of sinh and cosh, every bound
+  rounded outward: valid, but not tight on any of the 2,000 points, up to
+  4 doubles too wide.
+- **Time per interval,** for intervals of width 0.5 (and 1, for `b`):
+
+  | | pyinterval | ival, one at a time | ival, an array of 20,000 |
+  |---|---:|---:|---:|
+  | exp | 11.0 µs | 1.8 µs | 25 ns |
+  | sin | 11.7 µs | 1.8 µs | 141 ns |
+  | atan | 10.8 µs | 1.7 µs | 31 ns |
+  | `a*b + 2` | 22.2 µs | 4.5 µs | 20 ns |
+
+  One interval at a time costs about a microsecond of ctypes per call;
+  arrays pay it once per call.
+
+## Tests
+
+`make ival-python-check` at the root of crnumerics runs `tests/` against
+the library just built (it needs pytest and mpmath): bounds against
+mpmath at 300 bits and exact fractions, arrays against one interval at
+a time, outward rounding of numbers that are not doubles, the reverse
+operations and the accurate mode.

crival-0.2.0/README.md

@@ -0,0 +1,121 @@
+# ival for Python
+
+Interval arithmetic over NumPy arrays: every result is the tightest
+interval of doubles around the exact one (IEEE 1788.1). It calls
+crnumerics' C library `libival`, whose functions are CORE-MATH's,
+correctly rounded.
+
+```python
+import ival, numpy as np
+
+x = ival.Interval(1, 2)
+ival.exp(x) * x + 1                # Interval(3.718281828459045, 15.7781121978613)
+ival.Interval(0.1) + 0.2           # Interval(0.3, 0.30000000000000004): the exact sum inside
+ival.Interval.from_text("[0.1]")   # Interval(0.09999999999999999, 0.1): the decimal 0.1 inside
+X = ival.Interval(np.linspace(0, 1, 10**6), np.linspace(0, 1, 10**6) + 1e-3)
+ival.sin(X)                        # a million intervals in one call
+```
+
+## Installing
+
+On Linux x86-64 and aarch64 (glibc 2.26 or later), the wheels on PyPI
+carry the library, so nothing else needs installing. The package is
+`crival` on PyPI; the module is `ival`:
+
+```sh
+pip install crival
+python3 -c 'import ival; print(ival.exp(ival.Interval(1)))'
+```
+
+Elsewhere, or to use a libival you installed, install `libival` first,
+from the root of crnumerics, then the package:
+
+```sh
+make install-ival PREFIX=$HOME/.local     # or /usr/local; installs libival.so.0 and ival.pc
+pip install ./ival/python                 # numpy is the one dependency
+```
+
+`ival/python/build-wheel.sh` builds a wheel that carries the library,
+for the glibc it was built on and newer. The wheels on PyPI are built in
+the manylinux_2_28 containers by `.github/workflows/wheels.yml`.
+
+The binding finds the library through `IVAL_LIBRARY` (a path), then a
+copy inside the package (a wheel's), then the system's linker paths, then `pkg-config --variable=libdir ival` (for a
+prefix like `$HOME/.local`, `PKG_CONFIG_PATH` must include its
+`lib/pkgconfig`).
+`ival.library_path` says which it loaded, and `ival.version()` the
+library's version. It works with libival 0.1.0 and later; 0.2.0 fixes sinRev, cosRev
+and tanRev, which in 0.1.0 could miss a set. Python 3.9 or
+later; tested on Linux x86-64 and aarch64.
+
+## What there is
+
+- **`Interval(lo, hi)`**, or `Interval(a)` for the smallest interval
+  holding `a`. One interval holds two Python floats; an array of them two
+  float64 arrays, broadcast as NumPy does. The empty interval is
+  `[nan, nan]`; `Interval(lo, hi)` is empty unless `lo <= hi`
+  (1788's numsToInterval). `Interval.from_text("[0.1, 0.2]")` reads 1788's
+  text forms, a string or an array of strings, rounding each decimal
+  outward.
+- **Numbers that are not doubles round outward.** A Python int beyond
+  2^53, a `Fraction`, a `Decimal`, a long double, an int64 array: each
+  becomes the two doubles around it, never the nearest one, as an end,
+  as an operand (`x + Fraction(1, 3)`) or as a member to test
+  (`2**53 + 1 in x`). A float is taken as the double it is, so `0.1` is
+  already rounded: give decimals as text or `Decimal`.
+- **Arithmetic:** `+ - * /`, unary `-`, `abs`, `**` (an integer power
+  is `pown`, tight; any other `pow`), `&` (intersection), `|` (hull).
+- **40 functions:** `exp exp2 exp10 expm1 log log2 log10 log1p sqrt cbrt
+  rsqrt sin cos tan sinpi cospi tanpi asin acos atan asinpi acospi atanpi
+  sinh cosh tanh asinh acosh atanh erf erfc tgamma sqr recip sign ceil
+  floor trunc round roundeven`, and `atan2 hypot pow min max cancelminus
+  cancelplus pown rootn fma`.
+- **The accurate mode:** `acc_exp`, `acc_sin`, ... (the first 32 above,
+  and `acc_atan2`, `acc_hypot`, `acc_pow`) are at most one ulp wider than
+  the tight result, and faster on arrays, when the environment variable
+  `IVAL_CRMVEC` names crmvec's `libmvec.so.1` (x86-64 with AVX2 and FMA).
+  Without it they give the tight result.
+- **Reverse operations** (the tightest interval around
+  `{x in X : f(x) in C}`, X the whole line if omitted): `sqrrev absrev
+  coshrev sinrev cosrev tanrev pownrev mulrev powrev1 powrev2`.
+- **Measures and tests:** `.inf .sup .mid .wid .rad .mag .mig`,
+  `is_empty() is_entire() is_singleton()`, `subset interior disjoint
+  equal`, `contains(X, v)` and `v in X`.
+
+The rounding mode is the library's business: it sets what it needs and
+restores the caller's, so nothing here changes how the rest of a program
+rounds. A call releases the GIL, and the library is thread-safe.
+
+## Speed, and pyinterval
+
+pyinterval (on CRlibm) was Python's correctly rounded interval library.
+Its last release was in March 2017, and `pip install pyinterval` fails on
+Python 3.12: its crlibm imports `distutils.command.upload`, which Python
+3.12 lacks and setuptools 75 dropped. Built with setuptools 74 and no
+build isolation, it and this binding were run on the same inputs by
+`bench/pyinterval_compare.py`, on an AMD Ryzen 5 PRO 5650U, 2026-10-09:
+
+- **Bounds:** on 2,000 points each of exp, log, sin, cos, tan, atan,
+  sqrt, sinh, cosh, expm1 and log1p, both tight and the same, bound for
+  bound. pyinterval's tanh is a quotient of sinh and cosh, every bound
+  rounded outward: valid, but not tight on any of the 2,000 points, up to
+  4 doubles too wide.
+- **Time per interval,** for intervals of width 0.5 (and 1, for `b`):
+
+  | | pyinterval | ival, one at a time | ival, an array of 20,000 |
+  |---|---:|---:|---:|
+  | exp | 11.0 µs | 1.8 µs | 25 ns |
+  | sin | 11.7 µs | 1.8 µs | 141 ns |
+  | atan | 10.8 µs | 1.7 µs | 31 ns |
+  | `a*b + 2` | 22.2 µs | 4.5 µs | 20 ns |
+
+  One interval at a time costs about a microsecond of ctypes per call;
+  arrays pay it once per call.
+
+## Tests
+
+`make ival-python-check` at the root of crnumerics runs `tests/` against
+the library just built (it needs pytest and mpmath): bounds against
+mpmath at 300 bits and exact fractions, arrays against one interval at
+a time, outward rounding of numbers that are not doubles, the reverse
+operations and the accurate mode.

crival-0.2.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "crival"   # on PyPI; the module is ival (import ival)
+version = "0.2.0"
+description = "Tight IEEE 1788.1 interval arithmetic over NumPy arrays, on crnumerics' libival (CORE-MATH's correctly rounded functions)"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"   # math.nextafter
+dependencies = ["numpy"]
+
+[project.urls]
+Source = "https://github.com/anun333/crnumerics/tree/main/ival"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+ival = ["libival.so.0", "LICENSE", "LICENSE-CORE-MATH"]   # present only in a wheel from build-wheel.sh

crival-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

crival-0.2.0/setup.py

@@ -0,0 +1,27 @@
+"""Only for a wheel that carries libival.so.0 (build-wheel.sh): it is for one platform, and the package is Python
+and ctypes, so any Python 3 can use it. The distribution reports binaries, which files the package as platlib,
+and the tag says py3-none-<platform>."""
+import os
+
+from setuptools import setup
+from setuptools.dist import Distribution
+
+bundled = os.path.exists(os.path.join(os.path.dirname(os.path.abspath(__file__)), "src", "ival", "libival.so.0"))
+kw = {}
+if bundled:
+    try:
+        from setuptools.command.bdist_wheel import bdist_wheel
+    except ImportError:   # setuptools before 70.1
+        from wheel.bdist_wheel import bdist_wheel
+
+    class BinaryDistribution(Distribution):
+        def has_ext_modules(self):
+            return True
+
+    class PlatformWheel(bdist_wheel):
+        def get_tag(self):
+            return "py3", "none", super().get_tag()[2]
+
+    kw = {"distclass": BinaryDistribution, "cmdclass": {"bdist_wheel": PlatformWheel}}
+
+setup(**kw)

crival-0.2.0/src/crival.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: crival
+Version: 0.2.0
+Summary: Tight IEEE 1788.1 interval arithmetic over NumPy arrays, on crnumerics' libival (CORE-MATH's correctly rounded functions)
+License: MIT
+Project-URL: Source, https://github.com/anun333/crnumerics/tree/main/ival
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# ival for Python
+
+Interval arithmetic over NumPy arrays: every result is the tightest
+interval of doubles around the exact one (IEEE 1788.1). It calls
+crnumerics' C library `libival`, whose functions are CORE-MATH's,
+correctly rounded.
+
+```python
+import ival, numpy as np
+
+x = ival.Interval(1, 2)
+ival.exp(x) * x + 1                # Interval(3.718281828459045, 15.7781121978613)
+ival.Interval(0.1) + 0.2           # Interval(0.3, 0.30000000000000004): the exact sum inside
+ival.Interval.from_text("[0.1]")   # Interval(0.09999999999999999, 0.1): the decimal 0.1 inside
+X = ival.Interval(np.linspace(0, 1, 10**6), np.linspace(0, 1, 10**6) + 1e-3)
+ival.sin(X)                        # a million intervals in one call
+```
+
+## Installing
+
+On Linux x86-64 and aarch64 (glibc 2.26 or later), the wheels on PyPI
+carry the library, so nothing else needs installing. The package is
+`crival` on PyPI; the module is `ival`:
+
+```sh
+pip install crival
+python3 -c 'import ival; print(ival.exp(ival.Interval(1)))'
+```
+
+Elsewhere, or to use a libival you installed, install `libival` first,
+from the root of crnumerics, then the package:
+
+```sh
+make install-ival PREFIX=$HOME/.local     # or /usr/local; installs libival.so.0 and ival.pc
+pip install ./ival/python                 # numpy is the one dependency
+```
+
+`ival/python/build-wheel.sh` builds a wheel that carries the library,
+for the glibc it was built on and newer. The wheels on PyPI are built in
+the manylinux_2_28 containers by `.github/workflows/wheels.yml`.
+
+The binding finds the library through `IVAL_LIBRARY` (a path), then a
+copy inside the package (a wheel's), then the system's linker paths, then `pkg-config --variable=libdir ival` (for a
+prefix like `$HOME/.local`, `PKG_CONFIG_PATH` must include its
+`lib/pkgconfig`).
+`ival.library_path` says which it loaded, and `ival.version()` the
+library's version. It works with libival 0.1.0 and later; 0.2.0 fixes sinRev, cosRev
+and tanRev, which in 0.1.0 could miss a set. Python 3.9 or
+later; tested on Linux x86-64 and aarch64.
+
+## What there is
+
+- **`Interval(lo, hi)`**, or `Interval(a)` for the smallest interval
+  holding `a`. One interval holds two Python floats; an array of them two
+  float64 arrays, broadcast as NumPy does. The empty interval is
+  `[nan, nan]`; `Interval(lo, hi)` is empty unless `lo <= hi`
+  (1788's numsToInterval). `Interval.from_text("[0.1, 0.2]")` reads 1788's
+  text forms, a string or an array of strings, rounding each decimal
+  outward.
+- **Numbers that are not doubles round outward.** A Python int beyond
+  2^53, a `Fraction`, a `Decimal`, a long double, an int64 array: each
+  becomes the two doubles around it, never the nearest one, as an end,
+  as an operand (`x + Fraction(1, 3)`) or as a member to test
+  (`2**53 + 1 in x`). A float is taken as the double it is, so `0.1` is
+  already rounded: give decimals as text or `Decimal`.
+- **Arithmetic:** `+ - * /`, unary `-`, `abs`, `**` (an integer power
+  is `pown`, tight; any other `pow`), `&` (intersection), `|` (hull).
+- **40 functions:** `exp exp2 exp10 expm1 log log2 log10 log1p sqrt cbrt
+  rsqrt sin cos tan sinpi cospi tanpi asin acos atan asinpi acospi atanpi
+  sinh cosh tanh asinh acosh atanh erf erfc tgamma sqr recip sign ceil
+  floor trunc round roundeven`, and `atan2 hypot pow min max cancelminus
+  cancelplus pown rootn fma`.
+- **The accurate mode:** `acc_exp`, `acc_sin`, ... (the first 32 above,
+  and `acc_atan2`, `acc_hypot`, `acc_pow`) are at most one ulp wider than
+  the tight result, and faster on arrays, when the environment variable
+  `IVAL_CRMVEC` names crmvec's `libmvec.so.1` (x86-64 with AVX2 and FMA).
+  Without it they give the tight result.
+- **Reverse operations** (the tightest interval around
+  `{x in X : f(x) in C}`, X the whole line if omitted): `sqrrev absrev
+  coshrev sinrev cosrev tanrev pownrev mulrev powrev1 powrev2`.
+- **Measures and tests:** `.inf .sup .mid .wid .rad .mag .mig`,
+  `is_empty() is_entire() is_singleton()`, `subset interior disjoint
+  equal`, `contains(X, v)` and `v in X`.
+
+The rounding mode is the library's business: it sets what it needs and
+restores the caller's, so nothing here changes how the rest of a program
+rounds. A call releases the GIL, and the library is thread-safe.
+
+## Speed, and pyinterval
+
+pyinterval (on CRlibm) was Python's correctly rounded interval library.
+Its last release was in March 2017, and `pip install pyinterval` fails on
+Python 3.12: its crlibm imports `distutils.command.upload`, which Python
+3.12 lacks and setuptools 75 dropped. Built with setuptools 74 and no
+build isolation, it and this binding were run on the same inputs by
+`bench/pyinterval_compare.py`, on an AMD Ryzen 5 PRO 5650U, 2026-10-09:
+
+- **Bounds:** on 2,000 points each of exp, log, sin, cos, tan, atan,
+  sqrt, sinh, cosh, expm1 and log1p, both tight and the same, bound for
+  bound. pyinterval's tanh is a quotient of sinh and cosh, every bound
+  rounded outward: valid, but not tight on any of the 2,000 points, up to
+  4 doubles too wide.
+- **Time per interval,** for intervals of width 0.5 (and 1, for `b`):
+
+  | | pyinterval | ival, one at a time | ival, an array of 20,000 |
+  |---|---:|---:|---:|
+  | exp | 11.0 µs | 1.8 µs | 25 ns |
+  | sin | 11.7 µs | 1.8 µs | 141 ns |
+  | atan | 10.8 µs | 1.7 µs | 31 ns |
+  | `a*b + 2` | 22.2 µs | 4.5 µs | 20 ns |
+
+  One interval at a time costs about a microsecond of ctypes per call;
+  arrays pay it once per call.
+
+## Tests
+
+`make ival-python-check` at the root of crnumerics runs `tests/` against
+the library just built (it needs pytest and mpmath): bounds against
+mpmath at 300 bits and exact fractions, arrays against one interval at
+a time, outward rounding of numbers that are not doubles, the reverse
+operations and the accurate mode.

crival-0.2.0/src/crival.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/crival.egg-info/PKG-INFO
+src/crival.egg-info/SOURCES.txt
+src/crival.egg-info/dependency_links.txt
+src/crival.egg-info/requires.txt
+src/crival.egg-info/top_level.txt
+src/ival/__init__.py
+tests/test_ival.py

crival-0.2.0/src/crival.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crival-0.2.0/src/crival.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

crival-0.2.0/src/crival.egg-info/top_level.txt

@@ -0,0 +1 @@
+ival

crival-0.2.0/src/ival/__init__.py

@@ -0,0 +1,577 @@
+"""ival for Python: tight IEEE 1788.1 intervals over NumPy arrays, from crnumerics' C library libival.
+
+An Interval holds one interval, as two Python floats, or an array of them, as two NumPy arrays of float64 broadcast
+like NumPy. Every result is the tightest binary64 interval around the exact one: the functions are CORE-MATH's,
+correctly rounded in every rounding mode. The empty interval is [nan, nan].
+
+    import ival
+    x = ival.Interval(1, 2)
+    y = ival.exp(x) * x + 1                          # [e + 1, 2 e^2 + 1], each end rounded outward
+    t = ival.Interval.from_text("[0.1, 0.2]")       # decimal ends rounded outward, not to nearest
+    s = ival.sin(ival.Interval([0, 1, 2], [0.5, 4, 3]))   # three intervals at once
+
+A number that is not a double (a large int, a Fraction, a Decimal, a long double) becomes the two doubles around it,
+never the nearest one, wherever it is given: as an end, as an operand, or as a member to test.
+
+The library is libival.so.0: found by the environment variable IVAL_LIBRARY, then a copy inside this package (a
+wheel's), then the system's linker paths (crnumerics' `make install`), then pkg-config's libdir for ival.
+"""
+import ctypes
+import ctypes.util
+import math
+import numbers
+import os
+import subprocess
+from decimal import Decimal
+from fractions import Fraction
+
+import numpy as np
+
+__all__ = ["Interval", "version", "library_path"]
+
+_N = ctypes.c_size_t
+_c = ctypes.c_double
+_ref = ctypes.byref
+_ONE = ctypes.c_size_t(1)
+_INF = math.inf
+_NAN = math.nan
+
+
+def _find():
+    env = os.environ.get("IVAL_LIBRARY")
+    if env:
+        return env
+    here = os.path.join(os.path.dirname(os.path.abspath(__file__)), "libival.so.0")
+    if os.path.exists(here):   # a wheel's own copy (build-wheel.sh)
+        return here
+    for name in ("libival.so.0", "libival.so"):
+        try:
+            ctypes.CDLL(name)
+            return name
+        except OSError:
+            pass
+    found = ctypes.util.find_library("ival")
+    if found:
+        return found
+    try:
+        libdir = subprocess.run(["pkg-config", "--variable=libdir", "ival"], capture_output=True, text=True,
+                                check=True).stdout.strip()
+        for name in ("libival.so.0", "libival.so"):
+            path = os.path.join(libdir, name)
+            if os.path.exists(path):
+                return path
+    except (OSError, subprocess.CalledProcessError):
+        pass
+    raise OSError("ival: libival.so not found; install crnumerics' ival (make install) or set IVAL_LIBRARY")
+
+
+library_path = _find()
+_lib = ctypes.CDLL(library_path)
+_lib.ival_version.restype = ctypes.c_char_p
+_lib.ival_version.argtypes = []
+
+
+def version():
+    """The C library's version (IVAL_VERSION of the ival.h it was built from)."""
+    return _lib.ival_version().decode()
+
+
+def _arr(x):   # float64, C-contiguous, keeping a 0-d array 0-d (np.ascontiguousarray makes it 1-d)
+    return np.require(x, dtype=np.float64, requirements="C")
+
+
+def _p(a):   # the array's address (the array stays alive through the call: the caller holds it)
+    return ctypes.c_void_p(a.ctypes.data)
+
+
+# ---- numbers to doubles, rounded outward
+def _round(v, up):
+    """the real number v as a double: v itself when it is one, else the double just above it (up) or below it"""
+    if type(v) is float:
+        return v
+    if isinstance(v, np.integer):
+        v = int(v)                       # NumPy compares an int64 with a float in float64, inexactly
+    elif isinstance(v, (np.bool_, bool)) or not isinstance(v, (numbers.Real, Decimal)):
+        raise TypeError(f"ival: an interval's end must be a real number, not {type(v).__name__}")
+    try:
+        f = float(v)                     # to nearest
+    except OverflowError:                # an int or a Fraction beyond the largest double
+        f = _INF if v > 0 else -_INF
+    if f != f or f == v:                 # NaN, or exact (the comparisons are exact for int, Fraction, Decimal, long double)
+        return f
+    if up:
+        return f if f > v else math.nextafter(f, _INF)
+    return f if f < v else math.nextafter(f, -_INF)
+
+
+def _exact(v):   # v as a Fraction; None for an infinity or NaN
+    if isinstance(v, np.integer):
+        v = int(v)
+    try:
+        return Fraction(*v.as_integer_ratio())
+    except (OverflowError, ValueError, AttributeError):
+        return None
+
+
+def _ends(x, up):
+    """an array of numbers as float64, each rounded outward (up or down) when it is not a double; and a mask of
+    the ones rounded (None when none can be)"""
+    a = np.asarray(x)
+    k, size = a.dtype.kind, a.dtype.itemsize
+    if a.dtype == np.float64 or (k in "iuf" and size <= 4):
+        return _arr(a), None                                # exact in float64
+    if k == "f":                                            # a long double: compared with its rounding exactly
+        f = a.astype(np.float64)
+        moved = f < a if up else f > a
+        return _arr(np.where(moved, np.nextafter(f, _INF if up else -_INF), f)), moved
+    if k in "iu":
+        f = a.astype(np.float64)
+        moved = (a > 2**53) | (a < -2**53) if k == "i" else a > 2**53
+        if moved.any():
+            f[moved] = [_round(int(v), up) for v in a[moved]]
+        return _arr(f), moved
+    if k == "O":
+        f = np.array([_round(v, up) for v in a.ravel()], dtype=np.float64).reshape(a.shape)
+        return _arr(f), np.array([type(v) is not float for v in a.ravel()], dtype=bool).reshape(a.shape)
+    if k == "b":
+        raise TypeError("ival: an interval's end must be a real number, not a bool")
+    raise TypeError(f"ival: an interval's end must be a real number, not {a.dtype}"
+                    + (" (text goes through Interval.from_text)" if k in "US" else ""))
+
+
+def _same(*arrs):
+    """the arrays broadcast to one shape, as C float64 arrays; when they are arrays of one shape and floats (an
+    array and a number), the arrays pass as they are and each float is filled out, cheaper than broadcasting"""
+    s = next((a.shape for a in arrs if type(a) is np.ndarray), None)
+    if s is not None and all(type(a) is float or (type(a) is np.ndarray and a.shape == s) for a in arrs):
+        return [np.full(s, a) if type(a) is float else _arr(a) for a in arrs]
+    return [_arr(a) for a in np.broadcast_arrays(*arrs)]
+
+
+def _mk(lo, hi):
+    obj = _new(Interval)
+    obj.lo, obj.hi = lo, hi
+    return obj
+
+
+def _wrap(lo, hi):   # an array result; one interval is kept as two floats
+    return _mk(float(lo), float(hi)) if lo.ndim == 0 else _mk(lo, hi)
+
+
+def _one(lo, hi):
+    """[lo, hi] for two doubles, as ival_nums makes it: empty unless lo <= hi, lo != +inf, hi != -inf; zeros +0"""
+    if lo <= hi and lo != _INF and hi != -_INF:
+        return _mk(0.0 if lo == 0 else lo, 0.0 if hi == 0 else hi)
+    return _mk(_NAN, _NAN)
+
+
+class Interval:
+    """One interval, or a NumPy-shaped array of them: lo and hi are two floats, or two float64 arrays of one shape;
+    [nan, nan] is empty. Interval(a) is the smallest interval holding the number a (the point [a, a] when a is a
+    double); Interval(lo, hi) is the smallest holding [lo, hi], empty unless lo <= hi, lo != +inf and hi != -inf
+    (1788's numsToInterval). Decimal ends are best given as text (from_text) or as Decimal: 0.1 as a float is
+    already rounded to nearest."""
+
+    __slots__ = ("lo", "hi")
+    __array_priority__ = 1000   # so that ndarray + Interval comes here
+
+    def __init__(self, lo, hi=None):
+        point = hi is None
+        if point:
+            hi = lo
+        if type(lo) is int and -2**53 <= lo <= 2**53:   # exact as a double
+            lo = float(lo)
+        if type(hi) is int and -2**53 <= hi <= 2**53:
+            hi = float(hi)
+        if type(lo) is float and type(hi) is float:   # as ival_nums does it, without the call
+            if lo <= hi and lo != _INF and hi != -_INF:
+                self.lo, self.hi = 0.0 if lo == 0 else lo, 0.0 if hi == 0 else hi
+            else:
+                self.lo = self.hi = _NAN
+            return
+        if not (isinstance(lo, np.ndarray) or isinstance(hi, np.ndarray)) and np.ndim(lo) == 0 and np.ndim(hi) == 0:
+            l, h = _round(lo, False), _round(hi, True)
+            if (type(lo) is not float or type(hi) is not float) and not point:
+                ql, qh = _exact(lo), _exact(hi)   # rounded: lo > hi is decided on the numbers themselves
+                if ql is not None and qh is not None and ql > qh:
+                    l = h = _NAN
+            r = _one(l, h)
+            self.lo, self.hi = r.lo, r.hi
+            return
+        a, b = np.broadcast_arrays(np.asarray(lo), np.asarray(hi))
+        lo_d, ml = _ends(a, False)
+        hi_d, mh = _ends(b, True)
+        if (ml is not None or mh is not None) and not point:
+            moved = (ml if ml is not None else False) | (mh if mh is not None else False)
+            lo_d, hi_d = lo_d.copy(), hi_d.copy()
+            for k in np.flatnonzero(moved):
+                ql, qh = _exact(a.flat[k]), _exact(b.flat[k])
+                if ql is not None and qh is not None and ql > qh:
+                    lo_d.flat[k] = hi_d.flat[k] = _NAN
+        out_lo, out_hi, st = np.empty_like(lo_d), np.empty_like(lo_d), np.empty(lo_d.shape, dtype=np.uint8)
+        _lib.ival_nums(_p(lo_d), _p(hi_d), _p(out_lo), _p(out_hi), _p(st), lo_d.size)
+        if out_lo.ndim == 0:
+            out_lo, out_hi = float(out_lo), float(out_hi)
+        self.lo, self.hi = out_lo, out_hi
+
+    @classmethod
+    def from_text(cls, s):
+        """1788's textToInterval: "[0.1, 0.2]", "[1]", "0.1" (a point), "[entire]", "[empty]", "1.5?3" ...; each
+        decimal end rounded outward. s may be a string or an array of strings."""
+        strs = np.asarray(s, dtype=object)
+        flat = [str(t).encode() for t in strs.ravel()]
+        n = len(flat)
+        arr = (ctypes.c_char_p * n)(*flat)
+        lo, hi, st = np.empty(n), np.empty(n), np.empty(n, dtype=np.uint8)
+        _lib.ival_text(arr, _p(lo), _p(hi), _p(st), n)
+        return _wrap(lo.reshape(strs.shape), hi.reshape(strs.shape))
+
+    @classmethod
+    def empty(cls, shape=()):
+        return _mk(_NAN, _NAN) if shape == () else _mk(np.full(shape, np.nan), np.full(shape, np.nan))
+
+    @classmethod
+    def entire(cls, shape=()):
+        return _mk(-_INF, _INF) if shape == () else _mk(np.full(shape, -np.inf), np.full(shape, np.inf))
+
+    # ---- shape and access
+    @property
+    def shape(self):
+        return np.shape(self.lo)
+
+    def __len__(self):
+        return len(self.lo)
+
+    def __getitem__(self, k):
+        return _wrap(_arr(self.lo[k]), _arr(self.hi[k]))
+
+    def __iter__(self):
+        for k in range(len(self)):
+            yield self[k]
+
+    def __repr__(self):
+        if type(self.lo) is float:
+            return f"Interval({self.lo!r}, {self.hi!r})" if self.lo == self.lo else "Interval.empty()"
+        return f"Interval(lo={self.lo!r}, hi={self.hi!r})"
+
+    # ---- arithmetic (tight; a number is the smallest interval holding it)
+    def __add__(self, o): return _bin(_lib.ival_add, self, o)
+    def __radd__(self, o): return _bin(_lib.ival_add, o, self)
+    def __sub__(self, o): return _bin(_lib.ival_sub, self, o)
+    def __rsub__(self, o): return _bin(_lib.ival_sub, o, self)
+    def __mul__(self, o): return _bin(_lib.ival_mul, self, o)
+    def __rmul__(self, o): return _bin(_lib.ival_mul, o, self)
+    def __truediv__(self, o): return _bin(_lib.ival_div, self, o)
+    def __rtruediv__(self, o): return _bin(_lib.ival_div, o, self)
+    def __neg__(self): return _un(_lib.ival_neg, self)
+    def __pos__(self): return self
+    def __abs__(self): return _un(_lib.ival_abs, self)
+
+    def __pow__(self, p):
+        if isinstance(p, (int, np.integer)) or (isinstance(p, np.ndarray) and p.dtype.kind in "iu"):
+            return pown(self, p)
+        return pow(self, p)
+
+    # ---- the 1788 measures and tests
+    @property
+    def inf(self): return _num(_lib.ival_inf, self)
+    @property
+    def sup(self): return _num(_lib.ival_sup, self)
+    @property
+    def mid(self): return _num(_lib.ival_mid, self)
+    @property
+    def wid(self): return _num(_lib.ival_wid, self)
+    @property
+    def rad(self): return _num(_lib.ival_rad, self)
+    @property
+    def mag(self): return _num(_lib.ival_mag, self)
+    @property
+    def mig(self): return _num(_lib.ival_mig, self)
+
+    def is_empty(self): return _bool1(_lib.ival_isempty, self)
+    def is_entire(self): return _bool1(_lib.ival_isentire, self)
+    def is_singleton(self): return _bool1(_lib.ival_issingleton, self)
+
+    def __contains__(self, x):
+        """x in X: the number x lies in X (in every interval of an array)"""
+        r = contains(self, x)
+        return bool(r) if np.ndim(r) == 0 else bool(np.all(r))
+
+    def subset(self, o): return _bool2(_lib.ival_subset, self, o)
+    def interior(self, o): return _bool2(_lib.ival_interior, self, o)
+    def disjoint(self, o): return _bool2(_lib.ival_disjoint, self, o)
+    def equal(self, o): return _bool2(_lib.ival_equal, self, o)
+
+    def __and__(self, o): return _bin(_lib.ival_intersect, self, o)
+    def __or__(self, o): return _bin(_lib.ival_hull, self, o)
+
+
+_new = object.__new__
+
+
+def _as_interval(x):
+    if isinstance(x, Interval):
+        return x
+    if type(x) is int and -2**53 <= x <= 2**53:
+        x = float(x)
+    if type(x) is float:   # a double is the point [x, x]; an infinity or NaN the empty interval
+        return _mk(0.0 if x == 0 else x, 0.0 if x == 0 else x) if -_INF < x < _INF else _mk(_NAN, _NAN)
+    return Interval(x)
+
+
+# Each operation below has two paths: one interval (two floats, passed by reference, with no NumPy: a call costs
+# about a microsecond) and arrays (broadcast, one call over all of them).
+def _out(shape):
+    return np.empty(shape), np.empty(shape)
+
+
+def _un(f, x):
+    x = _as_interval(x)
+    if type(x.lo) is float:
+        zl, zh = _c(), _c()
+        f(_ref(_c(x.lo)), _ref(_c(x.hi)), _ref(zl), _ref(zh), _ONE)
+        return _mk(zl.value, zh.value)
+    lo, hi = _arr(x.lo), _arr(x.hi)
+    zl, zh = _out(lo.shape)
+    f(_p(lo), _p(hi), _p(zl), _p(zh), _N(lo.size))
+    return _mk(zl, zh)
+
+
+def _bin(f, x, y):
+    x, y = _as_interval(x), _as_interval(y)
+    if type(x.lo) is float and type(y.lo) is float:
+        zl, zh = _c(), _c()
+        f(_ref(_c(x.lo)), _ref(_c(x.hi)), _ref(_c(y.lo)), _ref(_c(y.hi)), _ref(zl), _ref(zh), _ONE)
+        return _mk(zl.value, zh.value)
+    al, ah, bl, bh = _same(x.lo, x.hi, y.lo, y.hi)
+    zl, zh = _out(al.shape)
+    f(_p(al), _p(ah), _p(bl), _p(bh), _p(zl), _p(zh), _N(al.size))
+    return _wrap(zl, zh)
+
+
+def _num(f, x):
+    if type(x.lo) is float:
+        y = _c()
+        f(_ref(_c(x.lo)), _ref(_c(x.hi)), _ref(y), _ONE)
+        return y.value
+    lo, hi = _arr(x.lo), _arr(x.hi)
+    y = np.empty(lo.shape)
+    f(_p(lo), _p(hi), _p(y), _N(lo.size))
+    return y
+
+
+def _bool1(f, x):
+    if type(x.lo) is float:
+        r = ctypes.c_ubyte()
+        f(_ref(_c(x.lo)), _ref(_c(x.hi)), _ref(r), _ONE)
+        return bool(r.value)
+    lo, hi = _arr(x.lo), _arr(x.hi)
+    r = np.empty(lo.shape, dtype=np.uint8)
+    f(_p(lo), _p(hi), _p(r), _N(lo.size))
+    return r.astype(bool)
+
+
+def _bool2(f, x, y):
+    x, y = _as_interval(x), _as_interval(y)
+    if type(x.lo) is float and type(y.lo) is float:
+        r = ctypes.c_ubyte()
+        f(_ref(_c(x.lo)), _ref(_c(x.hi)), _ref(_c(y.lo)), _ref(_c(y.hi)), _ref(r), _ONE)
+        return bool(r.value)
+    al, ah, bl, bh = _same(x.lo, x.hi, y.lo, y.hi)
+    r = np.empty(al.shape, dtype=np.uint8)
+    f(_p(al), _p(ah), _p(bl), _p(bh), _p(r), _N(al.size))
+    return r.astype(bool) if r.ndim else bool(r)
+
+
+def contains(x, v):
+    """1788's isMember: whether the real number v lies in X, elementwise (an infinity never does)"""
+    x = _as_interval(x)
+    if np.ndim(v) == 0 and type(x.lo) is float:
+        if type(v) is not float:   # compared exactly, not rounded
+            q = _exact(v)
+            return q is not None and x.lo <= q <= x.hi
+        r = ctypes.c_ubyte()
+        _lib.ival_ismember(_ref(_c(v)), _ref(_c(x.lo)), _ref(_c(x.hi)), _ref(r), _ONE)
+        return bool(r.value)
+    a = np.asarray(v)
+    if not (a.dtype == np.float64 or (a.dtype.kind in "iuf" and a.dtype.itemsize <= 4)):
+        va, lo, hi = np.broadcast_arrays(a, x.lo, x.hi)
+        r = np.array([contains(_mk(float(l), float(h)), w) for w, l, h in zip(va.ravel(), lo.ravel(), hi.ravel())])
+        return r.reshape(va.shape) if va.ndim else bool(r[0])
+    v, lo, hi = (_arr(b) for b in np.broadcast_arrays(a, x.lo, x.hi))
+    r = np.empty(v.shape, dtype=np.uint8)
+    _lib.ival_ismember(_p(v), _p(lo), _p(hi), _p(r), _N(v.size))
+    return r.astype(bool) if r.ndim else bool(r)
+
+
+# ---- the functions, each the tightest interval around f over X (within f's domain)
+_UNARY = ["acos", "acosh", "acospi", "asin", "asinh", "asinpi", "atan", "atanh", "atanpi", "cbrt", "cos", "cosh",
+          "cospi", "erf", "erfc", "exp", "exp10", "exp2", "expm1", "log", "log10", "log1p", "log2", "rsqrt", "sin",
+          "sinh", "sinpi", "sqrt", "tan", "tanh", "tanpi", "tgamma", "sqr", "recip", "sign", "ceil", "floor",
+          "trunc", "round", "roundeven"]
+_BINARY = ["atan2", "hypot", "pow", "min", "max", "cancelminus", "cancelplus"]
+
+
+def _make_unary(name):
+    cf = getattr(_lib, "ival_" + name)
+
+    def f(x):
+        return _un(cf, x)
+    f.__name__ = name
+    f.__doc__ = f"ival_{name}: the tightest interval around {name}(x) for x in X, elementwise"
+    return f
+
+
+def _make_binary(name):
+    cf = getattr(_lib, "ival_" + name)
+
+    def f(x, y):
+        return _bin(cf, x, y)
+    f.__name__ = name
+    f.__doc__ = f"ival_{name}: the tightest interval around {name}(x, y) for x in X, y in Y, elementwise"
+    return f
+
+
+for _n in _UNARY:
+    globals()[_n] = _make_unary(_n)
+    __all__.append(_n)
+for _n in _BINARY:
+    globals()[_n] = _make_binary(_n)
+    __all__.append(_n)
+for _n in _UNARY[:32]:   # the 32 functions (ival-list.h) have the accurate mode: one ulp at most, at vector speed
+    globals()["acc_" + _n] = _make_unary("acc_" + _n)
+    __all__.append("acc_" + _n)
+for _n in ("atan2", "hypot", "pow"):
+    globals()["acc_" + _n] = _make_binary("acc_" + _n)
+    __all__.append("acc_" + _n)
+
+
+def _int1(p):   # an integer exponent or root as a C int
+    if type(p) is int and -2**31 <= p < 2**31:
+        return p
+    if isinstance(p, (np.bool_, bool)) or not isinstance(p, (numbers.Integral, np.integer)):
+        if not (isinstance(p, (numbers.Real, np.floating)) and float(p).is_integer()):
+            raise TypeError(f"ival: the power must be an integer, not {p!r}")
+    p = int(p)
+    if not -2**31 <= p < 2**31:
+        raise OverflowError(f"ival: the power {p} is beyond a C int")
+    return p
+
+
+def _ints(p):   # an array of them
+    a = np.asarray(p)
+    if a.dtype.kind not in "iu" and not (a.dtype.kind == "f" and np.all(a == np.floor(a))):
+        raise TypeError(f"ival: the powers must be integers, not {a.dtype}")
+    if a.size and (a.min() < -2**31 or a.max() >= 2**31):
+        raise OverflowError("ival: a power beyond a C int")
+    return a.astype(np.intc)
+
+
+def _pow_int(f, x, p):
+    x = _as_interval(x)
+    if type(x.lo) is float and (type(p) is int or np.ndim(p) == 0):
+        zl, zh = _c(), _c()
+        f(_ref(_c(x.lo)), _ref(_c(x.hi)), _ref(ctypes.c_int(_int1(p))), _ref(zl), _ref(zh), _ONE)
+        return _mk(zl.value, zh.value)
+    lo, hi, pp = np.broadcast_arrays(x.lo, x.hi, _ints(p))
+    lo, hi = _arr(lo), _arr(hi)
+    pp = np.require(pp, dtype=np.intc, requirements="C")
+    zl, zh = _out(lo.shape)
+    f(_p(lo), _p(hi), _p(pp), _p(zl), _p(zh), _N(lo.size))
+    return _wrap(zl, zh)
+
+
+def pown(x, p):
+    """x^p for integer p, elementwise (1788's pown): tight; a negative power of [0, 0] is empty"""
+    return _pow_int(_lib.ival_pown, x, p)
+
+
+def rootn(x, q):
+    """the real q-th root, elementwise (1788.1's rootn)"""
+    return _pow_int(_lib.ival_rootn, x, q)
+
+
+def fma(a, b, c):
+    """a * b + c with one rounding of each end, elementwise"""
+    a, b, c = _as_interval(a), _as_interval(b), _as_interval(c)
+    if type(a.lo) is float and type(b.lo) is float and type(c.lo) is float:
+        zl, zh = _c(), _c()
+        _lib.ival_fma(*(_ref(_c(v)) for v in (a.lo, a.hi, b.lo, b.hi, c.lo, c.hi)), _ref(zl), _ref(zh), _ONE)
+        return _mk(zl.value, zh.value)
+    arrs = _same(a.lo, a.hi, b.lo, b.hi, c.lo, c.hi)
+    zl, zh = _out(arrs[0].shape)
+    _lib.ival_fma(*(_p(v) for v in arrs), _p(zl), _p(zh), _N(arrs[0].size))
+    return _wrap(zl, zh)
+
+
+# ---- reverse operations: the tightest interval around {x in X : f(x) in C}
+def _make_rev(name):
+    cf = getattr(_lib, "ival_" + name)
+
+    def f(c, x=None):
+        c = _as_interval(c)
+        x = _mk(-_INF, _INF) if x is None else _as_interval(x)
+        if type(c.lo) is float and type(x.lo) is float:
+            zl, zh = _c(), _c()
+            cf(_ref(_c(c.lo)), _ref(_c(c.hi)), _ref(_c(x.lo)), _ref(_c(x.hi)), _ref(zl), _ref(zh), _ONE)
+            return _mk(zl.value, zh.value)
+        cl, ch, xl, xh = _same(c.lo, c.hi, x.lo, x.hi)
+        zl, zh = _out(cl.shape)
+        cf(_p(cl), _p(ch), _p(xl), _p(xh), _p(zl), _p(zh), _N(cl.size))
+        return _wrap(zl, zh)
+    f.__name__ = name
+    f.__doc__ = f"ival_{name}(C, X): the tightest interval around {{x in X : f(x) in C}} (X the whole line if omitted)"
+    return f
+
+
+for _n in ("sqrrev", "absrev", "coshrev", "sinrev", "cosrev", "tanrev"):
+    globals()[_n] = _make_rev(_n)
+    __all__.append(_n)
+
+
+def pownrev(c, p, x=None):
+    """the tightest interval around {x in X : x^p in C}"""
+    c = _as_interval(c)
+    x = _mk(-_INF, _INF) if x is None else _as_interval(x)
+    if type(c.lo) is float and type(x.lo) is float and (type(p) is int or np.ndim(p) == 0):
+        zl, zh = _c(), _c()
+        _lib.ival_pownrev(_ref(_c(c.lo)), _ref(_c(c.hi)), _ref(_c(x.lo)), _ref(_c(x.hi)),
+                          _ref(ctypes.c_int(_int1(p))), _ref(zl), _ref(zh), _ONE)
+        return _mk(zl.value, zh.value)
+    cl, ch, xl, xh, pp = np.broadcast_arrays(c.lo, c.hi, x.lo, x.hi, _ints(p))
+    cl, ch, xl, xh = _arr(cl), _arr(ch), _arr(xl), _arr(xh)
+    pp = np.require(pp, dtype=np.intc, requirements="C")
+    zl, zh = _out(cl.shape)
+    _lib.ival_pownrev(_p(cl), _p(ch), _p(xl), _p(xh), _p(pp), _p(zl), _p(zh), _N(cl.size))
+    return _wrap(zl, zh)
+
+
+def _rev3(f, b, c, x):
+    b, c = _as_interval(b), _as_interval(c)
+    x = _mk(-_INF, _INF) if x is None else _as_interval(x)
+    if type(b.lo) is float and type(c.lo) is float and type(x.lo) is float:
+        zl, zh = _c(), _c()
+        f(*(_ref(_c(v)) for v in (b.lo, b.hi, c.lo, c.hi, x.lo, x.hi)), _ref(zl), _ref(zh), _ONE)
+        return _mk(zl.value, zh.value)
+    arrs = _same(b.lo, b.hi, c.lo, c.hi, x.lo, x.hi)
+    zl, zh = _out(arrs[0].shape)
+    f(*(_p(v) for v in arrs), _p(zl), _p(zh), _N(arrs[0].size))
+    return _wrap(zl, zh)
+
+
+def mulrev(b, c, x=None):
+    """the tightest interval around {x in X : x b in C for some b in B}"""
+    return _rev3(_lib.ival_mulrev, b, c, x)
+
+
+def powrev1(b, c, x=None):
+    """the tightest interval around {x in X : x^y in C for some y in B}"""
+    return _rev3(_lib.ival_powrev1, b, c, x)
+
+
+def powrev2(a, c, y=None):
+    """the tightest interval around {y in Y : x^y in C for some x in A}"""
+    return _rev3(_lib.ival_powrev2, a, c, y)
+
+
+__all__ += ["pown", "rootn", "fma", "contains", "pownrev", "mulrev", "powrev1", "powrev2"]

crival-0.2.0/tests/test_ival.py

@@ -0,0 +1,193 @@
+"""Tests of ival's Python binding: results tight against mpmath (300 bits) and exact fractions, arrays elementwise
+the same as one interval at a time, the constructors, empty intervals, the reverse operations and the accurate mode.
+Run with libival on the linker's path or IVAL_LIBRARY naming it: python3 -m pytest ival/python/tests"""
+import math
+import random
+from fractions import Fraction
+
+import mpmath
+import numpy as np
+import pytest
+
+import ival
+
+mpmath.mp.prec = 300
+rng = random.Random(20261009)
+
+
+def adjacent(lo, hi):
+    """lo and hi the same double or neighbours: the tightest interval around a value not a double"""
+    return lo == hi or math.nextafter(lo, math.inf) == hi
+
+
+def brackets(lo, hi, exact):
+    return mpmath.mpf(lo) <= exact <= mpmath.mpf(hi)
+
+
+def test_version():
+    assert isinstance(ival.version(), str) and ival.version().count(".") == 2
+
+
+FUNCS = [("exp", mpmath.exp, lambda: rng.uniform(-700, 700)), ("log", mpmath.log, lambda: math.exp(rng.uniform(-700, 700))),
+         ("sin", mpmath.sin, lambda: rng.uniform(-1e6, 1e6)), ("cos", mpmath.cos, lambda: rng.uniform(-1e6, 1e6)),
+         ("tan", mpmath.tan, lambda: rng.uniform(-100, 100)), ("atan", mpmath.atan, lambda: rng.uniform(-1e3, 1e3)),
+         ("sinh", mpmath.sinh, lambda: rng.uniform(-700, 700)), ("tanh", mpmath.tanh, lambda: rng.uniform(-20, 20)),
+         ("cbrt", lambda x: mpmath.sign(x) * mpmath.cbrt(abs(x)), lambda: rng.uniform(-1e9, 1e9)),   # the real root
+         ("exp2", lambda x: mpmath.power(2, x), lambda: rng.uniform(-1000, 1000)),
+         ("log1p", mpmath.log1p, lambda: rng.uniform(-0.999, 1e6)), ("erf", mpmath.erf, lambda: rng.uniform(-6, 6)),
+         ("asinh", mpmath.asinh, lambda: rng.uniform(-1e6, 1e6)), ("sqrt", mpmath.sqrt, lambda: rng.uniform(0, 1e300))]
+
+
+@pytest.mark.parametrize("name,ref,gen", FUNCS, ids=[f[0] for f in FUNCS])
+def test_points_tight(name, ref, gen):
+    """f of a point [x, x]: the exact f(x) inside, the ends adjacent (each the exact value rounded down and up)"""
+    xs = np.array([gen() for _ in range(300)])
+    r = getattr(ival, name)(ival.Interval(xs))
+    for x, lo, hi in zip(xs, r.lo, r.hi):
+        exact = ref(mpmath.mpf(float(x)))
+        assert brackets(lo, hi, exact), (name, x, lo, hi)
+        assert adjacent(lo, hi), (name, x, lo, hi)
+
+
+def test_arith_exact():
+    """the four operations against exact fractions: inside, and the ends adjacent"""
+    for _ in range(2000):
+        a, b = rng.uniform(-1e6, 1e6), rng.uniform(-1e6, 1e6)
+        for op, ex in (("__add__", Fraction(a) + Fraction(b)), ("__sub__", Fraction(a) - Fraction(b)),
+                       ("__mul__", Fraction(a) * Fraction(b)), ("__truediv__", Fraction(a) / Fraction(b))):
+            r = getattr(ival.Interval(a), op)(b)
+            assert Fraction(float(r.lo)) <= ex <= Fraction(float(r.hi)), (op, a, b)
+            assert adjacent(float(r.lo), float(r.hi)), (op, a, b)
+
+
+def test_point_one_plus_point_two():
+    r = ival.Interval(0.1) + 0.2
+    assert float(r.lo) == 0.3 and float(r.hi) == math.nextafter(0.3, 1)
+
+
+def test_text_rounds_outward():
+    t = ival.Interval.from_text("[0.1, 0.2]")
+    assert Fraction(float(t.lo)) < Fraction("0.1") and adjacent(float(t.lo), 0.1)
+    assert Fraction(float(t.hi)) > Fraction("0.2") or float(t.hi) == 0.2
+    assert Fraction("0.2") <= Fraction(float(t.hi)) and adjacent(0.2, float(t.hi)) or float(t.hi) == 0.2
+    e = ival.Interval.from_text(["[empty]", "[entire]", "[1, 2]"])
+    assert e.shape == (3,) and e.is_empty()[0] and e.is_entire()[1] and float(e.lo[2]) == 1.0
+
+
+def test_arrays_match_one_at_a_time():
+    lo = np.array([rng.uniform(-10, 10) for _ in range(500)])
+    hi = lo + np.array([rng.uniform(0, 3) for _ in range(500)])
+    X = ival.Interval(lo, hi)
+    for f in (ival.sin, ival.exp, ival.atan, ival.sqr, ival.cosh):
+        R = f(X)
+        for k in range(0, 500, 37):
+            r = f(ival.Interval(lo[k], hi[k]))
+            assert (float(r.lo), float(r.hi)) == (R.lo[k], R.hi[k])
+    Y = X * 2 + 1                                          # broadcasting a number
+    assert Y.shape == (500,)
+    Z = X + ival.Interval(lo[:1], hi[:1])                  # a one-interval array broadcast
+    assert Z.shape == (500,)
+
+
+def test_empty():
+    e = ival.Interval(2, 1)
+    assert e.is_empty()
+    for r in (e + 1, ival.exp(e), e * ival.Interval(1, 2), ival.sqrt(ival.Interval(-3, -1))):
+        assert r.is_empty()
+    assert not ival.Interval(0, 1).is_empty()
+
+
+def test_domain_and_poles():
+    assert float(ival.log(ival.Interval(-1, 1)).lo) == -math.inf
+    t = ival.tan(ival.Interval(1, 2))                      # across pi/2
+    assert float(t.lo) == -math.inf and float(t.hi) == math.inf
+    assert float((ival.Interval(-2, 3) ** 2).lo) == 0.0     # an even power straddling 0
+
+
+def test_pown_tight():
+    for _ in range(300):
+        x, p = rng.uniform(-50, 50), rng.choice([2, 3, 4, 5, 7, 11, -1, -2, -3])
+        r = ival.pown(ival.Interval(x), p)
+        exact = mpmath.power(mpmath.mpf(x), p)
+        assert brackets(float(r.lo), float(r.hi), exact) and adjacent(float(r.lo), float(r.hi)), (x, p)
+
+
+def test_reverse():
+    r = ival.sqrrev(ival.Interval(4, 9))
+    assert (float(r.lo), float(r.hi)) == (-3.0, 3.0)
+    r = ival.sqrrev(ival.Interval(4, 9), ival.Interval(0, 10))
+    assert (float(r.lo), float(r.hi)) == (2.0, 3.0)
+    r = ival.powrev2(ival.Interval(0.25, 0.5), ival.Interval(2, math.inf))   # ITF1788.jl#8's case
+    assert (float(r.lo), float(r.hi)) == (-math.inf, -0.5)
+    r = ival.mulrev(ival.Interval(2, 4), ival.Interval(8, 8))
+    assert (float(r.lo), float(r.hi)) == (2.0, 4.0)
+
+
+def test_accurate_mode():
+    """one ulp at most outside the tight result (equal to it without crmvec)"""
+    xs = np.array([rng.uniform(-50, 50) for _ in range(400)])
+    X = ival.Interval(xs, xs + 0.5)
+    for name in ("exp", "sin", "log1p", "atan"):
+        T, A = getattr(ival, name)(X), getattr(ival, "acc_" + name)(X)
+        ok = ~np.isnan(T.lo)
+        assert np.all(A.lo[ok] <= T.lo[ok]) and np.all(A.hi[ok] >= T.hi[ok])
+        assert np.all(np.nextafter(T.lo[ok], -np.inf) <= A.lo[ok]) and np.all(A.hi[ok] <= np.nextafter(T.hi[ok], np.inf))
+
+
+def test_measures_and_membership():
+    x = ival.Interval(1, 3)
+    assert x.mid == 2.0 and x.wid == 2.0 and x.rad == 1.0 and x.mag == 3.0 and x.mig == 1.0
+    assert 2.5 in x and 3.5 not in x
+    assert ival.Interval(1.5, 2).subset(x) and not x.subset(ival.Interval(1.5, 2))
+    assert float((x & ival.Interval(2, 5)).lo) == 2.0 and float((x | ival.Interval(5, 6)).hi) == 6.0
+
+
+def _ok(r, exact):   # the interval r contains the exact number (a Fraction), and its ends are adjacent doubles
+    return Fraction(float(r.lo)) <= exact <= Fraction(float(r.hi)) and adjacent(float(r.lo), float(r.hi))
+
+
+def test_numbers_round_outward():
+    """a number that is not a double becomes the two doubles around it, not the nearest one"""
+    from decimal import Decimal
+    for v in (2**53 + 1, -(2**60) - 3, 10**20 + 7, Decimal("0.1"), Fraction(1, 3)):
+        assert _ok(ival.Interval(v), Fraction(v)), v
+    r = ival.Interval(Fraction(1, 3), 2**53 + 1)
+    assert Fraction(float(r.lo)) <= Fraction(1, 3) and Fraction(float(r.hi)) >= 2**53 + 1
+    assert ival.Interval(2**53 + 3, 2**53 + 1).is_empty()      # lo > hi though both round to 2^53 + 2
+    big = ival.Interval(10**400)                                # beyond the largest double
+    assert float(big.lo) == np.finfo(np.float64).max and float(big.hi) == math.inf
+    a = np.array([2**53 + 1, 2**62 + 1, -(2**63) + 1, 5], dtype=np.int64)
+    r = ival.Interval(a)
+    for k, v in enumerate(a.tolist()):
+        assert Fraction(float(r.lo[k])) <= v <= Fraction(float(r.hi[k])), v
+    if np.finfo(np.longdouble).nmant > 52:                      # x86's 80-bit long double
+        x = np.longdouble(1) / 3
+        assert _ok(ival.Interval(x), Fraction(*x.as_integer_ratio()))
+        r = ival.Interval(np.array([x, -x]))
+        assert _ok(r[1], -Fraction(*x.as_integer_ratio()))
+    assert (float(ival.Interval(0.5).lo), float(ival.Interval(7).hi)) == (0.5, 7.0)   # exact numbers stay points
+    r = ival.Interval(1, 2) + Fraction(1, 3)                                          # an operand too
+    assert Fraction(r.lo) <= Fraction(4, 3) and Fraction(r.hi) >= Fraction(7, 3)
+    assert ival.contains(ival.Interval(0, 2**53), 2**53 + 1) is False and (2**53 + 1) in ival.Interval(2**53 + 1)
+    assert not ival.contains(ival.Interval(0, 1), np.array([2**60 + 1])).any()
+
+
+def test_one_at_a_time_matches_arrays():
+    """an Interval of one interval (Python floats) gives the bounds of the array path, through every kind of call"""
+    xs = [rng.uniform(-3, 3) for _ in range(200)]
+    X = ival.Interval(np.array(xs), np.array(xs) + 0.25)
+    one = [ival.Interval(x, x + 0.25) for x in xs]
+    assert all(type(o.lo) is float for o in one)
+    calls = [(lambda A: ival.exp(A)), (lambda A: A * A - 1 / A), (lambda A: ival.pown(A, 3)), (lambda A: A ** -2),
+             (lambda A: ival.atan2(A, A + 1)), (lambda A: ival.sqrrev(A, ival.Interval(0, 4))),
+             (lambda A: ival.fma(A, A, 1)), (lambda A: ival.powrev1(ival.Interval(2, 3), A + 4)),
+             (lambda A: ival.rootn(A, 3)), (lambda A: A & ival.Interval(0, 1))]
+    for f in calls:
+        R = f(X)
+        for k in range(0, 200, 7):
+            r = f(one[k])
+            assert type(r.lo) is float
+            assert np.array_equal([r.lo, r.hi], [R.lo[k], R.hi[k]], equal_nan=True), k
+    assert [o.mid for o in one[:5]] == list(X.mid[:5]) and [o.is_empty() for o in one[:5]] == [False] * 5
+    assert ival.Interval(1, 2).subset(ival.Interval(0, 3)) is True and ival.contains(ival.Interval(1, 2), 1.5) is True
+    assert type(X[3].lo) is float and X[3].equal(one[3])