crdistr 0.4.1__tar.gz

crdistr-0.4.1/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.

crdistr-0.4.1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: crdistr
+Version: 0.4.1
+Summary: erfinv, erfcinv and probit (the inverse normal distribution) over NumPy arrays, correctly rounded in binary32, binary16 and bfloat16, on crnumerics' libcrdist
+License: MIT
+Project-URL: Source, https://github.com/anun333/crnumerics/tree/main/dist
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# crdistr: crdist for Python
+
+The normal distribution over NumPy arrays, from crnumerics' C library `libcrdist`: `erfinv`, `erfcinv`, `probit`
+(the standard normal quantile: R's `qnorm`, SciPy's `ndtri`), `ndtr`, `log_ndtr`, `normpdf` and `logit`, correctly
+rounded to nearest in binary32, binary16 and bfloat16, every input of each checked against MPFR on x86-64 and
+aarch64; and samplers on a Philox4x32-10 stream. The results are the same bits on every machine, in any
+floating-point environment.
+
+```python
+import numpy as np, crdistr
+crdistr.probit(np.float32(0.975))                  # 1.959964, the float32 nearest the exact quantile
+u = np.random.default_rng(1).random(10, dtype=np.float32)
+z = crdistr.probit(u)                              # normal draws: the same everywhere for the same u
+crdistr.erfinv(np.array([0.1, 0.5], np.float16))   # binary16 in, binary16 out, rounded once
+crdistr.log_ndtr(np.float32(-40))                  # log Phi(-40) = -804.6084, where Phi underflows binary64
+s = crdistr.Stream(seed=42)                        # Philox4x32-10, (seed, substream, index)
+g = s.gamma(1000, shape=2.5)                      # the same bits on every machine
+```
+
+Also `ndtr` (Phi), `normpdf` and `logit`, correctly rounded like the inverses; and `Stream`'s `uniform`,
+`normal`, `exponential`, `gamma`, `beta`, `chisquared`, `student_t` and `words`, whose bits are fixed by the
+specification in `crdist.h` (the tests check the binding against its recorded fingerprints).
+
+The format follows the input. float16 arrays use binary16, and ml_dtypes' `bfloat16` arrays use bfloat16; for
+bfloat16 bit patterns given as `uint16`, use `erfinv_bf16`, `erfcinv_bf16` and `probit_bf16`. float32 uses
+binary32. Anything else is converted to float32 first, rounded to nearest, so a float64 0.1 becomes float32's 0.1
+before the function sees it.
+
+The library is `libcrdist.so.0`, from crnumerics' `make install` (or `CRDIST_LIBRARY` naming it). The tests
+(`make crdist-python-check` at crnumerics' root) compare results with mpmath, rounded once to each format.
+Linux only for now. `pip install crdistr`, then `import crdistr`: the name is crdistr on PyPI and as a module,
+"crdist" on PyPI being an unrelated project (the C library is still crdist: `libcrdist`, `crdist.h`).

crdistr-0.4.1/README.md

@@ -0,0 +1,32 @@
+# crdistr: crdist for Python
+
+The normal distribution over NumPy arrays, from crnumerics' C library `libcrdist`: `erfinv`, `erfcinv`, `probit`
+(the standard normal quantile: R's `qnorm`, SciPy's `ndtri`), `ndtr`, `log_ndtr`, `normpdf` and `logit`, correctly
+rounded to nearest in binary32, binary16 and bfloat16, every input of each checked against MPFR on x86-64 and
+aarch64; and samplers on a Philox4x32-10 stream. The results are the same bits on every machine, in any
+floating-point environment.
+
+```python
+import numpy as np, crdistr
+crdistr.probit(np.float32(0.975))                  # 1.959964, the float32 nearest the exact quantile
+u = np.random.default_rng(1).random(10, dtype=np.float32)
+z = crdistr.probit(u)                              # normal draws: the same everywhere for the same u
+crdistr.erfinv(np.array([0.1, 0.5], np.float16))   # binary16 in, binary16 out, rounded once
+crdistr.log_ndtr(np.float32(-40))                  # log Phi(-40) = -804.6084, where Phi underflows binary64
+s = crdistr.Stream(seed=42)                        # Philox4x32-10, (seed, substream, index)
+g = s.gamma(1000, shape=2.5)                      # the same bits on every machine
+```
+
+Also `ndtr` (Phi), `normpdf` and `logit`, correctly rounded like the inverses; and `Stream`'s `uniform`,
+`normal`, `exponential`, `gamma`, `beta`, `chisquared`, `student_t` and `words`, whose bits are fixed by the
+specification in `crdist.h` (the tests check the binding against its recorded fingerprints).
+
+The format follows the input. float16 arrays use binary16, and ml_dtypes' `bfloat16` arrays use bfloat16; for
+bfloat16 bit patterns given as `uint16`, use `erfinv_bf16`, `erfcinv_bf16` and `probit_bf16`. float32 uses
+binary32. Anything else is converted to float32 first, rounded to nearest, so a float64 0.1 becomes float32's 0.1
+before the function sees it.
+
+The library is `libcrdist.so.0`, from crnumerics' `make install` (or `CRDIST_LIBRARY` naming it). The tests
+(`make crdist-python-check` at crnumerics' root) compare results with mpmath, rounded once to each format.
+Linux only for now. `pip install crdistr`, then `import crdistr`: the name is crdistr on PyPI and as a module,
+"crdist" on PyPI being an unrelated project (the C library is still crdist: `libcrdist`, `crdist.h`).

crdistr-0.4.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "crdistr"   # on PyPI and as the module (import crdistr); "crdist" there is an unrelated project
+version = "0.4.1"
+description = "erfinv, erfcinv and probit (the inverse normal distribution) over NumPy arrays, correctly rounded in binary32, binary16 and bfloat16, on crnumerics' libcrdist"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = ["numpy"]
+
+[project.urls]
+Source = "https://github.com/anun333/crnumerics/tree/main/dist"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+crdistr = ["libcrdist.so.0", "LICENSE", "LICENSE-CORE-MATH"]   # present only in a wheel from build-wheel.sh

crdistr-0.4.1/setup.cfg

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

crdistr-0.4.1/setup.py

@@ -0,0 +1,32 @@
+"""Only for a wheel that carries libcrdist.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
+
+here = os.path.join(os.path.dirname(os.path.abspath(__file__)), "src", "crdistr")
+bundled = any(os.path.exists(os.path.join(here, n)) for n in ("libcrdist.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):
+            plat = super().get_tag()[2]
+            if plat.startswith("macosx_"):   # the library's minimum, not the build machine's macOS
+                target = os.environ.get("MACOSX_DEPLOYMENT_TARGET", "11.0").replace(".", "_")
+                plat = "macosx_" + target + "_" + plat.split("_", 3)[3]
+            return "py3", "none", plat
+
+    kw = {"distclass": BinaryDistribution, "cmdclass": {"bdist_wheel": PlatformWheel}}
+
+setup(**kw)

crdistr-0.4.1/src/crdistr/__init__.py

@@ -0,0 +1,207 @@
+"""crdistr, crdist for Python: erfinv, erfcinv and probit (the standard normal quantile) over NumPy arrays, correctly rounded
+to nearest in binary32, binary16 and bfloat16, from crnumerics' C library libcrdist. Every input of every function
+in each format was checked against MPFR; the results are the same bits on every machine, in any floating-point
+environment.
+
+    import numpy as np, crdistr
+    crdistr.probit(np.float32(0.975))                 # 1.959964 (R's qnorm, SciPy's ndtri), the float32 nearest
+    crdistr.erfinv(np.array([0.1, 0.5], np.float32)) # elementwise
+    crdistr.probit(np.float16(0.9))                   # binary16 in, binary16 out, rounded once
+    u = np.random.default_rng(1).random(10, dtype=np.float32)
+    z = crdistr.probit(u)                             # normal draws, the same everywhere for the same u
+    crdistr.log_ndtr(np.float32(-40))                 # log Phi(-40) = -804.6084, where Phi underflows
+    s = crdistr.Stream(seed=42)                       # Philox4x32-10: the same draws on every machine
+    g = s.gamma(1000, shape=2.5)
+
+The format follows the input: float16 arrays use binary16, ml_dtypes' bfloat16 arrays use bfloat16 (or pass bfloat16
+bit patterns as uint16 to erfinv_bf16, erfcinv_bf16 and probit_bf16), float32 uses binary32, and anything else is
+converted to float32 first (rounded to nearest), so a float64 0.1 becomes float32's 0.1 before the function sees it.
+
+The library is libcrdist.so.0: found by the environment variable CRDIST_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 crdist.
+"""
+import ctypes
+import ctypes.util
+import os
+import subprocess
+
+import numpy as np
+
+__all__ = ["erfinv", "erfcinv", "probit", "ndtr", "log_ndtr", "normpdf", "logit", "erfinv_bf16", "erfcinv_bf16",
+           "probit_bf16", "Stream", "version", "library_path"]
+
+
+def _find():
+    env = os.environ.get("CRDIST_LIBRARY")
+    if env:
+        return env
+    here = os.path.join(os.path.dirname(os.path.abspath(__file__)), "libcrdist.so.0")   # a wheel's own copy
+    if os.path.exists(here):
+        return here
+    for name in ("libcrdist.so.0", "libcrdist.so"):
+        try:
+            ctypes.CDLL(name)
+            return name
+        except OSError:
+            pass
+    found = ctypes.util.find_library("crdist")
+    if found:
+        return found
+    try:
+        libdir = subprocess.run(["pkg-config", "--variable=libdir", "crdist"], capture_output=True, text=True,
+                                check=True).stdout.strip()
+        for name in ("libcrdist.so.0", "libcrdist.so"):
+            path = os.path.join(libdir, name)
+            if os.path.exists(path):
+                return path
+    except (OSError, subprocess.CalledProcessError):
+        pass
+    raise OSError("crdistr: libcrdist.so not found; install crnumerics (make install) or set CRDIST_LIBRARY")
+
+
+library_path = _find()
+_lib = ctypes.CDLL(library_path)
+_lib.crdist_version.restype = ctypes.c_char_p
+_lib.crdist_version.argtypes = []
+_SIG = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
+for _f in ("erfinv", "erfcinv", "probit", "ndtr", "log_ndtr", "normpdf", "logit"):
+    for _name in ("crdist_%sf" % _f, "crdist_%s_f16" % _f, "crdist_%s_bf16" % _f):
+        getattr(_lib, _name).restype = None
+        getattr(_lib, _name).argtypes = _SIG
+
+
+def version():
+    """The C library's version (CRDIST_VERSION of the crdist.h it was built from)."""
+    return _lib.crdist_version().decode()
+
+
+def _call(name, x, dtype):
+    a = np.require(x, dtype=dtype, requirements="C")   # keeps a 0-d array 0-d
+    y = np.empty_like(a)
+    getattr(_lib, name)(ctypes.c_void_p(y.ctypes.data), ctypes.c_void_p(a.ctypes.data), a.size)
+    return y if y.ndim else y[()]
+
+
+def _dispatch(f, x):
+    dt = getattr(x, "dtype", None)
+    if dt == np.float16:
+        return _call("crdist_%s_f16" % f, x, np.float16)
+    if dt is not None and dt.name == "bfloat16":   # ml_dtypes' type: two bytes, bfloat16's bits
+        a = np.require(x, requirements="C")
+        return _call("crdist_%s_bf16" % f, a.view(np.uint16), np.uint16).view(dt)
+    return _call("crdist_%sf" % f, x, np.float32)
+
+
+def erfinv(x):
+    """The y with erf(y) = x, correctly rounded (-1 <= x <= 1; erfinv(+-1) = +-inf, NaN outside)."""
+    return _dispatch("erfinv", x)
+
+
+def erfcinv(x):
+    """The y with erfc(y) = x, correctly rounded (0 <= x <= 2; erfcinv(0) = inf, erfcinv(2) = -inf, NaN outside)."""
+    return _dispatch("erfcinv", x)
+
+
+def probit(p):
+    """The y with Phi(y) = p, Phi the standard normal distribution function, correctly rounded (0 <= p <= 1;
+    probit(0) = -inf, probit(1) = inf, NaN outside): R's qnorm, SciPy's ndtri."""
+    return _dispatch("probit", p)
+
+
+def ndtr(x):
+    """Phi(x), the standard normal distribution function, correctly rounded (SciPy's ndtr, R's pnorm); the
+    survival function is ndtr(-x)."""
+    return _dispatch("ndtr", x)
+
+
+def log_ndtr(x):
+    """log Phi(x), correctly rounded, also where Phi underflows (SciPy's log_ndtr)."""
+    return _dispatch("log_ndtr", x)
+
+
+def normpdf(x):
+    """The standard normal density e^(-x^2/2)/sqrt(2 pi), correctly rounded."""
+    return _dispatch("normpdf", x)
+
+
+def logit(p):
+    """log(p/(1 - p)), correctly rounded (0 <= p <= 1; logit(0) = -inf, logit(1) = inf, NaN outside)."""
+    return _dispatch("logit", p)
+
+
+def erfinv_bf16(bits):
+    """erfinv on bfloat16 numbers given as their bit patterns (uint16), returning bit patterns."""
+    return _call("crdist_erfinv_bf16", bits, np.uint16)
+
+
+def erfcinv_bf16(bits):
+    """erfcinv on bfloat16 bit patterns (uint16)."""
+    return _call("crdist_erfcinv_bf16", bits, np.uint16)
+
+
+def probit_bf16(bits):
+    """probit on bfloat16 bit patterns (uint16)."""
+    return _call("crdist_probit_bf16", bits, np.uint16)
+
+
+class _CStream(ctypes.Structure):
+    _fields_ = [("seed", ctypes.c_uint64), ("substream", ctypes.c_uint64), ("index", ctypes.c_uint64)]
+
+
+for _name in ("crdist_uniformf", "crdist_normalf", "crdist_exponentialf"):
+    getattr(_lib, _name).argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.POINTER(_CStream)]
+_lib.crdist_words.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.POINTER(_CStream)]
+for _name in ("crdist_gammaf", "crdist_chisquaredf", "crdist_student_tf"):
+    getattr(_lib, _name).argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_double, ctypes.POINTER(_CStream)]
+_lib.crdist_betaf.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_double, ctypes.c_double, ctypes.POINTER(_CStream)]
+
+
+class Stream:
+    """A Philox4x32-10 stream (seed, substream), read from index on: the same draws on every machine (crdist.h's
+    specification; each sampler's bits are fixed by it). Each call takes the words it needs and moves index past
+    them; streams with different substreams never overlap.
+
+        s = crdistr.Stream(seed=42)
+        z = s.normal(1000)                  # float32
+        g = s.gamma(1000, shape=2.5)
+        crdistr.Stream(42).normal(1000)      # the same z again
+    """
+
+    def __init__(self, seed, substream=0, index=0):
+        self._s = _CStream(seed, substream, index)
+
+    seed = property(lambda self: self._s.seed)
+    substream = property(lambda self: self._s.substream)
+    index = property(lambda self: self._s.index)
+
+    def _run(self, name, n, *args, dtype=np.float32):
+        y = np.empty(int(n), dtype)
+        getattr(_lib, name)(ctypes.c_void_p(y.ctypes.data), y.size, *args, ctypes.byref(self._s))
+        return y
+
+    def words(self, n):
+        """the stream's next n 32-bit words"""
+        return self._run("crdist_words", n, dtype=np.uint32)
+
+    def uniform(self, n):
+        """(2k + 1) 2^-24 for k the word's top 23 bits: 2^23 values in (0, 1), symmetric about 1/2"""
+        return self._run("crdist_uniformf", n)
+
+    def normal(self, n):
+        """standard normal: probit of a binary32 in (0, 1/2], the sign from the word's top bit"""
+        return self._run("crdist_normalf", n)
+
+    def exponential(self, n):
+        return self._run("crdist_exponentialf", n)
+
+    def gamma(self, n, shape):
+        return self._run("crdist_gammaf", n, float(shape))
+
+    def beta(self, n, a, b):
+        return self._run("crdist_betaf", n, float(a), float(b))
+
+    def chisquared(self, n, k):
+        return self._run("crdist_chisquaredf", n, float(k))
+
+    def student_t(self, n, nu):
+        return self._run("crdist_student_tf", n, float(nu))

crdistr-0.4.1/src/crdistr.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: crdistr
+Version: 0.4.1
+Summary: erfinv, erfcinv and probit (the inverse normal distribution) over NumPy arrays, correctly rounded in binary32, binary16 and bfloat16, on crnumerics' libcrdist
+License: MIT
+Project-URL: Source, https://github.com/anun333/crnumerics/tree/main/dist
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# crdistr: crdist for Python
+
+The normal distribution over NumPy arrays, from crnumerics' C library `libcrdist`: `erfinv`, `erfcinv`, `probit`
+(the standard normal quantile: R's `qnorm`, SciPy's `ndtri`), `ndtr`, `log_ndtr`, `normpdf` and `logit`, correctly
+rounded to nearest in binary32, binary16 and bfloat16, every input of each checked against MPFR on x86-64 and
+aarch64; and samplers on a Philox4x32-10 stream. The results are the same bits on every machine, in any
+floating-point environment.
+
+```python
+import numpy as np, crdistr
+crdistr.probit(np.float32(0.975))                  # 1.959964, the float32 nearest the exact quantile
+u = np.random.default_rng(1).random(10, dtype=np.float32)
+z = crdistr.probit(u)                              # normal draws: the same everywhere for the same u
+crdistr.erfinv(np.array([0.1, 0.5], np.float16))   # binary16 in, binary16 out, rounded once
+crdistr.log_ndtr(np.float32(-40))                  # log Phi(-40) = -804.6084, where Phi underflows binary64
+s = crdistr.Stream(seed=42)                        # Philox4x32-10, (seed, substream, index)
+g = s.gamma(1000, shape=2.5)                      # the same bits on every machine
+```
+
+Also `ndtr` (Phi), `normpdf` and `logit`, correctly rounded like the inverses; and `Stream`'s `uniform`,
+`normal`, `exponential`, `gamma`, `beta`, `chisquared`, `student_t` and `words`, whose bits are fixed by the
+specification in `crdist.h` (the tests check the binding against its recorded fingerprints).
+
+The format follows the input. float16 arrays use binary16, and ml_dtypes' `bfloat16` arrays use bfloat16; for
+bfloat16 bit patterns given as `uint16`, use `erfinv_bf16`, `erfcinv_bf16` and `probit_bf16`. float32 uses
+binary32. Anything else is converted to float32 first, rounded to nearest, so a float64 0.1 becomes float32's 0.1
+before the function sees it.
+
+The library is `libcrdist.so.0`, from crnumerics' `make install` (or `CRDIST_LIBRARY` naming it). The tests
+(`make crdist-python-check` at crnumerics' root) compare results with mpmath, rounded once to each format.
+Linux only for now. `pip install crdistr`, then `import crdistr`: the name is crdistr on PyPI and as a module,
+"crdist" on PyPI being an unrelated project (the C library is still crdist: `libcrdist`, `crdist.h`).

crdistr-0.4.1/src/crdistr.egg-info/SOURCES.txt

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

crdistr-0.4.1/src/crdistr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crdistr-0.4.1/src/crdistr.egg-info/requires.txt

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

crdistr-0.4.1/src/crdistr.egg-info/top_level.txt

@@ -0,0 +1 @@
+crdistr

crdistr-0.4.1/tests/test_crdistr.py

@@ -0,0 +1,183 @@
+"""Tests of crdistr, crdist's Python binding: results correctly rounded against mpmath (300 bits, then rounded once to the
+format), the format following the input's dtype, shapes, scalars and non-contiguous arrays, the special values,
+and the floating-point state left as it was. crdist-check proves the C library on every input; these test that
+the binding hands the right inputs to the right functions and the results back. Run with libcrdist on the
+linker's path or CRDIST_LIBRARY naming it: python3 -m pytest dist/python/tests"""
+import random
+
+import mpmath
+import numpy as np
+import pytest
+
+import crdistr
+
+mpmath.mp.prec = 300
+rng = random.Random(20261013)
+
+
+def exact(f, x):
+    x = mpmath.mpf(float(x))
+    if f == "erfinv":
+        return mpmath.erfinv(x)
+    if f == "erfcinv":
+        return mpmath.erfinv(1 - x)
+    return mpmath.sqrt(2) * mpmath.erfinv(2 * x - 1)
+
+
+def rounded(v, bits):
+    """v rounded once to `bits` significant bits, to nearest (normal numbers only)"""
+    with mpmath.workprec(bits):
+        return float(+v)
+
+
+def draw(f, dtype, n, lo_exp):
+    """n numbers of the dtype inside f's domain, away from its ends, with |y| in the format's normal range"""
+    out = []
+    top = 1.0 if f != "erfcinv" else 2.0
+    while len(out) < n:
+        x = dtype(rng.uniform(0, top) if rng.random() < 0.5 else 2.0 ** rng.uniform(lo_exp, -1))
+        if 0 < x < top and x != 1 and not (f == "probit" and x == 0.5) and abs(exact(f, x)) > 2.0 ** -13:
+            out.append(x)
+    return np.array(out, dtype)
+
+
+@pytest.mark.parametrize("f", ["erfinv", "erfcinv", "probit"])
+def test_float32_correctly_rounded(f):
+    x = draw(f, np.float32, 400, -100)
+    y = getattr(crdistr, f)(x)
+    assert y.dtype == np.float32
+    for a, b in zip(x, y):
+        assert float(b) == rounded(exact(f, a), 24), (f, float(a))
+
+
+@pytest.mark.parametrize("f", ["erfinv", "erfcinv", "probit"])
+def test_float16_correctly_rounded(f):
+    x = draw(f, np.float16, 300, -13)
+    y = getattr(crdistr, f)(x)
+    assert y.dtype == np.float16
+    for a, b in zip(x, y):
+        assert float(b) == rounded(exact(f, a), 11), (f, float(a))
+
+
+def test_bfloat16_bits():
+    # 0.5 is 0x3f00; erfinv(0.5) = 0.4769..., bfloat16's nearest 0.4765625 = 0x3ef4
+    assert int(crdistr.erfinv_bf16(np.uint16(0x3f00))) == 0x3ef4
+    bits = np.array([0x3f00, 0x3f40, 0x0001], np.uint16)   # 0.5, 0.75, the smallest subnormal
+    y = crdistr.probit_bf16(bits)
+    assert y.dtype == np.uint16 and y.shape == (3,)
+    f32 = (y.astype(np.uint32) << 16).view(np.float32)
+    assert f32[0] == 0 and 0.67 < f32[1] < 0.68 and f32[2] < -13
+
+
+def test_bfloat16_dtype():
+    ml = pytest.importorskip("ml_dtypes")
+    x = np.array([0.5, 0.25], ml.bfloat16)
+    y = crdistr.erfinv(x)
+    assert y.dtype == ml.bfloat16
+    assert int(y.view(np.uint16)[0]) == 0x3ef4
+
+
+def test_special_values():
+    inf, nan = np.inf, np.nan
+    e = crdistr.erfinv(np.array([-1, 1, 0, -0.0, 2, nan], np.float32))
+    assert e[0] == -inf and e[1] == inf and e[2] == 0 and np.signbit(e[3]) and np.isnan(e[4]) and np.isnan(e[5])
+    c = crdistr.erfcinv(np.array([0, 2, 1, -1, 3], np.float32))
+    assert c[0] == inf and c[1] == -inf and c[2] == 0 and not np.signbit(c[2]) and np.isnan(c[3]) and np.isnan(c[4])
+    p = crdistr.probit(np.array([0, 1, 0.5, -0.5, 1.5], np.float32))
+    assert p[0] == -inf and p[1] == inf and p[2] == 0 and np.isnan(p[3]) and np.isnan(p[4])
+
+
+def test_shapes_scalars_and_conversion():
+    x = np.linspace(0.05, 0.95, 12, dtype=np.float32).reshape(3, 4)
+    y = crdistr.probit(x)
+    assert y.shape == (3, 4) and y.dtype == np.float32
+    assert np.array_equal(crdistr.probit(x.T), y.T)             # non-contiguous: elementwise the same
+    assert np.array_equal(crdistr.probit(x[:, ::2]), y[:, ::2])
+    s = crdistr.probit(np.float32(0.975))
+    assert np.ndim(s) == 0 and float(s) == rounded(exact("probit", np.float32(0.975)), 24)
+    # a float64 or a list becomes float32 first (rounded to nearest), and the result is float32
+    assert crdistr.probit([0.975]).dtype == np.float32
+    assert crdistr.probit(np.float64(0.975)) == s
+    assert crdistr.erfinv(0.5) == crdistr.erfinv(np.float32(0.5))
+
+
+def test_environment_left_alone():
+    # the library sets round-to-nearest for itself and restores the caller's state; NumPy's error state is Python's
+    before = np.geterr()
+    crdistr.erfinv(np.array([0.5, 2.0], np.float32))
+    assert np.geterr() == before
+
+
+def test_version():
+    assert crdistr.version().count(".") == 2
+
+
+def exact_fn(f, x):
+    x = mpmath.mpf(float(x))
+    if f == "ndtr":
+        return mpmath.ncdf(x)
+    if f == "log_ndtr":
+        return mpmath.log(mpmath.ncdf(x))
+    if f == "normpdf":
+        return mpmath.npdf(x)
+    return mpmath.log(x / (1 - x))
+
+
+@pytest.mark.parametrize("f", ["ndtr", "log_ndtr", "normpdf", "logit"])
+def test_functions_of_x_correctly_rounded(f):
+    out = []
+    while len(out) < 300:
+        if f == "logit":
+            x = np.float32(rng.uniform(0, 1) if rng.random() < 0.5 else 2.0 ** rng.uniform(-60, -1))
+            ok = 0 < x < 1 and x != 0.5
+        else:
+            x = np.float32(rng.uniform(-14, 6) if rng.random() < 0.7 else -(10 ** rng.uniform(1, 30)))
+            ok = abs(float(exact_fn(f, x))) > 2.0 ** -120 if f != "log_ndtr" else x < 5
+        if ok:
+            out.append(x)
+    x = np.array(out, np.float32)
+    y = getattr(crdistr, f)(x)
+    assert y.dtype == np.float32
+    for a, b in zip(x, y):
+        v = exact_fn(f, a)
+        if abs(v) > 3e38:
+            assert np.isinf(b), (f, float(a))
+        else:
+            assert float(b) == rounded(v, 24), (f, float(a))
+
+
+def test_log_ndtr_far():
+    assert float(crdistr.log_ndtr(np.float32(-40))) == rounded(mpmath.log(mpmath.ncdf(-40)), 24)
+    assert crdistr.log_ndtr(np.float32(-1e20)) == -np.inf   # -5e39, past binary32
+    assert crdistr.ndtr(np.float32(-40)) == 0
+
+
+def fnv(y):
+    h = 0xcbf29ce484222325
+    for u in np.asarray(y, np.float32).view(np.uint32).tolist():
+        for b in range(4):
+            h ^= (u >> (8 * b)) & 0xff
+            h = (h * 0x100000001b3) % 2 ** 64
+    return h
+
+
+def test_stream_fingerprints():
+    # crdist-check's recorded fingerprints (seed 1, substream 0, index 0, 4096 draws): the binding gives the C bits
+    assert fnv(crdistr.Stream(1).normal(4096)) == 0xe0b080312afb39d4
+    assert fnv(crdistr.Stream(1).gamma(4096, 2.5)) == 0xc6a5cb829535e89e
+    assert fnv(crdistr.Stream(1).beta(4096, 0.01, 0.02)) == 0xa972487992e10f5b
+
+
+def test_stream_index_and_substreams():
+    s = crdistr.Stream(7, substream=3)
+    a = s.words(10)
+    assert s.index == 10 and a.dtype == np.uint32
+    assert np.array_equal(crdistr.Stream(7, 3, 4).words(6), a[4:])          # cut by index
+    assert not np.array_equal(crdistr.Stream(7, 4).words(10), a)            # another substream
+    t = crdistr.Stream(9)
+    t.normal(5)
+    assert t.index == 5                                                    # a normal takes one word
+    g = crdistr.Stream(9).gamma(3, -1.0)
+    assert np.isnan(g).all()
+    # Random123's known answer for Philox4x32-10 at counter 0, key 0
+    assert crdistr.Stream(0).words(4).tolist() == [0x6627e8d5, 0xe169c58d, 0xbc57ac4c, 0x9b00dbd8]