diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 00000000..79e42c79 --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,21 @@ +name: xsref tests + +on: [ push, pull_request ] + +jobs: + xsref_tests: + name: xsref table consistency tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + + - name: Setup Python + uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0 + with: + python-version: '3.12' + + - name: Install xsref and dependencies + run: pip install .[test] + + - name: Run tests + run: pytest diff --git a/README.md b/README.md index ff9c3286..0d69b209 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,82 @@ # xsref -Test case generation for xsf special function library + +## Introduction and Installation + +This package is used to generate test cases for scalar kernels in the xsf +special function library. Reference values are computed using +[`mpmath`](https://mpmath.org/). Reference tables are stored in +[parquet](https://parquet.apache.org/docs/file-format/) files within the +`xref` repo itself at `xsref/tables/`. Since `xsref` relies on these parquet +files being part of the repo itself, it should be installed using an inplace +build + +```bash +pip install -e . +``` + +from inside the top level directory of the `xsf` repo. Or + +```bash +pip install -e .[test] +``` + +if one wants to install the test dependencies. + +## Reference tables + +Subdirectories under `xsref/tables` should correspond to conceptually related +collections of test cases. Subdirectories under these subdirectories should +correspond to special functions, and share a name with the corresponding `xsf` +scalar kernel function name (not the SciPy ufunc name). For example +`xsref/tables/scipy_special_tests` is for parquet files for all test cases +that appeared in the `scipy.special` tests prior to the separation of scalar kernels +into the separate [xsf](https://github.com/scipy/xsf) library. +`xsref/tables/scipy_special_tests/cyl_bessel_i` contains parquet files containing +reference test cases for the [modified Bessel function $I_v$](https://dlmf.nist.gov/10.25#E2) +which corresponds to the SciPy ufunc +[`iv`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.iv.html). + +Within a directory like `xsref/tables/scipy_special_tests/cyl_bessel_i`, for +each type overload, there will be a parquet file for inputs, such as `In_d_d-d.parquet` +[^1]. The substring `d_d-d` says that this is for cases for the +signature `double cyl_bessel_i(double, double)`. There will be a corresponding +parquet file containing reference output values `Out_d_d-d.parquet`. For each +tested platform there will be parquet files like `Err_d_d-d_gcc-linux-x86_x6.parquet` +containing current extended relative error [^2] values for `xsf`'s implementation compared +to the reference implementation. Rather than having some fixed tolerance +standard, we track the current relative error at each snapshot of development history, +and test that it is not made worse by some fixed multiple. The idea is to use just +tests to drive continuous improvement, helping us identify cases where the scalar +kernels could be improved. + +The hope is that the reference implementations be independent of the `xsf` +implementations, relying on arbitrary precision calculations based on simple +definitions. In this case, agreement between the `xsf` implementation and the +reference implementation should make us reasonably confident that the `xsf` +implementation is accurate. However, disagreement could occur either due to +flaws in the `xsf` implementation, or flaws in the reference implementation. +Such situations must be investigated on a case by case basis. + +There are functions and parameter regions where we do not yet have an +arbitrary precision reference implementation. Currently there is a fallback to +the SciPy implementations from just before the scalar kernels were split +into the separate `xsf` library. The `Out` parquet files contain a boolean column, +`"fallback"` which is True for cases where such a fallback was used. + +## Testing + +The test suite uses `pytest` and can be run by invoking the `pytest` command +in a shell from within the top level of the `xsref` repo. Currently the test +suite only checks the consistency of the reference tables. + +-- + +[^1]: For complex valued cases, it would be nice to be able to use NumPy typecodes + such as `In_d_D-D.parquet`, but this will not work on case insensitive file + systems such as the default on MacOS. Instead of `D` we use `cd` for complex + double and instead of `F` we use `cf` for complex float. The filename in + question here would thus be `In_d_cd-cd.parquet`. + +[^2]: Extended relative error is a metric we've devised which given any two floating + point numbers (or complex floating point numbers), including exceptional values like + `NaN`s, infinities, and zeros, will return a non-`NaN` result. diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..f73e4eb1 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,24 @@ +[build-system] +requires = ["setuptools", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "xsref" +version = "0.0.0" +license = {file = "LICENSE"} +maintainers = [ + {name = "xsf developers", email = "albert.steppi@gmail.com"} +] +requires-python = ">=3.11" +dependencies = [ + "mpmath==1.3.0", + "numpy", + "packaging", + "polars", + "pyarrow", + "scipy==1.15.1", +] +readme = "README.md" + +[project.optional-dependencies] +test = ["pytest"] diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..9f39d934 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,180 @@ +[pytest] +markers = + airy: mark a test as pertaining to airy. + airye: mark a test as pertaining to airye. + bdtr: mark a test as pertaining to bdtr. + bdtrc: mark a test as pertaining to bdtrc. + bdtri: mark a test as pertaining to bdtri. + bei: mark a test as pertaining to bei. + beip: mark a test as pertaining to beip. + ber: mark a test as pertaining to ber. + berp: mark a test as pertaining to berp. + besselpoly: mark a test as pertaining to besselpoly. + beta: mark a test as pertaining to beta. + betaln: mark a test as pertaining to betaln. + betainc: mark a test as pertaining to betainc. + betaincc: mark a test as pertaining to betaincc. + betaincinv: mark a test as pertaining to betaincinv. + betainccinv: mark a test as pertaining to betainccinv. + binom: mark a test as pertaining to binom. + cbrt: mark a test as pertaining to cbrt. + cem: mark a test as pertaining to cem. + cem_cva: mark a test as pertaining to cem_cva. + chdtr: mark a test as pertaining to chdtr. + chdtrc: mark a test as pertaining to chdtrc. + chdtri: mark a test as pertaining to chdtri. + cosdg: mark a test as pertaining to cosdg. + cosm1: mark a test as pertaining to cosm1. + cospi: mark a test as pertaining to cospi. + cotdg: mark a test as pertaining to cotdg. + cyl_bessel_i: mark a test as pertaining to cyl_bessel_i. + cyl_bessel_i0: mark a test as pertaining to cyl_bessel_i0. + cyl_bessel_i0e: mark a test as pertaining to cyl_bessel_i0e. + cyl_bessel_i1: mark a test as pertaining to cyl_bessel_i1. + cyl_bessel_i1e: mark a test as pertaining to cyl_bessel_i1e. + cyl_bessel_ie: mark a test as pertaining to cyl_bessel_ie. + cyl_bessel_j: mark a test as pertaining to cyl_bessel_j. + cyl_bessel_j0: mark a test as pertaining to cyl_bessel_j0. + cyl_bessel_j1: mark a test as pertaining to cyl_bessel_j1. + cyl_bessel_je: mark a test as pertaining to cyl_bessel_je. + cyl_bessel_k: mark a test as pertaining to cyl_bessel_k. + cyl_bessel_k0: mark a test as pertaining to cyl_bessel_k0. + cyl_bessel_k0e: mark a test as pertaining to cyl_bessel_k0e. + cyl_bessel_k1: mark a test as pertaining to cyl_bessel_k1. + cyl_bessel_k1e: mark a test as pertaining to cyl_bessel_k1e. + cyl_bessel_ke: mark a test as pertaining to cyl_bessel_ke. + cyl_bessel_y: mark a test as pertaining to cyl_bessel_y. + cyl_bessel_y0: mark a test as pertaining to cyl_bessel_y0. + cyl_bessel_y1: mark a test as pertaining to cyl_bessel_y1. + cyl_bessel_ye: mark a test as pertaining to cyl_bessel_ye. + cyl_hankel_1: mark a test as pertaining to cyl_hankel_1. + cyl_hankel_1e: mark a test as pertaining to cyl_hankel_1e. + cyl_hankel_2: mark a test as pertaining to cyl_hankel_2. + cyl_hankel_2e: mark a test as pertaining to cyl_hankel_2e. + dawsn: mark a test as pertaining to dawsn. + digamma: mark a test as pertaining to digamma. + ellipe: mark a test as pertaining to ellipe. + ellipeinc: mark a test as pertaining to ellipeinc. + ellipj: mark a test as pertaining to ellipj. + ellipk: mark a test as pertaining to ellipk. + ellipkinc: mark a test as pertaining to ellipkinc. + ellipkm1: mark a test as pertaining to ellipkm1. + erf: mark a test as pertaining to erf. + erfi: mark a test as pertaining to erfi. + erfc: mark a test as pertaining to erfc. + erfcx: mark a test as pertaining to erfcx. + erfcinv: mark a test as pertaining to erfcinv. + exp1: mark a test as pertaining to exp1. + exp10: mark a test as pertaining to exp10. + exp2: mark a test as pertaining to exp2. + expi: mark a test as pertaining to expi. + expit: mark a test as pertaining to expit. + expm1: mark a test as pertaining to expm1. + expn: mark a test as pertaining to expn. + exprel: mark a test as pertaining to exprel. + fdtr: mark a test as pertaining to fdtr. + fdtrc: mark a test as pertaining to fdtrc. + fdtri: mark a test as pertaining to fdtri. + fresnel: mark a test as pertaining to fresnel. + gamma: mark a test as pertaining to gamma. + gammaincc: mark a test as pertaining to gammaincc. + gammainc: mark a test as pertaining to gammainc. + gammainccinv: mark a test as pertaining to gammainccinv. + gammaincinv: mark a test as pertaining to gammaincinv. + gammaln: mark a test as pertaining to gammaln. + gammasgn: mark a test as pertaining to gammasgn. + gdtr: mark a test as pertaining to gdtr. + gdtrc: mark a test as pertaining to gdtrc. + gdtrib: mark a test as pertaining to gdtrib. + hyp1f1: mark a test as pertaining to hyp1f1. + hyp2f1: mark a test as pertaining to hyp2f1. + hyperu: mark a test as pertaining to hyperu. + it1i0k0: mark a test as pertaining to it1i0k0. + it1j0y0: mark a test as pertaining to it1j0y0. + it2i0k0: mark a test as pertaining to it2i0k0. + it2j0y0: mark a test as pertaining to it2j0y0. + it2struve0: mark a test as pertaining to it2struve0. + itairy: mark a test as pertaining to itairy. + itmodstruve0: mark a test as pertaining to itmodstruve0. + itstruve0: mark a test as pertaining to itstruve0. + iv_ratio: mark a test as pertaining to iv_ratio. + iv_ratio_c: mark a test as pertaining to iv_ratio_c. + kei: mark a test as pertaining to kei. + keip: mark a test as pertaining to keip. + kelvin: mark a test as pertaining to kelvin. + ker: mark a test as pertaining to ker. + kerp: mark a test as pertaining to kerp. + kolmogc: mark a test as pertaining to kolmogc. + kolmogci: mark a test as pertaining to kolmogci. + kolmogi: mark a test as pertaining to kolmogi. + kolmogorov: mark a test as pertaining to kolmogorov. + kolmogp: mark a test as pertaining to kolmogp. + lambertw: mark a test as pertaining to lambertw. + lanczos_sum_expg_scaled: mark a test as pertaining to lanczos_sum_expg_scaled. + lgam1p: mark a test as pertaining to lgam1p. + log1p: mark a test as pertaining to log1p. + log1pmx: mark a test as pertaining to log1pmx. + loggamma: mark a test as pertaining to loggamma. + log_expit: mark a test as pertaining to log_expit. + log_wright_bessel: mark a test as pertaining to log_wright_bessel. + logit: mark a test as pertaining to logit. + mcm1: mark a test as pertaining to mcm1. + mcm2: mark a test as pertaining to mcm2. + modified_fresnel_minus: mark a test as pertaining to modified_fresnel_minus. + modified_fresnel_plus: mark a test as pertaining to modified_fresnel_plus. + msm1: mark a test as pertaining to msm1. + msm2: mark a test as pertaining to msm2. + nbdtr: mark a test as pertaining to nbdtr. + nbdtrc: mark a test as pertaining to nbdtrc. + ndtr: mark a test as pertaining to ndtr. + ndtri: mark a test as pertaining to ndtri. + oblate_aswfa: mark a test as pertaining to oblate_aswfa. + oblate_aswfa_nocv: mark a test as pertaining to oblate_aswfa_nocv. + oblate_radial1: mark a test as pertaining to oblate_radial1. + oblate_radial1_nocv: mark a test as pertaining to oblate_radial1_nocv. + oblate_radial2: mark a test as pertaining to oblate_radial2. + oblate_radial2_nocv: mark a test as pertaining to oblate_radial2_nocv. + oblate_segv: mark a test as pertaining to oblate_segv. + owens_t: mark a test as pertaining to owens_t. + pbdv: mark a test as pertaining to pbdv. + pbvv: mark a test as pertaining to pbvv. + pbwa: mark a test as pertaining to pbwa. + pdtr: mark a test as pertaining to pdtr. + pdtrc: mark a test as pertaining to pdtrc. + pdtri: mark a test as pertaining to pdtri. + pmv: mark a test as pertaining to pmv. + poch: mark a test as pertaining to poch. + prolate_aswfa: mark a test as pertaining to prolate_aswfa. + prolate_aswfa_nocv: mark a test as pertaining to prolate_aswfa_nocv. + prolate_radial1: mark a test as pertaining to prolate_radial1. + prolate_radial1_nocv: mark a test as pertaining to prolate_radial1_nocv. + prolate_radial2: mark a test as pertaining to prolate_radial2. + prolate_radial2_nocv: mark a test as pertaining to prolate_radial2_nocv. + prolate_segv: mark a test as pertaining to prolate_segv. + radian: mark a test as pertaining to radian. + rgamma: mark a test as pertaining to rgamma. + riemann_zeta: mark a test as pertaining to riemann_zeta. + round: mark a test as pertaining to round. + scaled_exp1: mark a test as pertaining to scaled_exp1. + sem: mark a test as pertaining to sem. + sem_cva: mark a test as pertaining to sem_cva. + shichi: mark a test as pertaining to shichi. + sici: mark a test as pertaining to sici. + sindg: mark a test as pertaining to sindg. + sinpi: mark a test as pertaining to sinpi. + smirnov: mark a test as pertaining to smirnov. + smirnovc: mark a test as pertaining to smirnovc. + smirnovci: mark a test as pertaining to smirnovci. + smirnovi: mark a test as pertaining to smirnovi. + smirnovp: mark a test as pertaining to smirnovp. + spence: mark a test as pertaining to spence. + struve_h: mark a test as pertaining to struve_h. + struve_l: mark a test as pertaining to struve_l. + tandg: mark a test as pertaining to tandg. + voigt_profile: mark a test as pertaining to voigt_profile. + wofz: mark a test as pertaining to wofz. + wright_bessel: mark a test as pertaining to wright_bessel. + xlogy: mark a test as pertaining to xlogy. + xlog1py: mark a test as pertaining to xlog1py. + zeta: mark a test as pertaining to zeta. + zetac: mark a test as pertaining to zetac. diff --git a/src/xsref/__init__.py b/src/xsref/__init__.py new file mode 100644 index 00000000..b873953f --- /dev/null +++ b/src/xsref/__init__.py @@ -0,0 +1,4 @@ +import xsref._reference._functions +from xsref._reference._functions import * # noqa + +__all__ = xsref._reference._functions.__all__ diff --git a/src/xsref/_reference/__init__.py b/src/xsref/_reference/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/xsref/_reference/_framework.py b/src/xsref/_reference/_framework.py new file mode 100644 index 00000000..a87f254e --- /dev/null +++ b/src/xsref/_reference/_framework.py @@ -0,0 +1,232 @@ +import functools +import inspect +import math +import numpy as np +import scipy +import signal +import threading +import typing +import warnings + +from mpmath import mp +from packaging import version +from typing import get_origin +from typing import overload + + +__all__ = ["reference_implementation", "XSRefFallbackWarning"] + + +if version.parse(scipy.__version__) >= version.parse("1.16"): + raise RuntimeError( + f"SciPy {scipy.__version__} is not an independent reference. SciPy" + " depends on xsf as of version 1.16." + ) + + +def get_signature_from_type_hints(type_hints): + input_types = [] + for key, val in type_hints.items(): + if key != "return": + if np.issubdtype(val, np.number): + input_types.append(val) + continue + else: + raise ValueError + if isinstance(val, typing._GenericAlias) or typing.get_origin(val) is tuple: + output_types = typing.get_args(val) + else: + output_types = (val, ) + + return (tuple(input_types), output_types) + + +def get_signatures_for_function(func): + type_hints = typing.get_type_hints(func) + if type_hints: + input_types, output_types = get_signature_from_type_hints( + typing.get_type_hints(func) + ) + return {input_types: output_types} + signatures = {} + for overload in typing.get_overloads(func): + input_types, output_types = get_signature_from_type_hints( + typing.get_type_hints(overload) + ) + signatures[input_types] = output_types + return signatures + + +def get_general_input_signature_from_args(args): + signature = [] + for arg in args: + arg_type = type(arg) + if np.issubdtype(arg_type, np.integer): + signature.append(np.integer) + elif np.issubdtype(arg_type, np.floating): + signature.append(np.floating) + elif np.issubdtype(arg_type, np.complexfloating): + signature.append(np.complexfloating) + return tuple(signature) + + +def get_output_types(args, general_output_types): + smallest_type_map = { + np.integer: np.int8, + np.floating: np.float16, + np.complexfloating: np.complex64, + } + largest_real_type = np.result_type(*(arg.real for arg in args)) + if largest_real_type.itemsize > 16: + raise ValueError( + "xsf reference implementation received unsupported dtype: " + " long double types are not supported." + ) + return tuple( + np.result_type(smallest_type_map[dtype], largest_real_type).type + for dtype in general_output_types + ) + + +def process_args(func, *args): + """Convert finite precision arguments to arbitrary precison.""" + expected_signatures = get_signatures_for_function(func) + input_signature = get_general_input_signature_from_args(args) + if input_signature not in expected_signatures: + raise ValueError + general_output_types = expected_signatures[input_signature] + output_types = get_output_types(args, general_output_types) + new_args = [] + for x, type_ in zip(args, input_signature): + if type_ is np.floating: + if x == 0: + # mpmath doesn't have signed zeros, so if zero, keep this + # a float to maintain the sign. + new_args.append(float(x)) + continue + new_args.append(mp.mpf(float(x))) + elif type_ is np.integer: + new_args.append(mp.mpf(float(x))) + elif type_ is np.complexfloating: + # Again mpmath doesn't have signed zeros, so if the real or + # imaginary part are zero, we just pass through a complex + # float. This should be kept in mind for the cases where + # this might matter. + if (x.real == 0 or x.imag) == 0: + new_args.append(complex(x)) + else: + new_args.append(mp.mpc(complex(x))) + return tuple(new_args), output_types + + +def process_output(args, output_types): + """Convert arbitrary precision arguments to finite precision.""" + output = [] + for arg, output_type in zip(args, output_types): + if isinstance(arg, mp.mpc): + if np.issubdtype(output_type, np.complexfloating): + output.append(output_type(arg)) + else: + if abs(arg.imag) == 0: + output.append(output_type(arg.real)) + else: + # Expected a real result, but got complex. Convention is to return + # nan in this case. + output.append(output_type("nan")) + else: + if np.issubdtype(output_type, np.floating): + output.append(output_type(arg)) + else: + # We expect a complex result but got a real output value. If + # it's a nan, make sure imaginary part is nan too. + if mp.isnan(arg): + output.append(output_type(math.nan, math.nan)) + else: + output.append(output_type(arg)) + output = tuple(output) + return output[0] if len(output) == 1 else output + + +class XSRefFallbackWarning(UserWarning): + pass + + +class reference_implementation: + def __init__(self, *, dps=100, scipy=None, default_timeout=3, nan_invalid=True): + self.dps = dps + self.default_timeout = default_timeout + self.nan_invalid = nan_invalid + self.scipy_func = scipy + + def _get_timeout_handler(self, funcname, seconds): + def timeout_handler(signum, frame): + raise TimeoutError( + f"Reference implementation {funcname} timed out after" + f" {seconds} seconds." + ) + return timeout_handler + + def __call__(self, func): + overloads = typing.get_overloads(func) + annotations_code = "import numpy\n" + for overload_def in overloads: + type_hints = overload_def.__annotations__ + return_type = type_hints['return'] + return_type = ( + f"numpy.{return_type.__name__}" + if return_type in [np.integer, np.floating, np.complexfloating] + else return_type + ) + input_types = ( + (key, f"numpy.{val.__name__}") for key, val in type_hints.items() + if key != 'return' + ) + annotations_code += ( + "@overload\n" + "def wrapper(" + f"{','.join((f'{arg}: {type_}' for arg, type_ in input_types))})" + f" -> {return_type}: ...\n" + ) + exec(annotations_code) + + @functools.wraps(func) + def wrapper(*args, timeout=self.default_timeout): + if timeout is not None: + signal.signal( + signal.SIGALRM, self._get_timeout_handler(func.__name__, timeout) + ) + signal.alarm(timeout) + try: + with mp.workdps(self.dps): + mp_args, output_types = process_args(func, *args) + if self.nan_invalid and any([mp.isnan(x) for x in + mp_args]): + result = tuple(mp.nan for _ in range(len(output_types))) + else: + result = func(*mp_args) + if not isinstance(result, tuple): + result = (result, ) + result = process_output(result, output_types) + except Exception as e: + if self.scipy_func is not None: + result = self.scipy_func(*args) + message = ( + f"Reference implementation {func.__name__} falling" + f" back to SciPy\nwith args: {args},\ndue to exception: " + f"{type(e).__name__}" + ) + message += f", {e}" if str(e) else "" + warnings.warn(message, XSRefFallbackWarning) + else: + raise e + finally: + signal.alarm(0) + + return result + + wrapper.__annotations__ = typing.get_type_hints(func) + setattr(wrapper, "_scipy_func", self.scipy_func) + setattr(wrapper, "_mp", func) + setattr(wrapper, "_arg_names", inspect.getfullargspec(func).args) + setattr(wrapper, "__xsref", None) + return wrapper diff --git a/src/xsref/_reference/_functions.py b/src/xsref/_reference/_functions.py new file mode 100644 index 00000000..baeb2732 --- /dev/null +++ b/src/xsref/_reference/_functions.py @@ -0,0 +1,2224 @@ +import math +import numpy as np +import scipy.special._ufuncs as ufuncs +import sys +import warnings + +from mpmath import mp # type: ignore +from mpmath.calculus.optimization import Bisection, Secant +from packaging import version +from typing import overload, Tuple + +from numpy import integer as Integer +from numpy import floating as Real +from numpy import complexfloating as Complex + +from ._framework import reference_implementation, XSRefFallbackWarning + + +def is_complex(x): + """Check if x is a relevant complex type + + Note: The only types which can appear as inputs to a reference + implementation after passing through the argument processing added by the + decorator are `float`, `mp.mpf`, `complex`, and `mp.mpc` (non mp types can + appear in order to preserve the sign of zero). + """ + return isinstance(x, (mp.mpc, complex)) + + +def to_fp(x): + """Cast mp to finite precision, otherwise idempotent.""" + if isinstance(x, mp.mpf): + return float(x) + if isinstance(x, mp.mpc): + return complex(x) + return x + + +def to_mp(x): + """Cast finite precision to mp, otherwise idempotent.""" + if np.issubdtype(x, Real): + return mp.mpf(x) + if np.issubdtype(x, Integer): + return int(x) + if np.issubdtype(x, Complex): + return mp.mpc(x) + return x + + +def get_resolution_precision(*, x=None, log2abs_x=None): + """Identify the level of precision needed to resolve 1 + x. + + This is the precision level needed so that + ``float((1 + x) - 1)`` will recover `x` with no loss of precision + due to catastrophic cancellation. + """ + if x is not None and log2abs_x is not None: + raise ValueError + if x is not None: + if x == 0 or not mp.isfinite(x): + return mp.prec + log2abs_x = mp.log(abs(x), b=2) + # 1075 is the precision needed to resolve the smallest subnormal. + return min( + max(int(mp.ceil(-log2abs_x)) + 53, mp.prec), 1075 + ) + + +@overload +def airy(x: Real) -> Tuple[Real, Real, Real, Real]: ... +@overload +def airy(x: Complex) -> Tuple[Complex, Complex, Complex, Complex]: ... + + +@reference_implementation(scipy=ufuncs.airy) +def airy(z): + """Airy functions and their derivatives. + + Notes + ----- + Airy functions are entire + """ + ai = mp.airyai(z) + aip = mp.airyai(z, derivative=1) + bi = mp.airybi(z) + bip = mp.airybi(z, derivative=1) + return ai, aip, bi, bip + + +@overload +def airye(x: Real) -> Tuple[Real, Real, Real, Real]: ... +@overload +def airye(x: Complex) -> Tuple[Complex, Complex, Complex, Complex]: ... + + +@reference_implementation(scipy=ufuncs.airye) +def airye(z): + """Exponentially scaled Airy functions and their derivatives. + + Notes + ----- + Scaled Airy functions are entire + """ + eai = mp.airyai(z) * mp.exp(mp.mpf("2.0") / mp.mpf("3.0") * z * mp.sqrt(z)) + eaip = mp.airyai(z, derivative=1) * mp.exp( + mp.mpf("2.0") / mp.mpf("3.0") * z * mp.sqrt(z) + ) + ebi = mp.airybi(z) * mp.exp( + -abs(mp.mpf("2.0") / mp.mpf("3.0") * (z * mp.sqrt(z)).real) + ) + ebip = mp.airybi(z, derivative=1) * mp.exp( + -abs(mp.mpf("2.0") / mp.mpf("3.0") * (z * mp.sqrt(z)).real) + ) + return eai, eaip, ebi, ebip + + +@overload +def bdtr(k: Real, n: Integer, p: Real) -> Real: ... +@overload +def bdtr(k: Real, n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.bdtr) +def bdtr(k, n, p): + """Binomial distribution cumulative distribution function.""" + k, n = mp.floor(k), mp.floor(n) + if p > 1 or p < 0 or k < 0 or n < 0 or k > n or mp.isinf(n): + return mp.nan + if k == n: + return mp.one + # set the precision high enough that mp.one - p != 1 + with mp.workprec(get_resolution_precision(x=p)): + result = betainc._mp(n - k, k + 1, 1 - p) + return result + + +@overload +def bdtrc(k: Real, n: Integer, p: Real) -> Real: ... +@overload +def bdtrc(k: Real, n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.bdtrc) +def bdtrc(k, n, p): + """Binomial distribution survival function.""" + if p > 1 or p < 0 or k < 0 or n < 0 or k > n or mp.isinf(n): + return mp.nan + k, n = mp.floor(k), mp.floor(n) + if k == n: + return mp.zero + return betainc._mp(k + 1, n - k, p) + + +@overload +def bdtri(k: Real, n: Integer, y: Real) -> Real: ... +@overload +def bdtri(k: Real, n: Real, y: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.bdtri) +def bdtri(k, n, y): + if y > 1 or y < 0 or k < 0 or n < 0 or k > n or mp.isinf(n): + return mp.nan + """Inverse function to `bdtr` with respect to `p`.""" + k, n = mp.floor(k), mp.floor(n) + + def f(p): + return bdtr._mp(k, n, p) - y + + return solve_bisect(f, 0, 1) + + +@reference_implementation(scipy=ufuncs.bei) +def bei(x: Real) -> Real: + """Kelvin function bei.""" + return mp.bei(0, x) + + +@reference_implementation(scipy=ufuncs.beip) +def beip(x: Real) -> Real: + """Derivative of the Kelvin function bei.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.ber) +def ber(x: Real) -> Real: + """Kelvin function ber.""" + return mp.ber(0, x) + + +@reference_implementation(scipy=ufuncs.berp) +def berp(x: Real) -> Real: + """Derivative of the Kelvin function ber.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.besselpoly) +def besselpoly(a: Real, lmb: Real, nu: Real) -> Real: + """Weighted integral of the Bessel function of the first kind.""" + def integrand(x): + return x**lmb * cyl_bessel_j._mp(nu, 2 * a * x) + + return mp.quad(integrand, [0, 1]) + + +@reference_implementation(scipy=ufuncs.beta) +def beta(a: Real, b: Real) -> Real: + """Beta function.""" + return mp.beta(a, b) + + +@reference_implementation(scipy=ufuncs.betaln) +def betaln(a: Real, b: Real) -> Real: + """Natural logarithm of the absolute value of the Beta function.""" + return mp.log(abs(mp.beta(a, b))) + + +@reference_implementation(scipy=ufuncs.betainc) +def betainc(a: Real, b: Real, x: Real) -> Real: + """Regularized incomplete Beta function.""" + return mp.betainc(a, b, 0, x, regularized=True) + + +@reference_implementation(scipy=ufuncs.betaincc) +def betaincc(a: Real, b: Real, x: Real) -> Real: + """Complement of the regularized incomplete Beta function.""" + return mp.betainc(a, b, x, 1.0, regularized=True) + + +@reference_implementation(scipy=ufuncs.betaincinv, default_timeout=10) +def betaincinv(a: Real, b: Real, y: Real) -> Real: + """Inverse of the regularized incomplete beta function.""" + def f(x): + return mp.betainc(a, b, 0, x, regularized=True) - y + + return solve_bisect(f, 0, 1) + + +@reference_implementation(scipy=ufuncs.betainccinv, default_timeout=10) +def betainccinv(a: Real, b: Real, y: Real) -> Real: + """Inverse of the complemented regularized incomplete beta function.""" + def f(x): + return mp.betainc(a, b, x, 1.0, regularized=True) - y + + return solve_bisect(f, 0, 1) + + +@reference_implementation(scipy=ufuncs.binom) +def binom(n: Real, k: Real) -> Real: + """Binomial coefficient considered as a function of two real variables.""" + return mp.binomial(n, k) + + +@reference_implementation(scipy=ufuncs.cbrt) +def cbrt(x: Real) -> Real: + """Cube root of x.""" + return mp.cbrt(x) + + +@reference_implementation(scipy=ufuncs.mathieu_cem) +def cem(m: Real, q: Real, x: Real) -> Tuple[Real, Real]: + """Even Mathieu function and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.mathieu_a) +def cem_cva(m: Real, q: Real) -> Real: + """Characteristic value of even Mathieu functions.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.chdtr) +def chdtr(v: Real, x: Real) -> Real: + """Chi square cumulative distribution function.""" + if x < 0 or v < 0: + return mp.nan + return gammainc._mp(v / 2, x / 2) + +@reference_implementation(scipy=ufuncs.chdtrc) +def chdtrc(v: Real, x: Real) -> Real: + """Chi square survival function.""" + if x < 0 or v < 0: + return mp.nan + return gammaincc._mp(v / 2, x / 2) + + +@reference_implementation(scipy=ufuncs.chdtri) +def chdtri(v: Real, p: Real) -> Real: + """Inverse to `chdtrc` with respect to `x`.""" + # TODO. Figure out why chdtri inverts chdtrc and not chdtr + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.cosdg) +def cosdg(x: Real) -> Real: + """Cosine of the angle x given in degrees.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.cosm1) +def cosm1(x: Real) -> Real: + """cos(x) - 1 for use when x is near zero.""" + # set the precision high enough to avoid catastrophic cancellation + # cos(x) - 1 = x^2/2 + O(x^4) for x near 0 + if not mp.isfinite(x): + return mp.nan + with mp.workprec(get_resolution_precision(log2abs_x=2*mp.log(abs(x/2), b=2))): + result = mp.cos(x) - mp.one + return result + + +@overload +def cospi(x: Real) -> Real: ... +@overload +def cospi(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs._cospi) +def cospi(x): + """Cosine of pi*x.""" + # This already does the right thing regarding sign of zero for the case + # x - 0.5 an integer. + return mp.cospi(x) + + +@reference_implementation(scipy=ufuncs.cotdg) +def cotdg(x: Real) -> Real: + """Cotangent of the angle x given in degrees.""" + raise NotImplementedError + + +@overload +def cyl_bessel_i(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_i(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.iv) +def cyl_bessel_i(v, z): + """Modified Bessel function of the first kind. + + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)`` + except for integer `v`. + """ + if v == mp.floor(v) and v < 0: + # Use symmetry iv(n, z) == iv(-n, z) for integers n. + # https://dlmf.nist.gov/10.27#E1 + # mpmath has an easier time with positive v. + v = -v + if z.imag == 0 and z.real < 0: + if v != mp.floor(v): + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + + if min(abs(v), abs(z)) > 1e3: + # mpmath can hang indefinitely for some large values of v and z. + raise NotImplementedError + + result = mp.besseli(v, z) + + if z.imag == 0 and z.real < 0 and v == mp.floor(v): + # No discontinuity for integer v and should return a real value. + # Numerical error can cause a small imaginary part here, so just return + # the real part. + result = result.real + return result + + +@reference_implementation(scipy=ufuncs.i0) +def cyl_bessel_i0(z: Real) -> Real: + """Modified Bessel function of order 0.""" + return cyl_bessel_i._mp(0, z) + + +@reference_implementation(scipy=ufuncs.i0e) +def cyl_bessel_i0e(z: Real) -> Real: + """Exponentially scaled modified Bessel function of order 0.""" + return mp.exp(-abs(z.real)) * cyl_bessel_i0._mp(z) + + +@reference_implementation(scipy=ufuncs.i1) +def cyl_bessel_i1(z: Real)-> Real: + """Modified Bessel function of order 1.""" + return cyl_bessel_i._mp(1, z) + + +@reference_implementation(scipy=ufuncs.i1e) +def cyl_bessel_i1e(z: Real) -> Real: + """Exponentially scaled modified Bessel function of order 1.""" + return mp.exp(-abs(z.real)) * cyl_bessel_i1._mp(z) + + +@overload +def cyl_bessel_ie(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_ie(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.ive) +def cyl_bessel_ie(v, z): + """Exponentially scaled modified Bessel function of the first kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)`` + except for integer `v`. + """ + return mp.exp(-abs(z.real)) * cyl_bessel_i._mp(v, z) + + +@overload +def cyl_bessel_j(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_j(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.jv) +def cyl_bessel_j(v, z): + """Bessel function of the first kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)`` + except for integer `v`. + """ + if v < 0 and v == mp.floor(v): + v = -v + prefactor = (-1)**v + else: + prefactor = 1.0 + + if z.imag == 0 and z.real < 0 and v != mp.floor(v): + if v != mp.floor(v): + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + + if min(abs(v), abs(z)) > 1e3: + # mpmath can hang indefinitely for some large values of v and z. + raise NotImplementedError + + result = prefactor * mp.besselj(v, z) + + if z.imag == 0 and z.real < 0 and v == mp.floor(v): + # No discontinuity for integer v and should return a real value. + # Numerical error can cause a small imaginary part here, so just return + # the real part. + result = result.real + return result + + +@reference_implementation(scipy=ufuncs.j0) +def cyl_bessel_j0(x: Real) -> Real: + """Bessel function of the first kind of order 0.""" + return mp.j0(x) + + +@reference_implementation(scipy=ufuncs.j1) +def cyl_bessel_j1(x: Real) -> Real: + """Bessel function of the first kind of order 1.""" + return mp.j1(x) + + +@overload +def cyl_bessel_je(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_je(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.jve) +def cyl_bessel_je(v, z): + """Exponentially scaled Bessel function of the first kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)`` + except for integer `v`. + """ + return mp.exp(-abs(z.imag)) * cyl_bessel_j._mp(v, z) + + +@overload +def cyl_bessel_k(v: Integer, z: Real) -> Real: ... +@overload +def cyl_bessel_k(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_k(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.kv) +def cyl_bessel_k(v, z): + """Modified Bessel function of the second kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)`` + except for integer `v`. + """ + if v < 0: + v = -v + if z.imag == 0 and z.real < 0: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.besselk(v, z) + + +@reference_implementation(scipy=ufuncs.k0) +def cyl_bessel_k0(x: Real) -> Real: + """Modified Bessel function of the second kinf of order 0.""" + return cyl_bessel_k._mp(0, x) + + +@reference_implementation(scipy=ufuncs.k0e) +def cyl_bessel_k0e(x: Real) -> Real: + """Exponentially scaled modified Bessel function K of order 0.""" + return mp.exp(x) * cyl_bessel_k0._mp(x) + + +@reference_implementation(scipy=ufuncs.k1) +def cyl_bessel_k1(x: Real) -> Real: + """Modified Bessel function of the second kind of order 0.""" + return cyl_bessel_k._mp(1, x) + + +@reference_implementation(scipy=ufuncs.k1e) +def cyl_bessel_k1e(x: Real) -> Real: + """Exponentially scaled modified Bessel function K of order 1.""" + return mp.exp(x) * cyl_bessel_k1._mp(x) + + +@overload +def cyl_bessel_ke(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_ke(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.kve) +def cyl_bessel_ke(v, z): + """Exponentially scaled modified Bessel function of the second kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + return mp.exp(z) * cyl_bessel_k._mp(v, z) + + +@overload +def cyl_bessel_y(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_y(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.yv, default_timeout=10) +def cyl_bessel_y(v, z): + """Bessel function of the second kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + if v < 0 and v == mp.floor(v): + # https://dlmf.nist.gov/10.4#E1 + v = -v + prefactor = (-1)**v + else: + prefactor = 1.0 + + if z.imag == 0 and z.real < 0: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + + if min(abs(v), abs(z)) > 1e3: + # mpmath can hang indefinitely for some large values of v and z. + raise NotImplementedError + + return prefactor * mp.bessely(v, z) + + +@reference_implementation(scipy=ufuncs.y0) +def cyl_bessel_y0(z: Real) -> Real: + """Bessel function of the second kind of order 0.""" + return cyl_bessel_y._mp(0, z) + + +@reference_implementation(scipy=ufuncs.y1) +def cyl_bessel_y1(z: Real) -> Real: + """Bessel function of the second kind of order 1.""" + return cyl_bessel_y._mp(1, z) + + +@overload +def cyl_bessel_ye(v: Real, z: Real) -> Real: ... +@overload +def cyl_bessel_ye(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.yve) +def cyl_bessel_ye(v, z): + """Exponentially scaled Bessel function of the second kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + return cyl_bessel_y._mp(v, z) * mp.exp(-abs(z.imag)) + + +@overload +def cyl_hankel_1(v: Real, z: Real) -> Real: ... +@overload +def cyl_hankel_1(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.hankel1) +def cyl_hankel_1(v, z): + """Hankel function of the first kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + if z.imag == 0 and z.real < 0: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.hankel1(v, z) + + +@overload +def cyl_hankel_1e(v: Real, z: Real) -> Real: ... +@overload +def cyl_hankel_1e(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.hankel1e) +def cyl_hankel_1e(v, z): + """Exponentially scaled Hankel function of the first kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + return cyl_hankel_1._mp(v, z) * mp.exp(z * -1j) + + +@overload +def cyl_hankel_2(v: Real, z: Real) -> Real: ... +@overload +def cyl_hankel_2(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.hankel2) +def cyl_hankel_2(v, z): + """Hankel function of the second kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + if z.imag == 0 and z.real < 0: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.hankel2(v, z) + + +@overload +def cyl_hankel_2e(v: Real, z: Real) -> Real: ... +@overload +def cyl_hankel_2e(v: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.hankel2e) +def cyl_hankel_2e(v, z): + """Exponentially scaled Hankel function of the second kind. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + return cyl_hankel_2._mp(v, z) * mp.exp(z * 1j) + + +@overload +def dawsn(x: Real) -> Real: ... +@overload +def dawsn(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.dawsn) +def dawsn(x): + """Dawson's integral + + dawsn is an entire function + """ + def integrand(t): + return mp.exp(t**2) + + return mp.exp(-x**2) * mp.quad(integrand, [0, x]) + + +@overload +def digamma(x: Real) -> Real: ... +@overload +def digamma(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.psi) +def digamma(x): + """The digamma function. + + Notes + ----- + Poles at nonpositive integers. + """ + if x == 0.0: + if isinstance(x, float): + return -math.copysign(mp.inf, x) + return mp.nan + if x.real < 0 and x.imag == 0 and x.real == mp.floor(x.real): + return mp.nan + return mp.digamma(x) + + +@reference_implementation(scipy=ufuncs.ellipe) +def ellipe(m: Real) -> Real: + """Complete elliptic integral of the second kind.""" + return mp.ellipe(m) + + +@reference_implementation(scipy=ufuncs.ellipeinc) +def ellipeinc(phi: Real, m: Real) -> Real: + """Incomplete elliptic integral of the second kind.""" + if not mp.isfinite(phi) or mp.isnan(m) or m == mp.inf: + # mpmath doesn't handle these cases, use self reference for now. + raise NotImplementedError + return mp.ellipe(phi, m) + + +@reference_implementation(scipy=ufuncs.ellipj) +def ellipj(u: Real, m: Real) -> Tuple[Real, Real, Real, Real]: + """Jacobian Elliptic functions.""" + sn = mp.ellipfun("sn", u=u, m=m) + cn = mp.ellipfun("cn", u=u, m=m) + dn = mp.ellipfun("dn", u=u, m=m) + phi = mp.asin(sn) + return sn, cn, dn, phi + + +@reference_implementation(scipy=ufuncs.ellipk) +def ellipk(m: Real) -> Real: + """Complete elliptic integral of the first kind.""" + return mp.ellipk(m) + + +@reference_implementation(scipy=ufuncs.ellipkinc) +def ellipkinc(phi: Real, m: Real) -> Real: + """Incomplete elliptic integral of the first kind.""" + if not mp.isfinite(phi) or mp.isnan(m) or m == mp.inf: + # mpmath doesn't handle these cases, use self reference for now. + raise NotImplementedError + return mp.ellipf(phi, m) + + +@reference_implementation(scipy=ufuncs.ellipkm1) +def ellipkm1(p: Real) -> Real: + """Complete elliptic integral of the first kind around m = 1.""" + # set the precision high enough to resolve 1 - p + with mp.workprec(get_resolution_precision(x=p)): + result = ellipk._mp(1 - p) + return result + + +@overload +def erf(x: Real) -> Real: ... +@overload +def erf(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.erf) +def erf(x): + """Error function. + + erf is an entire function + """ + return mp.erf(x) + + +@overload +def erfi(x: Real) -> Real: ... +@overload +def erfi(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.erfi) +def erfi(x): + """Imaginary error function. + + erfi is an entire function + """ + return -mp.j * mp.erf(mp.j * x) + + +@overload +def erfc(x: Real) -> Real: ... +@overload +def erfc(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.erfc) +def erfc(x): + """Complementary error function 1 - erf(x). + + Notes + ----- + erfc is an entire function + """ + return mp.erfc(x) + + +@overload +def erfcx(x: Real) -> Real: ... +@overload +def erfcx(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.erfcx) +def erfcx(x): + """Scaled complementary error function exp(x**2) * erfc(x) + + Notes + ----- + erfcx is an entire function + """ + return mp.exp(x**2) * mp.erfc(x) + + +@reference_implementation(scipy=ufuncs.erfcinv) +def erfcinv(x: Real) -> Real: + """Inverse of the complementary error function.""" + if not 0 <= x <= 2: + return mp.nan + if x == 0: + return mp.inf + with mp.workprec(get_resolution_precision(x=p)): + result = mp.erfinv(mp.one - x) + return result + + +@overload +def exp1(x: Real) -> Real: ... +@overload +def exp1(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.exp1) +def exp1(x): + """Exponential integral E1. + + Notes + ----- + Logarithmic singularity at x = 0 with branch cut on (-inf, 0). + """ + if x.imag == 0 and x.real < 0: + if not is_complex(x): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + x += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, x.imag) + return mp.e1(x) + + +@overload +def exp10(x: Real) -> Real: ... +@overload +def exp10(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.exp10) +def exp10(x): + """Compute 10**x.""" + return mp.mpf(10) ** x + + +@overload +def exp2(x: Real) -> Real: ... +@overload +def exp2(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.exp2) +def exp2(x): + """Compute 2**x.""" + return mp.mpf(2) ** x + + +@overload +def expi(x: Real) -> Real: ... +@overload +def expi(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.expi) +def expi(x): + """Exponential integral Ei. + + Notes + ----- + Logarithmic singularity at x = 0 with branch cut on (-inf, 0). + """ + if x.imag == 0 and x.real < 0: + if not is_complex(x): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + x += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, x.imag) + return mp.ei(x) + + +@reference_implementation(scipy=ufuncs.expit) +def expit(x: Real) -> Real: + """Expit (a.k.a logistic sigmoid).""" + return mp.sigmoid(x) + + +@overload +def expm1(x: Real) -> Real: ... +@overload +def expm1(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.expm1) +def expm1(x): + """exp(x) - 1. + + Notes + ----- + expm1 is an entire function + """ + return mp.expm1(x) + +@overload +def expn(n: Integer, x: Real) -> Real: ... +@overload +def expn(n: Real, x: Real) -> Real: ... + +@reference_implementation(scipy=ufuncs.expn) +def expn(n, x): + """Generalized exponential integral En.""" + return mp.expint(n, x) + + +@reference_implementation(scipy=ufuncs.exprel) +def exprel(x: Real) -> Real: + """Relative error exponential, (exp(x) - 1)/x.""" + if x == 0: + return mp.one + # set the precision high enough to avoid catastrophic cancellation + # Near 0, mp.exp(x) - 1 = x + O(x^2) + with mp.workprec(get_resolution_precision(x=x)): + result = (mp.exp(x) - 1) / x + return result + + +@reference_implementation(scipy=ufuncs.fdtr) +def fdtr(dfn: Real, dfd: Real, x: Real) -> Real: + """F cumulative distribution function.""" + if x < 0 or dfn < 0 or dfd < 0: + return mp.nan + x_dfn = x * dfn + return betainc._mp(dfn / 2, dfd / 2, x_dfn / (dfd + x_dfn)) + + +@reference_implementation(scipy=ufuncs.fdtrc) +def fdtrc(dfn: Real, dfd: Real, x: Real) -> Real: + """F survival function.""" + if x < 0 or dfn < 0 or dfd < 0: + return mp.nan + x_dfn = x * dfn + return betaincc._mp(dfn / 2, dfd / 2, x_dfn / (dfd + x_dfn)) + + +@reference_implementation(scipy=ufuncs.fdtri) +def fdtri(dfn: Real, dfd: Real, p: Real) -> Real: + """F cumulative distribution function.""" + if p < 0 or p > 1 or dfn < 0 or dfd < 0: + return mp.nan + if p == 0: + return 0.0 + if p == 1: + return mp.inf + q = betaincinv._mp(dfn / 2, dfd / 2, p) + return q * dfd / ((1 - q) * dfn) + +@overload +def fresnel(x: Real) -> Tuple[Real, Real]: ... +@overload +def fresnel(x: Complex) -> Tuple[Complex, Complex]: ... + + +@reference_implementation(scipy=ufuncs.fresnel) +def fresnel(x): + """Fresnel integrals. + + Notes + ----- + Fresnel integrals are entire functions + """ + return mp.fresnels(x), mp.fresnelc(x) + + +@overload +def gamma(x: Real) -> Real: ... +@overload +def gamma(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.gamma) +def gamma(x): + """Gamma function. + + Notes + ----- + Poles at nonpositive integers + """ + if x == 0.0: + if isinstance(x, float): + return math.copysign(mp.inf, x) + return mp.nan + if x.real < 0 and x.imag == 0 and x.real == mp.floor(x.real): + return mp.nan + return mp.gamma(x) + + +@reference_implementation(scipy=ufuncs.gammaincc) +def gammaincc(a: Real, x: Real) -> Real: + """Regularized upper incomplete gamma function.""" + if a < 0 or x < 0: + return mp.nan + if min(a, x) > 1e6: + raise NotImplementedError + return mp.gammainc(a, x, mp.inf, regularized=True) + + +@reference_implementation(scipy=ufuncs.gammainc) +def gammainc(a: Real, x: Real) -> Real: + """Regularized lower incomplete gamma function.""" + if a < 0 or x < 0: + return mp.nan + if min(a, x) > 1e6: + raise NotImplementedError + return mp.gammainc(a, 0, x, regularized=True) + + +@reference_implementation(scipy=ufuncs.gammainccinv) +def gammainccinv(a: Real, y: Real) -> Real: + """Inverse to the regularized upper incomplete gamma function.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.gammaincinv) +def gammaincinv(a: Real, y: Real) -> Real: + """Inverse to the regularized lower incomplete gamma function.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.gammaln) +def gammaln(x: Real) -> Real: + """Logarithm of the absolute value of the gamma function.""" + if x.real <= 0 and x == int(x): + return mp.inf + return mp.log(abs(mp.gamma(x))) + + +@reference_implementation(scipy=ufuncs.gammasgn) +def gammasgn(x: Real) -> Real: + """Sign of the gamma function.""" + if x == 0.0: + return math.copysign(1.0, x) + if x == -mp.inf or x < 0 and x == int(x): + return mp.nan + return mp.sign(mp.gamma(x)) + + +@reference_implementation(scipy=ufuncs.gdtr) +def gdtr(a: Real, b: Real, x: Real) -> Real: + """Gamma distribution cumulative distribution function.""" + if a < 0 or x < 0: + return mp.nan + if min(a*x, b) > 1e6: + raise NotImplementedError + return gammainc._mp(b, a * x) + + +@reference_implementation(scipy=ufuncs.gdtrc) +def gdtrc(a: Real, b: Real, x: Real)-> Real: + """Gamma distribution survival function.""" + if a < 0 or x < 0: + return mp.nan + if min(a*x, b) > 1e6: + raise NotImplementedError + return gammaincc._mp(b, a * x) + + +@reference_implementation(scipy=ufuncs.gdtrib) +def gdtrib(a: Real, p: Real, x: Real) -> Real: + """Inverse of `gdtr` vs b.""" + raise NotImplementedError + + +@overload +def hyp1f1(a: Real, b: Real, z: Real) -> Real: ... +@overload +def hyp1f1(a: Real, b: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.hyp1f1) +def hyp1f1(a, b, z): + """Confluent hypergeometric function 1F1. + + Notes + ----- + Entire in a and z + Meromorphic in b with poles at nonpositive integers + """ + return mp.hyp1f1(a, b, z) + + +@overload +def hyp2f1(a: Real, b: Real, c: Real, z: Real) -> Real: ... +@overload +def hyp2f1(a: Real, b: Real, c: Real, z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.hyp2f1) +def hyp2f1(a, b, c, z): + """Gauss hypergeometric function 2F1(a, b; c; z). + + Notes + ----- + Branch point at ``z=1`` with branch cut along ``(1, inf)`` + except for a or b a non-positive integer, in which case hyp2f1 reduces + to a polynomial. + """ + if z.imag == 0 and z.real > 1: + if not (a == mp.floor(a) or b == mp.floor(b)): + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.hyp2f1(a, b, c, z) + + +@reference_implementation(scipy=ufuncs.hyperu) +def hyperu(a: Real, b: Real, z: Real) -> Real: + """Confluent hypergeometric function U. + + Notes + ----- + Branch point at ``z=0`` with branch cut along ``(-inf, 0)``. + """ + if z.imag == 0 and z.real < 0: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero + z += mp.mpc("0", "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.hyperu(a, b, z) + + +@reference_implementation(scipy=ufuncs.iti0k0) +def it1i0k0(x: Real) -> Tuple[Real, Real]: + """Integrals of modified Bessel functions of order 0.""" + result1 = mp.quad(cyl_bessel_i0._mp, [0, x]) + result2 = mp.quad(cyl_bessel_k0._mp, [0, x]) + return result1, result2 + + +@reference_implementation(scipy=ufuncs.itj0y0) +def it1j0y0(x: Real) -> Tuple[Real, Real]: + """Integrals of Bessel functions of the first kind of order 0.""" + result1 = mp.quad(cyl_bessel_j0._mp, [0, x]) + result2 = mp.quad(cyl_bessel_y0._mp, [0, x]) + return result1, result2 + + +@reference_implementation(scipy=ufuncs.it2i0k0) +def it2i0k0(x: Real) -> Tuple[Real, Real]: + """Integrals related to modified Bessel functions of order 0.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.it2j0y0) +def it2j0y0(x: Real) -> Tuple[Real, Real]: + """Integrals related to Bessel functions of the first kind of order 0.""" + + def f1(t): + return (1 - cyl_bessel_j0._mp(t)) / t + + def f2(t): + return cyl_bessel_y0._mp(t) / t + + result1 = mp.quad(f1, [0, x]) + result2 = mp.quad(f2, [0, x]) + return result1, result2 + + +@reference_implementation(scipy=ufuncs.it2struve0) +def it2struve0(x: Real) -> Real: + """Integral related to the Struve function of order 0.""" + def f(t): + return struve_h._mp(0, t) / t + + return mp.quad(f, [0, x]) + + +@reference_implementation(scipy=ufuncs.itairy) +def itairy(x: Real) -> Tuple[Real, Real, Real, Real]: + """Integrals of Airy functions.""" + def ai(t): + return mp.airyai(t) + + def bi(t): + return mp.airybi(t) + + result1 = mp.quad(ai, [0, x]) + result2 = mp.quad(bi, [0, x]) + result3 = mp.quad(ai, [-x, 0]) + result4 = mp.quad(bi, [-x, 0]) + return result1, result2, result3, result4 + + +@reference_implementation(scipy=ufuncs.itmodstruve0) +def itmodstruve0(x: Real) -> Real: + """Integral of the modified Struve function of order 0.""" + def f(t): + return struve_l._mp(0, t) + + return mp.quad(f, [0, x]) + + +@reference_implementation(scipy=ufuncs.itstruve0) +def itstruve0(x: Real) -> Real: + """Integral of the modified Struve function of order 0.""" + def f(t): + return struve_l._mp(0, t) + + return mp.quad(f, [0, x]) + + +@reference_implementation(scipy=ufuncs._iv_ratio) +def iv_ratio(v: Real, x: Real) -> Real: + """Returns the ratio ``iv(v, x) / iv(v - 1, x)``""" + numerator = cyl_bessel_i._mp(v, x) + return numerator / cyl_bessel_i._mp(v - 1, x) + + +@reference_implementation(scipy=ufuncs._iv_ratio_c) +def iv_ratio_c(v: Real, x: Real) -> Real: + """Returns ``1 - iv_ratio(v, x)``.""" + numerator = cyl_bessel_i._mp(v, x) + denominator = cyl_bessel_i._mp(v - 1, x) + # Set precision high enough to avoid catastrophic cancellation. + # For large x, iv_ratio_c(v, x) ~ (v - 0.5) / x + with mp.workprec(get_resolution_precision(x=(v - 0.5) / x)): + result = mp.one - numerator / denominator + return result + + +@reference_implementation(scipy=ufuncs.kei) +def kei(x: Real) -> Real: + """Kelvin function kei.""" + if x < 0: + return mp.nan + if x >= 1050: + # kei increases monotonically to zero from below, can verify that + # mp.kei(1050) == mpf('-1.3691040650084756e-324') + # smaller than smallest subnormal in double precision. + # Return something smaller than smallest subnormal so output processing + # can pick up the correct sign of zero. + return mp.mpf("-1e324") + return mp.kei(0, x) + + +@reference_implementation(scipy=ufuncs.keip) +def keip(x: Real) -> Real: + """Derivative of the Kelvin function kei.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.kelvin) +def kelvin(x: Real) -> Tuple[Complex, Complex, Complex, Complex]: + """Kelvin functions as complex numbers.""" + be = mp.mpc(ber._mp(x), bei._mp(x)) + ke = mp.mpc(ker._mp(x), kei._mp(x)) + bep = mp.mpc(berp(to_fp(x)), beip(to_fp(x))) + kep = mp.mpc(kerp(to_fp(x)), keip(to_fp(x))) + return be, ke, bep, kep + + +@reference_implementation(scipy=ufuncs.ker) +def ker(x: Real) -> Real: + """Kelvin function ker.""" + if x < 0: + return mp.nan + if x >= 1050: + # ker decreases monotonically, can verify that + # mp.ker(1050) == mpf('1.8167754471810517e-325') + # smaller than smallest subnormal in double precision. + return mp.zero + return mp.ker(0, x) + + +@reference_implementation(scipy=ufuncs.kerp) +def kerp(x: Real) -> Real: + """Derivative of the Kelvin function kerp.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs._kolmogc) +def kolmogc(x: Real) -> Real: + """CDF of Kolmogorov distribution. + + CDF of Kolmogorov distribution can be expressed in terms of + Jacobi Theta functions. + TODO: Look into writing arbitrary precision reference implementations + for kolmogc, kolmogci, kolmogi, and kolmogorov. + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs._kolmogci) +def kolmogci(x: Real) -> Real: + """Inverse CDF of Kolmogorov distribution.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.kolmogi) +def kolmogi(x: Real) -> Real: + """Inverse Survival Function of Kolmogorov distribution.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.kolmogorov) +def kolmogorov(x: Real) -> Real: + """Survival Function of Kolmogorov distribution.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs._kolmogp) +def kolmogp(x: Real) -> Real: + """Negative of PDF of Kolmogorov distribution. + + TODO: Why is this the negative pdf? + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs._lambertw) +def lambertw(z: Complex, k: Integer, eps: Real) -> Complex: + """Lambert W function. + + Notes + ----- + Branch cut on (-inf, 0) for ``k != 0``, (-inf, -1/e) for ``k = 0`` + ``k = 0`` corresponds to the principle branch. + There are infinitely many branches. + + The tolerance eps is not actually used but included for compatibility. + """ + if z.imag == 0 and (z.real < 0 and k !=0 or z.real < -1/mp.e): + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero. + # mpmath's lambertw currently converts z to a complex128 internally, + # so the small step here can't be smaller than the smallest subnormal. + z += mp.mpc(0, 5e-324) * math.copysign(mp.one, z.imag) + return mp.lambertw(z, k=k) + + +@reference_implementation(scipy=ufuncs._lanczos_sum_expg_scaled) +def lanczos_sum_expg_scaled(z: Real) -> Real: + """Exponentially scaled Lanczos approximation to the Gamma function.""" + g = mp.mpf("6.024680040776729583740234375") + return (mp.e / (z + g - 0.5)) ** (z - 0.5) * mp.gamma(z) + + +@reference_implementation(scipy=ufuncs._lgam1p) +def lgam1p(x: Real) -> Real: + """Logarithm of abs(gamma(x + 1)).""" + if mp.isnan(x) or x == -mp.inf: + return mp.nan + if x == 0: + return mp.zero + if x == mp.inf: + return mp.inf + # set the precision high enough to resolve 1 + x. + with mp.workprec(get_resolution_precision(x=x)): + return gammaln._mp(x + 1) + + +@overload +def log1p(z: Real) -> Real: ... +@overload +def log1p(z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.log1p) +def log1p(z): + """Logarithm of z + 1. + + Notes + ----- + Branch cut on (-inf, -1) + """ + if z.imag == 0 and z.real < -1: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero. + z += mp.mpc(0, "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.log1p(z) + + +@overload +def log1pmx(z: Real) -> Real: ... +@overload +def log1pmx(z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs._log1pmx) +def log1pmx(z): + """log(z + 1) - z. + + Notes + ----- + Branch cut on (-inf, -1) + """ + # set the precision high enough to avoid catastrophic cancellation. + # Near z = 0 log(1 + z) - z = -z^2/2 + O(z^3) + with mp.workprec(get_resolution_precision(x=z/2)): + result = log1p._mp(z) - z + return result + + +@overload +def loggamma(z: Real) -> Real: ... +@overload +def loggamma(z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.loggamma) +def loggamma(z): + """Principal branch of the logarithm of the gamma function. + + Notes + ----- + Logarithmic singularity at z = 0 + Branch cut on (-inf, 0). + Poles at nonnegative integers. + """ + if z == 0: + if isinstance(z, float): + return math.copysign(mp.inf, z) + return mp.nan + if z.real < 0 and z.imag == 0 and z.real == mp.floor(z.real): + return mp.nan + if z.imag == 0 and z.real < 0: + if not is_complex(z): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero. + z += mp.mpc(0, "1e-1000000000") * math.copysign(mp.one, z.imag) + return mp.loggamma(z) + + +@reference_implementation(scipy=ufuncs.log_expit) +def log_expit(x: Real) -> Real: + """Log of `expit`.""" + return mp.log(mp.sigmoid(x)) + + +@reference_implementation(scipy=ufuncs.log_wright_bessel, default_timeout=10) +def log_wright_bessel(a: Real, b: Real, x: Real) -> Real: + """Natural logarithm of Wright's generalized Bessel function.""" + return mp.log(wright_bessel._mp(a, b, x)) + + +@reference_implementation(scipy=ufuncs.logit) +def logit(p: Real) -> Real: + """Logit function ``logit(p) = log(p/(1 - p))``""" + if p == 1: + return mp.inf + if p < 0 or p > 1: + return mp.nan + # set the precision high enough to resolve 1 - p. + with mp.workprec(get_resolution_precision(x=p)): + result = mp.log(p/(1-p)) + return result + + +@reference_implementation(scipy=ufuncs.mathieu_modcem1) +def mcm1(m: Real, q: Real, x: Real) -> Tuple[Real, Real]: + """Even modified Mathieu function of the first kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.mathieu_modcem2) +def mcm2(m: Real, q: Real, x: Real) -> Tuple[Real, Real]: + """Even modified Mathieu function of the second kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.modfresnelm) +def modified_fresnel_minus(x: Real) -> Tuple[Complex, Complex]: + """Modified Fresnel negative integrals.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.modfresnelp) +def modified_fresnel_plus(x: Real) -> Tuple[Complex, Complex]: + """Modified Fresnel negative integrals.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.mathieu_modsem1) +def msm1(m: Real, q: Real, x: Real) -> Tuple[Real, Real]: + """Odd modified Mathieu function of the first kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.mathieu_modsem2) +def msm2(m: Real, q: Real, x: Real) -> Tuple[Real, Real]: + """Odd modified Mathieu function of the second kind and its derivative.""" + raise NotImplementedError + + +@overload +def nbdtr(k: Integer, n: Integer, p: Real) -> Real: ... +@overload +def nbdtr(k: Real, n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.nbdtr) +def nbdtr(k, n, p): + """Negative binomial cumulative distribution function.""" + if ( + mp.isinf(k) or mp.isinf(n) + or p > 1 or p < 0 or k < 0 or n < 0 + ): + return mp.nan + return betainc._mp(n, k + 1, p) + + +@overload +def nbdtrc(k: Integer, n: Integer, p: Real) -> Real: ... +@overload +def nbdtrc(k: Real, n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.nbdtrc) +def nbdtrc(k, n, p): + """Negative binomial survival function.""" + if ( + mp.isinf(k) or mp.isinf(n) + or p > 1 or p < 0 or k < 0 or n < 0 + ): + return mp.nan + return betaincc._mp(n, k + 1, p) + + +@overload +def ndtr(x: Real) -> Real: ... +@overload +def ndtr(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.ndtr) +def ndtr(x): + """Cumulative distribution of the standard normal distribution.""" + if x.imag == 0: + return mp.ncdf(x.real) + return (1 + erf._mp(x/mp.sqrt(2)))/2 + + +@reference_implementation(scipy=ufuncs.ndtri) +def ndtri(y: Real) -> Real: + """Inverse of `ndtr` vs x.""" + if not 0 <= y <= 1: + return mp.nan + if y == 0: + return -mp.inf + if y == 1: + return mp.inf + # set the precision high enough to resolve 2*y - 1 + with mp.workprec(get_resolution_precision(x=2*y)): + result = mp.sqrt(2) * mp.erfinv(2*y - 1) + return result + + +@reference_implementation(scipy=ufuncs.obl_ang1_cv) +def oblate_aswfa( + m: Real, n: Real, c: Real, cv: Real, x: Real +) -> Tuple[Real, Real]: + """Oblate spheroidal angular function obl_ang1 for precomputed cv + + cv: Characteristic Value + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.obl_ang1) +def oblate_aswfa_nocv( + m: Real, n: Real, c: Real, x: Real +) -> Tuple[Real, Real]: + """Oblate spheroidal angular function of the first kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.obl_rad1_cv) +def oblate_radial1( + m: Real, n: Real, c: Real, cv: Real, x: Real +) -> Tuple[Real, Real]: + """Oblate spheroidal radial function obl_rad1 for precomputed cv + + cv: Characteristic Value + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.obl_rad1) +def oblate_radial1_nocv( + m: Real, n: Real, c: Real, x: Real +) -> Tuple[Real, Real]: + """Oblate spheroidal radial function of the first kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.obl_rad2_cv) +def oblate_radial2( + m: Real, n: Real, c: Real, cv: Real, x: Real +) -> Tuple[Real, Real]: + """Oblate spheroidal angular function obl_rad2 for precomputed cv + + cv: Characteristic Value + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.obl_rad2) +def oblate_radial2_nocv( + m: Real, n: Real, c: Real, x: Real +) -> Tuple[Real, Real]: + """Oblate spheroidal radial function of the second kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.obl_cv) +def oblate_segv(m: Real, n: Real, c: Real) -> Real: + """Characteristic value of oblate spheroidal function.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.owens_t) +def owens_t(h: Real, a: Real) -> Real: + """Owen's T Function.""" + def integrand(x): + return mp.exp(-(h**2) * (1 + x**2) / 2) / (1 + x**2) + + return mp.quad(integrand, [0, a]) / (2 * mp.pi) + + +@reference_implementation(scipy=ufuncs.pbdv) +def pbdv(v: Real, x: Real) -> Tuple[Real, Real]: + """Parabolic cylinder function D.""" + d = mp.pcfd(v, x) + _, dp = ufuncs.pbdv(to_fp(v), to_fp(x)) + message = ( + "Reference implementation pbdv falls back to SciPy for derivative." + ) + warnings.warn(message, XSRefFallbackWarning) + return d, to_mp(dp) + + +@reference_implementation(scipy=ufuncs.pbvv) +def pbvv(v: Real, x: Real) -> Tuple[Real, Real]: + """Parabolic cylinder function V.""" + # Set precision to guarantee -v - 0.5 retains precision for very small v. + with mp.workprec(get_resolution_precision(x=2*v)): + d = mp.pcfv(-v - 0.5, x) + _, dp = ufuncs.pbvv(to_fp(v), to_fp(x)) + message = ( + "Reference implementation pbvv falls back to SciPy for derivative." + ) + warnings.warn(message, XSRefFallbackWarning) + return d, to_mp(dp) + + +@reference_implementation(scipy=ufuncs.pbwa) +def pbwa(v: Real, x: Real) -> Tuple[Real, Real]: + """Parabolic cylinder function W.""" + d = mp.pcfw(v, x) + _, dp = ufuncs.pbwa(to_fp(v), to_fp(x)) + message = ( + "Reference implementation pbwa falls back to SciPy for derivative." + ) + warnings.warn(message, XSRefFallbackWarning) + return d, to_mp(dp) + + +@reference_implementation(scipy=ufuncs.pdtr) +def pdtr(k: Real, m: Real) -> Real: + """Poisson cumulative distribution function.""" + if k < 0 or m < 0: + return mp.nan + k = mp.floor(k) + return gammaincc._mp(k + 1, m) + + +@reference_implementation(scipy=ufuncs.pdtrc) +def pdtrc(k: Real, m: Real) -> Real: + """Poisson survival function.""" + if k < 0 or m < 0: + return mp.nan + k = mp.floor(k) + return gammainc._mp(k + 1, m) + + +@overload +def pdtri(k: Integer, y: Real) -> Real: ... +@overload +def pdtri(k: Real, y: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.pdtri) +def pdtri(k, y): + """Inverse of `pdtr` vs m.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.lpmv) +def pmv(m: Integer, v: Real, x: Real) -> Real: + """Associated Legendre function of integer order and real degree.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.poch) +def poch(z: Real, m: Real) -> Real: + """Pochhammer symbol.""" + return mp.rf(z, m) + + +@reference_implementation(scipy=ufuncs.pro_ang1_cv) +def prolate_aswfa( + m: Real, n: Real, c: Real, cv: Real, x: Real +) -> Tuple[Real, Real]: + """Prolate spheroidal angular function pro_ang1 for precomputed cv + + cv: Characteristic Value + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.pro_ang1) +def prolate_aswfa_nocv( + m: Real, n: Real, c: Real, x: Real +) -> Tuple[Real, Real]: + """Prolate spheroidal angular function of the first kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.pro_rad1_cv) +def prolate_radial1( + m: Real, n: Real, c: Real, cv: Real, x: Real +) -> Tuple[Real, Real]: + """Prolate spheroidal radial function pro_rad1 for precomputed cv + + cv: Characteristic Value + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.pro_rad1) +def prolate_radial1_nocv( + m: Real, n: Real, c: Real, x: Real +) -> Tuple[Real, Real]: + """Prolate spheroidal radial function of the first kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.pro_rad2_cv) +def prolate_radial2( + m: Real, n: Real, c: Real, cv: Real, x: Real +) -> Tuple[Real, Real]: + """Prolate spheroidal angular function pro_rad2 for precomputed cv + + cv: Characteristic Value + """ + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.pro_rad2) +def prolate_radial2_nocv( + m: Real, n: Real, c: Real, x: Real +) -> Tuple[Real, Real]: + """Prolate spheroidal radial function of the second kind and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.pro_cv) +def prolate_segv(m: Real, n: Real, c: Real) -> Real: + """Characteristic value of prolate spheroidal function.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.radian) +def radian(d: Real, m: Real, s: Real) -> Real: + """Convert from degrees to radians.""" + return mp.radians(d + m / 60 + s / 3600) + + +@overload +def rgamma(z: Real) -> Real: ... +@overload +def rgamma(z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.rgamma) +def rgamma(z): + """Reciprocal of the gamma function.""" + if z == 0.0: + return z + if z.imag == 0 and z.real < 0 and z.real == mp.floor(z.real): + return 0.0 + return mp.one / mp.gamma(z) + + +@overload +def riemann_zeta(z: Real) -> Real: ... +@overload +def riemann_zeta(z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs._riemann_zeta) +def riemann_zeta(z): + """Riemann zeta function. + + Notes + ----- + A single pole at z = 1 + """ + if z == 1.0: + return mp.nan + return mp.zeta(z) + + +@reference_implementation(scipy=ufuncs.round) +def round(x: Real) -> Real: + """Round to the nearest integer.""" + return mp.nint(x) + + +@reference_implementation(scipy=ufuncs._scaled_exp1) +def scaled_exp1(x: Real) -> Real: + """Exponentially scaled exponential integral E1.""" + return mp.exp(x) * x * mp.e1(x) + + +@reference_implementation(scipy=ufuncs.mathieu_sem) +def sem(m: Real, q: Real, x: Real) -> Tuple[Real, Real]: + """Odd Mathieu function and its derivative.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.mathieu_b) +def sem_cva(m: Real, q: Real) -> Real: + """Characteristic value of odd Mathieu functions.""" + raise NotImplementedError + + +@overload +def shichi(x: Real) -> Tuple[Real, Real]: ... +@overload +def shichi(x: Complex) -> Tuple[Complex, Complex]: ... + + +@reference_implementation(scipy=ufuncs.shichi) +def shichi(x): + """Hyperbolic sine and cosine integrals. + + Notes + ----- + Hyperbolic sine and cosine integrals are entire functions + + """ + return mp.shi(x), mp.chi(x) + + +@overload +def sici(x: Real) -> Tuple[Real, Real]: ... +@overload +def sici(x: Complex) -> Tuple[Complex, Complex]: ... + + +@reference_implementation(scipy=ufuncs.sici) +def sici(x): + """Sine and cosine integrals. + + Notes + ----- + Sine and cosine integrals are entire functions + """ + return mp.si(x), mp.ci(x) + + +@reference_implementation(scipy=ufuncs.sindg) +def sindg(x): + """Sine of the angle `x` given in degrees.""" + raise NotImplementedError + + +@overload +def sinpi(x: Real) -> Real: ... +@overload +def sinpi(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs._sinpi) +def sinpi(x): + """Sine of pi*x. + + Note + ---- + sinpi is an entire function + """ + if x.imag == 0 and x.real == mp.floor(x.real): + # Something smaller than smallest subnormal will be converted to a zero + # of the correct sign by output processing. + return math.copysign(mp.mpf("1e-324"), x.real) + return mp.sinpi(x) + + +@overload +def smirnov(n: Integer, p: Real) -> Real: ... +@overload +def smirnov(n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.smirnov) +def smirnov(n, d): + """Kolmogorov-Smirnov complementary cumulative distribution function.""" + raise NotImplementedError + + +@overload +def smirnovc(n: Integer, p: Real) -> Real: ... +@overload +def smirnovc(n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs._smirnovc) +def smirnovc(n, d): + """Kolmogorov-Smirnov cumulative distribution function.""" + raise NotImplementedError + + +@overload +def smirnovci(n: Integer, p: Real) -> Real: ... +@overload +def smirnovci(n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs._smirnovci) +def smirnovci(n, p): + """Inverse to `smirnovc`.""" + raise NotImplementedError + + +@overload +def smirnovi(n: Integer, p: Real) -> Real: ... +@overload +def smirnovi(n: Real, p: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs.smirnovi) +def smirnovi(n, p): + """Inverse to `smirnov`.""" + raise NotImplementedError + + +@overload +def smirnovp(n: Integer, d: Real) -> Real: ... +@overload +def smirnovp(n: Real, d: Real) -> Real: ... + + +@reference_implementation(scipy=ufuncs._smirnovp) +def smirnovp(n, d): + """Negative of Kolmogorov-Smirnov pdf.""" + raise NotImplementedError + + +@overload +def spence(z: Real) -> Real: ... +@overload +def spence(z: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.spence) +def spence(z): + """Spence's function, also known as the dilogarithm.""" + # set the precision high enough that mp.one - z != 1 + with mp.workprec(get_resolution_precision(x=z)): + result = mp.polylog(2, mp.one - z) + return result + + +@reference_implementation(scipy=ufuncs.struve) +def struve_h(v: Real, x: Real) -> Real: + """Struve function.""" + return mp.struveh(v, x) + + +@reference_implementation(scipy=ufuncs.modstruve) +def struve_l(v: Real, x: Real) -> Real: + """Modified Struve function.""" + return mp.struvel(v, x) + + +@reference_implementation(scipy=ufuncs.tandg) +def tandg(x: Real) -> Real: + """Tangent of angle x given in degrees.""" + raise NotImplementedError + + +@reference_implementation(scipy=ufuncs.voigt_profile) +def voigt_profile(x: Real, sigma: Real, gamma: Real) -> Real: + """Voigt profile""" + raise NotImplementedError + + +@overload +def wofz(x: Real) -> Real: ... +@overload +def wofz(x: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.wofz) +def wofz(x): + """Faddeeva function + + Notes + ----- + wofz is an entire function + """ + return mp.exp(-x**2) * mp.erfc(-mp.j * x) + + +@reference_implementation(scipy=ufuncs.wright_bessel, default_timeout=10) +def wright_bessel(a: Real, b: Real, x: Real) -> Real: + """Wright's generalized Bessel function.""" + def term(k): + m = a * k + b + if m <= 0 and m == mp.floor(m): + return mp.zero + return x**k / (mp.factorial(k) * mp.gamma(a * k + b)) + + return mp.nsum(term, [0, mp.inf]) + + +@overload +def xlogy(x: Real, y: Real) -> Real: ... +@overload +def xlogy(x: Complex, y: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.xlogy) +def xlogy(x, y): + """Compute ``x*log(y)`` so that the result is 0 if ``x = 0``.""" + if x == 0 and not (mp.isnan(x.real) or mp.isnan(x.imag)): + return 0 + if y.imag == 0 and y.real < 0: + if not is_complex(y): + # We will get a complex value on the branch cut, so if received real + # input and expecting real output, just return NaN. + return mp.nan + # On branch cut, choose branch based on sign of zero. + y += mp.mpc(0, "1e-1000000000") * math.copysign(mp.one, y.imag) + return x * mp.log(y) + + +@overload +def xlog1py(x: Real, y: Real) -> Real: ... +@overload +def xlog1py(x: Complex, y: Complex) -> Complex: ... + + +@reference_implementation(scipy=ufuncs.xlog1py) +def xlog1py(x, y): + """Compute ``x*log(y)`` so that the result is 0 if ``x = 0``.""" + if x == 0 and not (mp.isnan(x.real) or mp.isnan(x.imag)): + return mp.zero + return x * log1p._mp(y) + + +@reference_implementation(scipy=ufuncs._zeta) +def zeta(z: Real, q: Real) -> Real: + """Hurwitz zeta function.""" + if z == 1.0: + return mp.nan + return mp.zeta(z, a=q) + + +@reference_implementation(scipy=ufuncs.zetac) +def zetac(z: Real) -> Real: + """Riemann zeta function minus 1.""" + # set the precision high enough to avoid catastrophic cancellation. + # As z approaches +inf in the right halfplane: + # zeta(z) - 1 = 2^-z + O(3^-z). + if z == 1: + return mp.nan + with mp.workprec(get_resolution_precision(log2abs_x=-z.real)): + result = mp.zeta(z) - mp.one + return result + + +def solve_bisect(f, xl, xr, *, maxiter=1000): + if not xl < xr: + xl, xr = xr, xl + fl, fr = f(xl), f(xr) + if fl == 0: + return xl + if fr == 0: + return xr + if mp.sign(fl) == mp.sign(fr): + raise ValueError("f(xl) and f(xr) must have different signs") + + DBL_MAX = sys.float_info.max + DBL_TRUE_MIN = 5e-324 + + # Special handling for case where initial interval contains 0. It + # can take a long time to find a root near zero to a given + # relative tolerance through bisection alone, so this makes an + # effort to find a better starting bracket. + if xl <= 0 <= xr: + f0 = f(0) + if f0 == 0: + return mp.zero + vals = np.asarray([1e-50, 1e-100, 1e-150, 1e-200, 1e-250, 1e-300, 5e-324]) + if mp.sign(f0) == mp.sign(fr): + vals = -vals + for t in vals: + if xl > t: + continue + ft = f(t) + if mp.sign(ft) != mp.sign(fl): + xr = t; + break + xl = t + else: + for t in vals: + if xr < t: + continue + ft = f(t) + if mp.sign(ft) != mp.sign(fr): + xl = t; + break + xr = t + + iterations = Bisection(mp, f, [xl, xr]) + x_prev = mp.inf + for i, (x, error) in enumerate(iterations): + if i == maxiter: + raise RuntimeError("maxiter exceeded") + if abs(x - x_prev) < abs(x)*1e-17: + break + if x < DBL_TRUE_MIN: + return mp.zero + if x > DBL_MAX: + return mp.inf + x_prev = x + return x + + +# Reference implementation adds an attribute "__xsref" which can be used here to +# concisely ensure that only reference implementations make it into __all__. +__all__ = [ + s for s, obj in globals().items() + if hasattr(obj, "__xsref") +] diff --git a/src/xsref/cpp_generation.py b/src/xsref/cpp_generation.py new file mode 100644 index 00000000..ac820258 --- /dev/null +++ b/src/xsref/cpp_generation.py @@ -0,0 +1,411 @@ +"""Generate cpp code for xsf tests""" +import argparse +import pyarrow.parquet as pq +import subprocess + +from pathlib import Path + +import xsref + + +func_name_to_header = { + "airy": "xsf/airy.h", + "airye": "xsf/airy.h", + "bdtr": "xsf/stats.h", + "bdtrc": "xsf/stats.h", + "bdtri": "xsf/stats.h", + "bei": "xsf/kelvin.h", + "beip": "xsf/kelvin.h", + "ber": "xsf/kelvin.h", + "berp": "xsf/kelvin.h", + "besselpoly": "xsf/bessel.h", + "beta": "xsf/beta.h", + "betaln": "xsf/beta.h", + "binom": "xsf/binom.h", + "cbrt": "xsf/cephes/cbrt.h", + "cem": "xsf/mathieu.h", + "cem_cva": "xsf/mathieu.h", + "chdtr": "xsf/stats.h", + "chdtrc": "xsf/stats.h", + "chdtri": "xsf/stats.h", + "cosdg": "xsf/trig.h", + "cosm1": "xsf/trig.h", + "cospi": "xsf/trig.h", + "cotdg": "xsf/trig.h", + "cyl_bessel_i": "xsf/bessel.h", + "cyl_bessel_i0": "xsf/bessel.h", + "cyl_bessel_i0e": "xsf/bessel.h", + "cyl_bessel_i1": "xsf/bessel.h", + "cyl_bessel_i1e": "xsf/bessel.h", + "cyl_bessel_ie": "xsf/bessel.h", + "cyl_bessel_j": "xsf/bessel.h", + "cyl_bessel_j0": "xsf/bessel.h", + "cyl_bessel_j1": "xsf/bessel.h", + "cyl_bessel_je": "xsf/bessel.h", + "cyl_bessel_k": "xsf/bessel.h", + "cyl_bessel_k0": "xsf/bessel.h", + "cyl_bessel_k0e": "xsf/bessel.h", + "cyl_bessel_k1": "xsf/bessel.h", + "cyl_bessel_k1e": "xsf/bessel.h", + "cyl_bessel_ke": "xsf/bessel.h", + "cyl_bessel_y": "xsf/bessel.h", + "cyl_bessel_y0": "xsf/bessel.h", + "cyl_bessel_y1": "xsf/bessel.h", + "cyl_bessel_ye": "xsf/bessel.h", + "cyl_hankel_1": "xsf/bessel.h", + "cyl_hankel_1e": "xsf/bessel.h", + "cyl_hankel_2": "xsf/bessel.h", + "cyl_hankel_2e": "xsf/bessel.h", + "dawsn": "xsf/erf.h", + "digamma": "xsf/digamma.h", + "ellipe": "xsf/ellip.h", + "ellipeinc": "xsf/ellip.h", + "ellipj": "xsf/ellip.h", + "ellipk": "xsf/ellip.h", + "ellipkinc": "xsf/ellip.h", + "ellipkm1": "xsf/ellip.h", + "erf": "xsf/erf.h", + "erfc": "xsf/erf.h", + "erfcinv": "xsf/cephes/erfinv.h", + "erfcx": "xsf/erf.h", + "erfi": "xsf/erf.h", + "exp1": "xsf/expint.h", + "exp10": "xsf/exp.h", + "exp2": "xsf/exp.h", + "expi": "xsf/expint.h", + "expit": "xsf/log_exp.h", + "expm1": "xsf/exp.h", + "expn": "xsf/cephes/expn.h", + "exprel": "xsf/log_exp.h", + "fdtr": "xsf/stats.h", + "fdtrc": "xsf/stats.h", + "fdtri": "xsf/stats.h", + "fresnel": "xsf/fresnel.h", + "gamma": "xsf/gamma.h", + "gammainc": "xsf/gamma.h", + "gammaincc": "xsf/gamma.h", + "gammainccinv": "xsf/gamma.h", + "gammaincinv": "xsf/gamma.h", + "gammaln": "xsf/gamma.h", + "gammasgn": "xsf/gamma.h", + "gdtr": "xsf/stats.h", + "gdtrc": "xsf/stats.h", + "gdtrib": "xsf/cdflib.h", + "hyp1f1": "xsf/specfun.h", + "hyp2f1": "xsf/hyp2f1.h", + "it1i0k0": "xsf/bessel.h", + "it1j0y0": "xsf/bessel.h", + "it2i0k0": "xsf/bessel.h", + "it2j0y0": "xsf/bessel.h", + "it2struve0": "xsf/struve.h", + "itairy": "xsf/airy.h", + "itmodstruve0": "xsf/struve.h", + "itstruve0": "xsf/struve.h", + "iv_ratio": "xsf/iv_ratio.h", + "iv_ratio_c": "xsf/iv_ratio.h", + "kei": "xsf/kelvin.h", + "keip": "xsf/kelvin.h", + "kelvin": "xsf/kelvin.h", + "ker": "xsf/kelvin.h", + "kerp": "xsf/kelvin.h", + "kolmogc": "xsf/stats.h", + "kolmogci": "xsf/stats.h", + "kolmogi": "xsf/stats.h", + "kolmogorov": "xsf/stats.h", + "kolmogp": "xsf/stats.h", + "lambertw": "xsf/lambertw.h", + "lanczos_sum_expg_scaled": "xsf/cephes/lanczos.h", + "lgam1p": "xsf/cephes/unity.h", + "log1p": "xsf/log.h", + "log1pmx": "xsf/log.h", + "log_expit": "xsf/log_exp.h", + "log_wright_bessel": "xsf/wright_bessel.h", + "loggamma": "xsf/gamma.h", + "logit": "xsf/log_exp.h", + "mcm1": "xsf/mathieu.h", + "mcm2": "xsf/mathieu.h", + "modified_fresnel_minus": "xsf/fresnel.h", + "modified_fresnel_plus": "xsf/fresnel.h", + "msm1": "xsf/mathieu.h", + "msm2": "xsf/mathieu.h", + "nbdtr": "xsf/stats.h", + "nbdtrc": "xsf/stats.h", + "ndtr": "xsf/stats.h", + "ndtri": "xsf/stats.h", + "oblate_aswfa": "xsf/sphd_wave.h", + "oblate_aswfa_nocv": "xsf/sphd_wave.h", + "oblate_radial1": "xsf/sphd_wave.h", + "oblate_radial1_nocv": "xsf/sphd_wave.h", + "oblate_radial2": "xsf/sphd_wave.h", + "oblate_radial2_nocv": "xsf/sphd_wave.h", + "oblate_segv": "xsf/sphd_wave.h", + "owens_t": "xsf/stats.h", + "pbdv": "xsf/par_cyl.h", + "pbvv": "xsf/par_cyl.h", + "pbwa": "xsf/par_cyl.h", + "pdtr": "xsf/stats.h", + "pdtrc": "xsf/stats.h", + "pdtri": "xsf/stats.h", + "pmv": "xsf/specfun.h", + "poch": "xsf/cephes/poch.h", + "prolate_aswfa": "xsf/sphd_wave.h", + "prolate_aswfa_nocv": "xsf/sphd_wave.h", + "prolate_radial1": "xsf/sphd_wave.h", + "prolate_radial1_nocv": "xsf/sphd_wave.h", + "prolate_radial2": "xsf/sphd_wave.h", + "prolate_radial2_nocv": "xsf/sphd_wave.h", + "prolate_segv": "xsf/sphd_wave.h", + "radian": "xsf/trig.h", + "rgamma": "xsf/loggamma.h", + "riemann_zeta": "xsf/zeta.h", + "round": "xsf/cephes/round.h", + "scaled_exp1": "xsf/expint.h", + "sem": "xsf/mathieu.h", + "sem_cva": "xsf/mathieu.h", + "shichi": "xsf/sici.h", + "sici": "xsf/sici.h", + "sindg": "xsf/trig.h", + "sinpi": "xsf/trig.h", + "smirnov": "xsf/stats.h", + "smirnovc": "xsf/stats.h", + "smirnovci": "xsf/stats.h", + "smirnovi": "xsf/stats.h", + "smirnovp": "xsf/stats.h", + "spence": "xsf/cephes/spence.h", + "struve_h": "xsf/struve.h", + "struve_l": "xsf/struve.h", + "tandg": "xsf/trig.h", + "voigt_profile": "xsf/erf.h", + "wofz": "xsf/erf.h", + "wright_bessel": "xsf/wright_bessel.h", + "xlog1py": "xsf/log.h", + "xlogy": "xsf/log.h", + "zeta": "xsf/zeta.h", + "zetac": "xsf/zeta.h" +} + + +class _generate_test_case: + def __init__( + self, func_name, in_types, out_types, case_family, *, arg_names=None + ): + self.func_name = func_name + self.in_types = in_types + self.out_types = out_types + self.case_family = case_family + self.__type_map_in_out = { + "d": "double", + "f": "float", + "D": "std::complex", + "F": "std::complex", + "i": "std::int32_t", + "p": "std::ptrdiff_t", + } + self.__type_map_tol = { + "d": "double", + "f": "float", + "D": "double", + "F": "float", + } + + if arg_names is None: + arg_names = [f"in{i}" for i, _ in enumerate(in_types)] + self.arg_names = arg_names + + def _get_generator_types(self): + input_ = [self.__type_map_in_out[typecode] for typecode in self.in_types] + if len(input_) > 1: + input_ = f"std::tuple<{','.join(input_)}>" + else: + input_ = input_[0] + + output = ( + [self.__type_map_in_out[typecode] for typecode in self.out_types] + ['bool'] + ) + output = f"std::tuple<{', '.join(output)}>" + + tol = [self.__type_map_tol[typecode] for typecode in self.out_types] + if len(tol) > 1: + tol = f"std::tuple<{', '.join(tol)}>" + else: + tol = tol[0] + + return input_, output, tol + + def _get_filenames(self): + in_types = "_".join(self.in_types).replace("D", "cd").replace("F", "cf") + out_types = "_".join(self.out_types).replace("D", "cd").replace("F", "cf") + types = f"{in_types}-{out_types}" + return ( + f'"In_{types}.parquet"', + f'"Out_{types}.parquet"', + f'("Err_{types}_" + get_platform_str() + ".parquet")' + ) + + def _make_generator(self): + in_file, out_file, tol_file = self._get_filenames() + input_types, output_types, tol_types = self._get_generator_types() + result = "auto [input, output, tol] = GENERATE(\n" + result += "xsf_test_cases<\n" + result += f"{input_types}, {output_types}, {tol_types}>(\n" + result += f"tables_path / {in_file},\n" + result += f"tables_path / {out_file},\n" + result += f"tables_path / {tol_file}\n" + result += "));\n" + return result + + def _make_body(self): + result = "" + arg_names = self.arg_names + if len(arg_names) == 1: + args = arg_names[0] + result += f"auto {args} = input;\n" + else: + args = ', '.join(arg_names) + result += f"auto [{args}] = input;\n" + out_types = self.out_types + if len(out_types) == 1: + out_names = ["out"] + desired_names = ["desired"] + tol_names = ["tol"] + error_names = ["error"] + result += f"auto [desired, fallback] = output;\n" + result += f"auto out = xsf::{self.func_name}({args});\n" + result += f"auto error = xsf::extended_relative_error(out, desired);\n" + result += "tol = adjust_tolerance(tol);\n" + result += f"CAPTURE({', '.join(arg_names + ['out', 'desired', 'error', 'tol', 'fallback'])});\n" + result += "REQUIRE(error <= tol);\n" + else: + out_names = [f"out{i}" for i, _ in enumerate(out_types)] + desired_names = [f"desired{i}" for i, _ in enumerate(out_types)] + desired_unpack = ", ".join(desired_names + ["fallback"]) + tol_names = [f"tol{i}" for i, _ in enumerate(out_types)] + tol_unpack = ", ".join(tol_names) + error_names = [f"error{i}" for i, _ in enumerate(out_types)] + result += f"auto [{desired_unpack}] = output;\n\n" + for typecode, name in zip(out_types, out_names): + out_type = self.__type_map_in_out[typecode] + result += f"{out_type} {name};\n" + result += "\n" + # Need references of output variables since these get modified. + result += f"xsf::{self.func_name}({', '.join(arg_names + out_names)});\n" + result += f"auto [{tol_unpack}] = tol;\n\n" + for error_name, out_name, desired_name, tol_name in zip( + error_names, out_names, desired_names, tol_names + ): + result += f"auto {error_name} = xsf::extended_relative_error({out_name}, {desired_name});\n" + result += f"{tol_name} = adjust_tolerance({tol_name});\n" + result += f"CAPTURE({', '.join(arg_names + [out_name, desired_name, error_name, tol_name, 'fallback'])});\n" + result += f"REQUIRE({error_name} <= {tol_name});\n\n" + return result + + def __call__(self): + types = f"{self.in_types}->{self.out_types}" + func_name = self.func_name + case_family = self.case_family + + result = f'TEST_CASE("{func_name} {types} {case_family}", "[{func_name}][{types}][{case_family}]")' + result += " {\n" + result += "SET_FP_FORMAT()\n" + result += self._make_generator() + result += "\n" + result += self._make_body() + result += "}\n" + return result + + +def generate_cpp_test_case(func_name, in_types, out_types, case_family, *, arg_names=None): + gen = _generate_test_case(func_name, in_types, out_types, case_family, arg_names=arg_names) + return gen() + + +def generate_test_file(func_name, types, case_family, *, arg_names=None): + result = '#include "../testing_utils.h"\n\n' + header_name = func_name_to_header[func_name] + + result += f"#include <{header_name}>\n" + result += "\n" + + result += "namespace fs = std::filesystem;\n" + result += "\n" + + result += f'fs::path tables_path{{fs::path(XSREF_TABLES_PATH) / "{case_family}" / "{func_name}"}};\n' + + if "xsf/cephes/" in header_name: + func_name = f"cephes::{func_name}" + + for in_types, out_types in types: + result += "\n" + result += generate_cpp_test_case( + func_name, in_types, out_types, case_family, arg_names=arg_names + ) + + return result + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=( + "Generate c++ test cases associated to a collection of parquet" + " tables from xsref." + ) + ) + + parser.add_argument( + "inpath_root", + type=str, + help="The root directory where parquet files are located." + ) + + parser.add_argument( + "outpath_root", + type=str, + help=( + "The root directory under which test files will be stored." + " Typically '~/xsf/tests'." + ) + ) + + parser.add_argument( + "case_family", + type=str, + help="Name for family of test cases being added.", + ) + + parser.add_argument( + "--force", action="store_true", + help="If true, recreate files that already exist." + ) + + args = parser.parse_args() + + inpath_root = Path(args.inpath_root) + outpath_root = Path(args.outpath_root) + outpath_root.mkdir(exist_ok=True, parents=True) + + func_types = {} + func_arg_names = {} + for input_file_path in inpath_root.glob("**/In_*.parquet"): + metadata = pq.read_schema(input_file_path).metadata + in_types = metadata[b"in"].decode("ascii") + out_types = metadata[b"out"].decode("ascii") + func_name = metadata[b"function"].decode("ascii") + + if func_name not in func_name_to_header: + continue + + if func_name not in func_types: + func_types[func_name] = [[in_types, out_types]] + arg_names = None + if hasattr(xsref, func_name): + arg_names = getattr(xsref, func_name)._arg_names + func_arg_names[func_name] = arg_names + + for func_name, types in func_types.items(): + arg_names = func_arg_names[func_name] + outpath = outpath_root / f"test_{func_name}.cpp" + if not outpath.exists() or args.force: + test_file = generate_test_file( + func_name, types, args.case_family, arg_names=arg_names + ) + with open(outpath, "w") as f: + f.write(test_file) diff --git a/src/xsref/float_tools.py b/src/xsref/float_tools.py new file mode 100644 index 00000000..f3c61e4c --- /dev/null +++ b/src/xsref/float_tools.py @@ -0,0 +1,133 @@ +import numpy as np +import warnings + + +__all__ = ["extended_absolute_error", "extended_relative_error"] + + +def _extended_absolute_error_real(actual, desired): + dtype = type(desired) + actual = dtype(actual) + if actual == desired or (np.isnan(actual) and np.isnan(desired)): + return dtype(0.0) + if np.isnan(desired) or np.isnan(actual): + # If expected nan but got non-NaN or expected non-NaN but got NaN + # we consider this to be an infinite error. + return dtype("inf") + if np.isinf(actual): + # We don't want to penalize early overflow too harshly, so instead + # compare with the mythical value nextafter(max_float). + sgn = np.sign(actual) + mantissa_bits = np.finfo(dtype).nmant + max_float = np.finfo(dtype).max + # max_float * 2**-(mantissa_bits + 1) = ulp(max_float) + ulp = 2**-(mantissa_bits + 1) * max_float; + return abs( + (sgn * max_float - desired) + sgn * ulp + ) + if np.isinf(desired): + sgn = np.sign(desired) + mantissa_bits = np.finfo(dtype).nmant + max_float = np.finfo(dtype).max + # max_float * 2**-(mantissa_bits + 1) = ulp(max_float) + ulp = 2**-(mantissa_bits + 1) * max_float + return abs( + (sgn * max_float - actual) + sgn * ulp + ) + return abs(actual - desired) + + +def _extended_relative_error_real(actual, desired): + dtype = type(actual) + abs_error = _extended_absolute_error_real(actual, desired) + abs_desired = abs(desired) + if desired == 0.0: + # If the desired result is 0.0, normalize by smallest subnormal instead + # of zero. Some answers are still better than others and we want to guard + abs_desired = np.finfo(dtype).smallest_subnormal + elif np.isinf(desired): + abs_desired = np.finfo(dtype).max + elif np.isnan(desired): + # extended_relative_error(nan, nan) = 0, otherwise + # extended_relative_error(x0, x1) with one of x0 or x1 NaN is infinity. + abs_desired = dtype(1) + with warnings.catch_warnings(action="ignore"): + return abs_error / abs_desired + + +def _extended_absolute_error_complex(actual, desired): + dtype = type(desired) + actual = dtype(actual) + with warnings.catch_warnings(action="ignore"): + return np.hypot( + _extended_absolute_error_real(actual.real, desired.real), + _extended_absolute_error_real(actual.imag, desired.imag) + ) + + +def _extended_relative_error_complex(actual, desired): + abs_error = _extended_absolute_error_complex(actual, desired) + finfo = np.finfo(type(actual.real)) + + desired_real = desired.real + desired_imag = desired.imag + + if desired_real == 0: + desired_real = np.copysign(finfo.smallest_subnormal, desired.real) + elif np.isinf(desired_real): + desired_real = np.copysign(finfo.max, desired.real) + elif np.isnan(desired_real): + desired_real = 1.0 + + if desired_imag == 0: + desired_imag = np.copysign(finfo.smallest_subnormal, desired.imag) + elif np.isinf(desired_imag): + desired_imag = np.copysign(finfo.max, desired.imag) + elif np.isnan(desired_imag): + desired_imag = 1.0 + + desired = type(actual)(desired_real, desired_imag) + if not np.isinf(desired) and np.isinf(np.abs(desired)): + # Rescale to handle overflow. + return (abs_error / 2) / abs(desired / 2) + return abs_error / abs(desired) + +# We wrap the vectorized functions so that they will not raise +# RuntimeWarning's if the output is nan or inf. + +@np.vectorize +def _extended_absolute_error(actual, desired): + if np.issubdtype(type(actual), np.complexfloating): + return _extended_absolute_error_complex(actual, desired) + if np.issubdtype(type(actual), np.floating): + return _extended_absolute_error_real(actual, desired) + raise ValueError( + "Unhandled argument type for extended_absolute_error." + " Arguments must be a subdtype of np.floating or" + " np.complexfloating." + ) + + +@np.vectorize +def _extended_relative_error(actual, desired): + if np.issubdtype(type(actual), np.complexfloating): + return _extended_relative_error_complex(actual, desired) + if np.issubdtype(type(actual), np.floating): + return _extended_relative_error_real(actual, desired) + raise ValueError( + "Unhandled argument type for extended_relative_error." + " Arguments must be a subdtype of np.floating or" + " np.complexfloating." + ) + + +def extended_absolute_error(actual, desired): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", RuntimeWarning) + return _extended_absolute_error(actual, desired) + + +def extended_relative_error(actual, desired): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", RuntimeWarning) + return _extended_relative_error(actual, desired) diff --git a/src/xsref/initial_reference_tolerances.py b/src/xsref/initial_reference_tolerances.py new file mode 100644 index 00000000..40fe5c40 --- /dev/null +++ b/src/xsref/initial_reference_tolerances.py @@ -0,0 +1,26 @@ +import argparse +from pathlib import Path +import pyarrow.parquet as pq + +from xsref.tables import compute_initial_err_table + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("table_path_root") + args = parser.parse_args() + table_path_root = Path(args.table_path_root) + + for inpath in table_path_root.glob("**/In_*.parquet"): + tol_table = compute_initial_err_table(inpath) + metadata = tol_table.schema.metadata + cpp_compiler = metadata[b"cpp_compiler"].decode("ascii") + architecture = metadata[b"architecture"].decode("ascii") + operating_system = metadata[b"operating_system"].decode("ascii") + types = inpath.name.removesuffix(".parquet").replace("In_", "") + filename = ( + f"Err_{types}_" + f"{cpp_compiler}-{operating_system}-{architecture}.parquet" + ) + outpath = inpath.parent / filename + pq.write_table(tol_table, outpath, compression="zstd", compression_level=22) diff --git a/src/xsref/scipy_case_generation.py b/src/xsref/scipy_case_generation.py new file mode 100644 index 00000000..c4378ed8 --- /dev/null +++ b/src/xsref/scipy_case_generation.py @@ -0,0 +1,259 @@ +import argparse +import inspect +import os +import csv +import numpy as np +import polars as pl +import pyarrow.parquet as pq +import re + +from collections import defaultdict +from multiprocessing import Lock +from pathlib import Path + +import xsref + +from xsref.tables import _create_table_schema + + +__all__ = ["TracedUfunc"] + + +class TracedUfunc: + """Wraps a ufunc and traces all arguments it receives along with metadata. + + This was used to determine all existing scipy.special test cases for + ufuncs. To use, replace the following lines from scipy/special/__init__.py + + from . import _ufuncs + from ._ufuncs import * + + with + + from xsref.scipy_case_generation import TracedUfunc + + from . import _ufuncs + for func_name in dir(_ufuncs): + if func_name.startswith("__") or func_name in ["seterr", "geterr", "errstate"]: + continue + func = getattr(_ufuncs, func_name) + if not callable(func): + continue + setattr( + _ufuncs, + func_name, + TracedUfunc(func, outpath=f"~/special_test_cases/{func_name}.csv") + ) + from ._ufuncs import * + + and then run + + python dev.py test -t scipy.special.tests -m full + + to run all SciPy special tests. + + A csvfile for each tested ufunc will appear in the folder f"~/special_test_cases". + The first n columns of this csvfile correspond to the n arguments of the function. + The final three columns contain + + 1. A numpy typecode signature of the form "dddD->D", "d->d", "f->f", "pd->d" + etc. showing the typecodes that were dispatched to for the collection + of arguments from this row. + 2. The name of the file from which the test was taken. + 3. The name of the test function or method from which the test case + was taken. + + Here are some example rows from yn.csv for the function ``yn``. + + "1","1","pd->d","special/tests/test_basic.py","test_yn" + "0","0.1","pd->d","special/tests/test_basic.py","test_y0" + "1","1","pd->d","special/tests/test_basic.py","test_yn" + "0","0.1","pd->d","special/tests/test_basic.py","test_y0" + "1","1","pd->d","special/tests/test_basic.py","test_yn" + """ + def __init__(self, ufunc, /, *, outpath=None): + self.__ufunc = ufunc + self.__outpath = Path(outpath).expanduser() + self.__lock = Lock() + self._dtype_map = { + "float32": "f", + "float64": "d", + "float128": "g", + "complex64": "F", + "complex128": "D", + "complex256": "G", + "int64": "p", + "int32": "i", + } + + def __call__(self, *args, **kwargs): + try: + expanded_args = np.broadcast_arrays(*args) + # There is a test that inputs will not broadcast which + # is asserted to raise a ValueError. Just skip that case. + # It's not relevant when directly testing scalar kernels. + except ValueError: + return self.__ufunc(*args, **kwargs) + dtypes = tuple(val.dtype for val in expanded_args) + dtypes = self.__ufunc.resolve_dtypes(dtypes + (None, ) * self.__ufunc.nout) + dtypes = [self._dtype_map[str(dtype)] for dtype in dtypes] + sig = "".join(dtypes[:self.__ufunc.nin]) + "->" + sig += "".join(dtypes[self.__ufunc.nin:]) + expanded_args = [val.flatten() for val in expanded_args] + rows = ( + row + (sig, ) + self._get_file_metadata() for row in zip(*expanded_args) + ) + self.__outpath.parent.mkdir(exist_ok=True, parents=True) + with self.__lock: + with open(self.__outpath, 'a', newline='') as csvfile: + csv.writer(csvfile, dialect="unix").writerows(rows) + + return self.__ufunc(*args, **kwargs) + + def __getattr__(self, name): + return getattr(self.__ufunc, name) + + def _get_file_metadata(self): + frame = inspect.currentframe() + pattern1 = re.compile(r"[^/]+/tests/.+\.py") + pattern2 = re.compile("^test_.*") + for _ in range(10): + test_name = frame.f_code.co_name + test_file = frame.f_globals.get("__file__") + if test_file is None: + return test_file, test_name + test_file = os.path.join(*test_file.split(os.path.sep)[-3:]) + if pattern1.match(test_file) and pattern2.match(test_name): + return test_file, test_name + frame = frame.f_back + return None, None + + +def _parse_column(col, dtype): + if dtype is np.complex64 or dtype is np.complex128: + col = col.to_numpy().astype(dtype) + real = pl.Series(col.real) + imag = pl.Series(col.imag) + return pl.DataFrame({"real": real, "imag": imag}).to_struct() + if dtype is np.float64: + return col.cast(pl.Float64) + if dtype is np.float32: + return col.cast(pl.Float32) + if dtype is np.int32: + return col.cast(pl.Int32) + if dtype is np.int64: + return col.cast(pl.Int64) + raise ValueError(f"unsupported dtype: {dtype}") + + +def traced_cases_to_parquet(funcname, infiles, outdir): + """Take a csv produced by TracedUfunc and produce parquet reference table.""" + outdir = Path(outdir) + dtype_map = { + "f": np.float32, + "d": np.float64, + "F": np.complex64, + "D": np.complex128, + "p": np.int64, + "i": np.int32, + } + + if isinstance(infiles, str): + infiles = [infiles] + + new_rows = defaultdict(list) + for infile in infiles: + with open(infile, 'r', newline='') as csvfile: + for row in csv.reader(csvfile, dialect="unix"): + args = row[:-3] + types = row[-3] + in_types, out_types = types.split("->") + if len(args) != len(in_types): + continue + + new_row = [] + for typecode, arg in zip(in_types, args): + try: + arg = dtype_map[typecode](arg) + except KeyError: + # Test cases with other typecodes (long double for instance) + # are just skipped. + break + if typecode in ["F", "D"]: + new_row.extend([arg.real, arg.imag]) + else: + new_row.append(arg) + else: + new_rows[types].append(new_row) + + for types, rows in new_rows.items(): + in_types, _ = types.split("->") + schema = _create_table_schema(in_types, "in") + + df = pl.DataFrame(rows, orient="row", schema=schema).unique() + df = df.to_arrow() + + types = types.replace("->", "-") + in_types, out_types = types.split("-") + metadata = { + b"in": in_types.encode("ascii"), + b"out": out_types.encode("ascii"), + b"function": funcname.encode("ascii") + } + df = df.replace_schema_metadata(metadata) + # Need to generate filenames based on the types which will still + # work on case insensitive filenames. + in_types = "_".join(in_types).replace("D", "cd").replace("F", "cf") + out_types = "_".join(out_types).replace("D", "cd").replace("F", "cf") + types = f"{in_types}-{out_types}" + pq.write_table(df, + outdir / f"In_{types}.parquet", + compression="zstd", + compression_level=22, + ) + + +def get_scipy_to_xsref_funcname_map(): + result = {} + for symbol in xsref.__all__: + obj = getattr(xsref, symbol) + if hasattr(obj, "_scipy_func"): + result[obj._scipy_func.__name__] = obj.__name__ + return result + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "inpath_root", + type=str, + help="Root directory where csv files of test cases are stored." + ) + parser.add_argument( + "outpath_root", + type=str, + help="Root directory where output files will be stored. Typically" + " xsref/tables." + ) + args = parser.parse_args() + + inpath_root = Path(args.inpath_root) + outpath_root = Path(args.outpath_root) + + scipy_to_xsref_funcname_map = get_scipy_to_xsref_funcname_map() + + # In some cases, there are multiple SciPy ufuncs which correspond + # to the same underlying implementation in xsf and thus the same + # xsref reference implementation. This loop collects all csv files + # corresponding to cases for a given xsref reference implementation. + xsref_func_to_case_files_map = defaultdict(list) + for inpath in inpath_root.glob("*.csv"): + scipy_func = inpath.name.removesuffix(".csv") + xsref_func = scipy_to_xsref_funcname_map.get(scipy_func) + if xsref_func is not None: + xsref_func_to_case_files_map[xsref_func].append(inpath) + + for funcname, filepaths in xsref_func_to_case_files_map.items(): + outdir = outpath_root / "scipy_special_tests" / funcname + outdir.mkdir(exist_ok=True, parents=True) + traced_cases_to_parquet(funcname, filepaths, outdir) diff --git a/src/xsref/tables.py b/src/xsref/tables.py new file mode 100644 index 00000000..d1004edb --- /dev/null +++ b/src/xsref/tables.py @@ -0,0 +1,501 @@ +import argparse +import csv +import hashlib +import mpmath +import numpy as np +import os +import polars as pl +import pyarrow as pa +import pyarrow.parquet as pq +import re +import scipy +import subprocess +import warnings + +from concurrent.futures import ProcessPoolExecutor +from functools import partial +from multiprocessing import Lock +from multiprocessing import Manager +from pathlib import Path + + +import xsref._reference._functions as xsref_funcs + +from xsref.float_tools import extended_relative_error +from xsref._reference._framework import XSRefFallbackWarning + + +def _process_arg(arg, typecode): + match typecode: + case "d": + return np.float64(arg) + case "f": + return np.float32(arg) + case "i": + return np.int32(arg) + case "p": + return np.int64(arg) + case "F": + return np.complex64(arg[0], arg[1]) + case "D": + return np.complex128(arg[0], arg[1]) + case "_": + raise ValueError(f"Received unhandled typecode: {typecode}") + + +def get_in_out_types(table_path): + """Get input types of function corresponding to table_path + + Parameters + ---------- + table_path : str + Path to a parquet table with rows corresponding to arguments to + a special function and in format used by xsref. float32, float64, int32 + and int64 inputs have corresponding types in parquet. Because parquet + does not support complex types, complex inputs are stored in two columns + each of the corresponding base type. + + Returns + ------- + tuple of str + Strings of NumPy dtype typecodes corresponding to the input types + and output_types respectively for the given reference table. + """ + metadata = pq.read_schema(table_path).metadata + return metadata[b"in"].decode("ascii"), metadata[b"out"].decode("ascii") + + +def get_input_rows(table_path): + """Return test cases from inputs parquet table. + + Parameters + ---------- + table_path : str + Path to a parquet table with rows corresponding to arguments to + a special function and in format used by xsref. float32, float64, int32 + and int64 inputs have corresponding types in parquet. Complex inputs + are stored in two columns of the corresponding base type. + + Returns + ------- + List of tuple + Arguments for reference function from reference table. + """ + input_types, _ = get_in_out_types(table_path) + table = pl.read_parquet(table_path) + + results = [] + for row in table.iter_rows(): + i = 0 + processed_row = [] + for typecode in input_types: + if typecode in ["F", "D"]: + processed_row.append(_process_arg([row[i], row[i+1]], typecode)) + i += 2 + else: + processed_row.append(_process_arg(row[i], typecode)) + i += 1 + results.append(tuple(processed_row)) + return results + + +def get_output_rows(table_path): + """Return test case reference values from outputs parquet table. + + Parameters + ---------- + table_path : str + Path to a parquet table with rows corresponding to outputs of a a + special function and in format used by xsref. float32, float64, int32 + and int64 inputs have corresponding types in parquet. Complex outputs + are stored in two columns of the corresponding base type. The final + column is named ``"fallback"`` and is of type ``bool``. ``"fallback"`` + holds value True if the reference value was taken from SciPy or xsf + itself, and is thus not an independent reference value. This is done + on a temporary basis to guard against regressions if a reference + implementation has not yet been implemented for a function in a given + parameter regime. + + Returns + ------- + List of tuple + Outputs for reference function from reference table. + """ + _, output_types = get_in_out_types(table_path) + table = pl.read_parquet(table_path) + + results = [] + for row in table.iter_rows(): + i = 0 + processed_row = [] + for typecode in output_types: + if typecode in ["F", "D"]: + processed_row.append(_process_arg([row[i], row[i+1]], typecode)) + i += 2 + else: + processed_row.append(_process_arg(row[i], typecode)) + i += 1 + results.append(tuple(processed_row)) + return results + + +def init(shared_lock): + global _shared_lock + + +def _evaluate(func, logpath, ertol, lock, args): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", XSRefFallbackWarning) + ref_results = func(*args) + fallback = any([x.category is XSRefFallbackWarning for x in w]) + + scipy_results = func._scipy_func(*args) + if not isinstance(scipy_results, tuple): + scipy_results = (scipy_results, ) + if not isinstance(ref_results, tuple): + ref_results = (ref_results, ) + + if not len(scipy_results) == len(ref_results): + raise ValueError( + f"Reference function {func} returned a different" + " number of outputs from corresponding SciPy function" + f" {func._scipy_func} for args {args}." + ) + + + if ( + tuple((type(x)) for x in scipy_results) + != tuple(type(x) for x in ref_results) + ): + raise ValueError( + f"Reference function {func} returned outputs of different" + " type from corresponding SciPy function" + f" {func._scipy_func} for args {args}." + ) + + errors = [] + for scipy_result, ref_result in zip(scipy_results, ref_results): + error = extended_relative_error(scipy_result, ref_result) + if logpath is not None and error >= ertol: + with lock: + if not os.path.exists(logpath): + with open(logpath, 'w', newline='') as csvfile: + csv.writer(csvfile, dialect="unix").writerow( + [f"in{i}" for i in range(len(args))] + + [f"ref_out{i}" for i in range(len(ref_results))] + + [f"scipy_out{i}" for i in range(len(scipy_results))] + ) + with open(logpath, 'a', newline='') as csvfile: + csv.writer(csvfile, dialect="unix").writerow( + args + ref_results + scipy_results + ) + + row = [] + for val in ref_results: + if np.issubdtype(val, np.complexfloating): + row.extend([val.real, val.imag]) + else: + row.append(val) + row.append(fallback) + + return row + +_shared_lock = Lock() + + +def _calculate_checksum(filepath): + with open(filepath, "rb") as f: + content = f.read() + checksum = hashlib.sha256(content).hexdigest() + return checksum + + +def _get_git_info(): + # Getting a commit hash requires an in-place build. + try: + commit_hash = subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=Path(__file__).parent + ).strip() + + status_check = subprocess.check_output( + ["git", "status", "--porcelain", "--untracked-files=no"], + cwd=Path(__file__).parent + ).decode("utf-8").splitlines() + + pattern = re.compile(r"^ \S{1,2} tables/") + + non_table_changes = [ + line for line in status_check + if not pattern.search(line) + ] + working_tree = b"dirty" if non_table_changes else b"clean" + + except subprocess.CalledProcessError: + commit_hash = b"" + working_tree = b"" + return commit_hash, working_tree + + +_np_to_pl_type_map = { + "f": pl.Float32, + "d": pl.Float64, + # complex values (F and D) are stored in two columns of a real floating + # point type. + "F": pl.Float32, + "D": pl.Float64, + "p": pl.Int64, + "i": pl.Int32, +} + + +def _create_table_schema(typecodes, prefix): + schema = {} + for i, typecode in enumerate(typecodes): + if typecode in ["F", "D"]: + schema[f"{prefix}{i}_real"] = _np_to_pl_type_map[typecode] + schema[f"{prefix}{i}_imag"] = _np_to_pl_type_map[typecode] + else: + schema[f"{prefix}{i}"] = _np_to_pl_type_map[typecode] + return schema + + +def compute_output_table(inpath, *, logpath=None, ertol=1e-2, nworkers=1): + """Compute arrow table of outputs associated to parquet file with inputs + + Parameters + ---------- + inpath : str + Path to a parquet file of inputs of the kind accepted by xsref. It has + columns for each input argument, of type ``f32``, ``f64``, ``int32``, + ``int64`` for these respective types, with ``complex64`` and + ``complex128`` arguments expressed in two columns of type ``f32`` or + ``f64`` respectively. The metadata contains the input types as an ascii + encoded string of NumPy dtype codes in the field ``b"in"``, the output + types as a similar string in the field ``b"out"``, and the associated + `xsref` reference function in the ascii encoded field ``b"function"`` + + logpath : Optional[str] + Path to where to store log file for this run. If None, no log is + stored. The log is a csv file of rows where the associated SciPy + function, returns a value which differs from the arbitrary precision + reference function by an extended relative error greater than + `ertol`. Each row contains input arguments together with corresponding + outputs for first the reference implementation and then the SciPy + implementation. Default: ``None`` + + ertol : Optional[float] + Extended relative error cutoff for adding a row to the log. Extended + relative error is equal to relative error for non-exceptional values + (finite and non-zero), but is modified to still produce an informative + value when a comparison contains one or more exceptional values. + Default: ``1e-2`` + + nworkers : Optional[int] + Controls the max number of workers used by `ProcessPoolExecutor`. + Default: ``1``. + + Returns + ------- + pyarrow.lib.Table + An arrow table of outputs associated to the corresponding inputs, plus + a Boolean column ``"fallback"`` which takes value ``True`` if and only + if the reference computation fell back to a double precision + calculation in SciPy. The metadata for the input table is the same as + for the output table, except that there are new entries: + + input_checksum + containing a sha256 checksum of the input parquet table. + mpmath_version + mpmath.__version__ at time of running + xsref_commit_hash + If using an in-place build, the current git commit hash for xsref. + working_tree_state + One of b"dirty" or b"clean". + + These additional metadata items can be used to help verify the integrity + of reference tables. + """ + metadata = pq.read_schema(inpath).metadata + checksum = _calculate_checksum(inpath) + metadata[b"input_checksum"] = checksum.encode("ascii") + metadata[b"mpmath_version"] = mpmath.__version__.encode("ascii") + + commit_hash, working_tree = _get_git_info() + + metadata[b"xsref_commit_hash"] = commit_hash + metadata[b"working_tree_state"] = working_tree + + funcname = metadata[b"function"].decode("ascii") + func = getattr(xsref_funcs, funcname) + + manager = Manager() + lock = manager.Lock() + + with ProcessPoolExecutor(max_workers=nworkers) as executor: + results = executor.map( + partial(_evaluate, func, logpath, ertol, lock), get_input_rows(inpath) + ) + results = list(results) + if not results: + return None + + schema = _create_table_schema(metadata[b"out"].decode("ascii"), "out") + schema["fallback"] = pl.Boolean() + + table = pl.DataFrame(results, orient="row", schema=schema) + table = table.to_arrow() + table = table.replace_schema_metadata(metadata) + + return table + + +def compute_initial_err_table(inpath): + """Use SciPy to calculate initial table of expected errors for xsref + + Parameters + ---------- + inpath : str + Path to a parquet file with inputs for test cases + + Returns + ------- + pyarrow.lib.Table + + Rows correspond to test cases and columns to outputs. Entries contain + the extended relative error between the expected result from the xsref + reference and what is computed with SciPy. The idea is that the initial + tolerances for all test cases will be based on the existing extended + relative errors between xsref and SciPy. + """ + inpath = Path(inpath) + outpath = inpath.parent / inpath.name.replace("In_", "Out_") + if not os.path.exists(outpath): + return None + metadata = pq.read_schema(inpath).metadata + funcname = metadata[b"function"].decode("ascii") + xsref_func = getattr(xsref_funcs, funcname) + scipy_func = xsref_func._scipy_func + + input_rows = get_input_rows(inpath) + reference_output_rows = np.asarray(get_output_rows(outpath)).T + observed_output = np.asarray(scipy_func(*zip(*input_rows))) + + err = extended_relative_error(observed_output, reference_output_rows) + + tol_table = pa.table( + {f"err{i}": pa.array(err[i, :]) for i in range(err.shape[0])} + ) + + input_checksum = _calculate_checksum(inpath) + output_checksum = _calculate_checksum(outpath) + + scipy_config = scipy.__config__.show(mode="dicts") + cpp_compiler = scipy_config["Compilers"]["c++"] + architecture = scipy_config["Machine Information"]["host"]["cpu"] + operating_system = scipy_config["Machine Information"]["host"]["system"] + + metadata[b"input_checksum"] = input_checksum.encode("ascii") + metadata[b"output_checksum"] = output_checksum.encode("ascii") + metadata[b"scipy_version"] = scipy.__version__.encode("ascii") + metadata[b"cpp_compiler"] = cpp_compiler["name"].encode("ascii") + metadata[b"cpp_compiler_version"] = cpp_compiler["version"].encode("ascii") + metadata[b"architecture"] = architecture.encode("ascii") + metadata[b"operating_system"] = operating_system.encode("ascii") + commit_hash, working_tree = _get_git_info() + metadata[b"xsref_commit_hash"] = commit_hash + metadata[b"working_tree_state"] = working_tree + + tol_table = tol_table.replace_schema_metadata(metadata) + return tol_table + + +def main(inpath_root, *, logpath_root=None, force=False, ertol=1e-2, nworkers=1): + inpath_root = Path(inpath_root) + logpath_root = Path(logpath_root) + logpath_root.mkdir(exist_ok=True, parents=True) + for inpath in inpath_root.glob("**/In_*.parquet"): + outpath = inpath.parent / inpath.name.replace("In_", "Out_") + input_checksum = _calculate_checksum(inpath) + if os.path.exists(outpath): + output_metadata = pq.read_schema(outpath).metadata + if ( + input_checksum == output_metadata[b"input_checksum"].decode("ascii") + and not force + ): + continue + logpath = logpath_root / inpath.relative_to( + inpath.parents[2] + ).with_suffix(".log") + logpath.parent.mkdir(exist_ok=True, parents=True) + table = compute_output_table( + inpath, logpath=logpath, ertol=ertol, nworkers=nworkers, + ) + pq.write_table(table, outpath, compression="zstd", compression_level=22) + + +# The script below uses the xsref reference implementations to generate parquet +# files with reference outputs corresponding to the input parquet files +# under (potentially recursively) inpath_root. The logs placed under --logpath_root +# in folders that match the directory structure under inpath_root contain cases +# where the difference between the test cases under SciPy 1.15.1 and the reference +# implementation differ. This is particularly useful for the first +# batch of test cases which are taken from the scipy.special tests, because presumably +# these should all pass (except those which were marked xfail). + +# Multiprocessing is used to speed things up, but the way it's used could be improved. +# Right now processes can starve when the number of cores is large, because processes +# are split up one input file at a time, and many of the input files are small. +# This could be improved by batching up cases from all input files at once, something +# which should eventually be pursued, but hasn't been yet because this is good +# enough. + +# example use + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=( + "Generate reference output parquet files corresponding to input" + " parquet files under inpath_root (searches directories recursively" + " for all with filename matching the pattern \"In_*.parquet\" and" + " generates the corresponding output files as alongside them as " + " \"Out_*.parquet\"." + ) + ) + parser.add_argument( + "inpath_root", + type=str, + help="The root directory where input parquet files are located." + ) + parser.add_argument( + "--logpath_root", + type=str, + default=None, + help="The directory where log files will be saved. Defaults to None.", + ) + parser.add_argument( + "--force", + action="store_true", + help="Force processing even if output already exists and checksums match.", + ) + parser.add_argument( + "--ertol", + type=float, + default=1e-2, + help="Error tolerance for cases that end up in the logs (default: 1e-2).", + ) + parser.add_argument( + "--nworkers", + type=int, + default=1, + help="Number of workers to use for computation (default: 1).", + ) + + args = parser.parse_args() + main( + args.inpath_root, + logpath_root=args.logpath_root, + force=args.force, + ertol=args.ertol, + nworkers=args.nworkers, + ) diff --git a/tables/scipy_special_tests/airy/Err_cd-cd_cd_cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/airy/Err_cd-cd_cd_cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..e67edaa2 Binary files /dev/null and b/tables/scipy_special_tests/airy/Err_cd-cd_cd_cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/airy/Err_d-d_d_d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/airy/Err_d-d_d_d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..647e135d Binary files /dev/null and b/tables/scipy_special_tests/airy/Err_d-d_d_d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/airy/In_cd-cd_cd_cd_cd.parquet b/tables/scipy_special_tests/airy/In_cd-cd_cd_cd_cd.parquet new file mode 100644 index 00000000..e3e2d4bf Binary files /dev/null and b/tables/scipy_special_tests/airy/In_cd-cd_cd_cd_cd.parquet differ diff --git a/tables/scipy_special_tests/airy/In_d-d_d_d_d.parquet b/tables/scipy_special_tests/airy/In_d-d_d_d_d.parquet new file mode 100644 index 00000000..765b23e9 Binary files /dev/null and b/tables/scipy_special_tests/airy/In_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/airy/Out_cd-cd_cd_cd_cd.parquet b/tables/scipy_special_tests/airy/Out_cd-cd_cd_cd_cd.parquet new file mode 100644 index 00000000..bd49eb43 Binary files /dev/null and b/tables/scipy_special_tests/airy/Out_cd-cd_cd_cd_cd.parquet differ diff --git a/tables/scipy_special_tests/airy/Out_d-d_d_d_d.parquet b/tables/scipy_special_tests/airy/Out_d-d_d_d_d.parquet new file mode 100644 index 00000000..f0e6ad1b Binary files /dev/null and b/tables/scipy_special_tests/airy/Out_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/airye/Err_cd-cd_cd_cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/airye/Err_cd-cd_cd_cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..84f3ce58 Binary files /dev/null and b/tables/scipy_special_tests/airye/Err_cd-cd_cd_cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/airye/Err_d-d_d_d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/airye/Err_d-d_d_d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2d9e99ac Binary files /dev/null and b/tables/scipy_special_tests/airye/Err_d-d_d_d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/airye/In_cd-cd_cd_cd_cd.parquet b/tables/scipy_special_tests/airye/In_cd-cd_cd_cd_cd.parquet new file mode 100644 index 00000000..677a3daf Binary files /dev/null and b/tables/scipy_special_tests/airye/In_cd-cd_cd_cd_cd.parquet differ diff --git a/tables/scipy_special_tests/airye/In_d-d_d_d_d.parquet b/tables/scipy_special_tests/airye/In_d-d_d_d_d.parquet new file mode 100644 index 00000000..3bb77078 Binary files /dev/null and b/tables/scipy_special_tests/airye/In_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/airye/Out_cd-cd_cd_cd_cd.parquet b/tables/scipy_special_tests/airye/Out_cd-cd_cd_cd_cd.parquet new file mode 100644 index 00000000..bf87852f Binary files /dev/null and b/tables/scipy_special_tests/airye/Out_cd-cd_cd_cd_cd.parquet differ diff --git a/tables/scipy_special_tests/airye/Out_d-d_d_d_d.parquet b/tables/scipy_special_tests/airye/Out_d-d_d_d_d.parquet new file mode 100644 index 00000000..388cb648 Binary files /dev/null and b/tables/scipy_special_tests/airye/Out_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/bdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a223c99d Binary files /dev/null and b/tables/scipy_special_tests/bdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bdtr/Err_d_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bdtr/Err_d_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c95af611 Binary files /dev/null and b/tables/scipy_special_tests/bdtr/Err_d_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bdtr/In_d_d_d-d.parquet b/tables/scipy_special_tests/bdtr/In_d_d_d-d.parquet new file mode 100644 index 00000000..aafbdadb Binary files /dev/null and b/tables/scipy_special_tests/bdtr/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtr/In_d_p_d-d.parquet b/tables/scipy_special_tests/bdtr/In_d_p_d-d.parquet new file mode 100644 index 00000000..95b0c9e8 Binary files /dev/null and b/tables/scipy_special_tests/bdtr/In_d_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtr/Out_d_d_d-d.parquet b/tables/scipy_special_tests/bdtr/Out_d_d_d-d.parquet new file mode 100644 index 00000000..e0b15269 Binary files /dev/null and b/tables/scipy_special_tests/bdtr/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtr/Out_d_p_d-d.parquet b/tables/scipy_special_tests/bdtr/Out_d_p_d-d.parquet new file mode 100644 index 00000000..154a1fca Binary files /dev/null and b/tables/scipy_special_tests/bdtr/Out_d_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d2152c73 Binary files /dev/null and b/tables/scipy_special_tests/bdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bdtrc/Err_d_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bdtrc/Err_d_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c100802b Binary files /dev/null and b/tables/scipy_special_tests/bdtrc/Err_d_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bdtrc/In_d_d_d-d.parquet b/tables/scipy_special_tests/bdtrc/In_d_d_d-d.parquet new file mode 100644 index 00000000..f9df4026 Binary files /dev/null and b/tables/scipy_special_tests/bdtrc/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtrc/In_d_p_d-d.parquet b/tables/scipy_special_tests/bdtrc/In_d_p_d-d.parquet new file mode 100644 index 00000000..f7986b93 Binary files /dev/null and b/tables/scipy_special_tests/bdtrc/In_d_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtrc/Out_d_d_d-d.parquet b/tables/scipy_special_tests/bdtrc/Out_d_d_d-d.parquet new file mode 100644 index 00000000..a54138e7 Binary files /dev/null and b/tables/scipy_special_tests/bdtrc/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtrc/Out_d_p_d-d.parquet b/tables/scipy_special_tests/bdtrc/Out_d_p_d-d.parquet new file mode 100644 index 00000000..4788f12d Binary files /dev/null and b/tables/scipy_special_tests/bdtrc/Out_d_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtri/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bdtri/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9d42b656 Binary files /dev/null and b/tables/scipy_special_tests/bdtri/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bdtri/Err_d_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bdtri/Err_d_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..eaa0374d Binary files /dev/null and b/tables/scipy_special_tests/bdtri/Err_d_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bdtri/In_d_d_d-d.parquet b/tables/scipy_special_tests/bdtri/In_d_d_d-d.parquet new file mode 100644 index 00000000..82f19e58 Binary files /dev/null and b/tables/scipy_special_tests/bdtri/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtri/In_d_p_d-d.parquet b/tables/scipy_special_tests/bdtri/In_d_p_d-d.parquet new file mode 100644 index 00000000..fb3268fc Binary files /dev/null and b/tables/scipy_special_tests/bdtri/In_d_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtri/Out_d_d_d-d.parquet b/tables/scipy_special_tests/bdtri/Out_d_d_d-d.parquet new file mode 100644 index 00000000..3d3becf2 Binary files /dev/null and b/tables/scipy_special_tests/bdtri/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/bdtri/Out_d_p_d-d.parquet b/tables/scipy_special_tests/bdtri/Out_d_p_d-d.parquet new file mode 100644 index 00000000..04fd644c Binary files /dev/null and b/tables/scipy_special_tests/bdtri/Out_d_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/bei/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/bei/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..bc54501f Binary files /dev/null and b/tables/scipy_special_tests/bei/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/bei/In_d-d.parquet b/tables/scipy_special_tests/bei/In_d-d.parquet new file mode 100644 index 00000000..2c64388f Binary files /dev/null and b/tables/scipy_special_tests/bei/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/bei/Out_d-d.parquet b/tables/scipy_special_tests/bei/Out_d-d.parquet new file mode 100644 index 00000000..285a3d7d Binary files /dev/null and b/tables/scipy_special_tests/bei/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/beip/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/beip/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..8eebd3d9 Binary files /dev/null and b/tables/scipy_special_tests/beip/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/beip/In_d-d.parquet b/tables/scipy_special_tests/beip/In_d-d.parquet new file mode 100644 index 00000000..5fe36007 Binary files /dev/null and b/tables/scipy_special_tests/beip/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/beip/Out_d-d.parquet b/tables/scipy_special_tests/beip/Out_d-d.parquet new file mode 100644 index 00000000..89b5b433 Binary files /dev/null and b/tables/scipy_special_tests/beip/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/ber/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ber/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a8d7e5cf Binary files /dev/null and b/tables/scipy_special_tests/ber/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ber/In_d-d.parquet b/tables/scipy_special_tests/ber/In_d-d.parquet new file mode 100644 index 00000000..b4bbc5aa Binary files /dev/null and b/tables/scipy_special_tests/ber/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ber/Out_d-d.parquet b/tables/scipy_special_tests/ber/Out_d-d.parquet new file mode 100644 index 00000000..8913be53 Binary files /dev/null and b/tables/scipy_special_tests/ber/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/berp/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/berp/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7c1239be Binary files /dev/null and b/tables/scipy_special_tests/berp/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/berp/In_d-d.parquet b/tables/scipy_special_tests/berp/In_d-d.parquet new file mode 100644 index 00000000..5beccf47 Binary files /dev/null and b/tables/scipy_special_tests/berp/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/berp/Out_d-d.parquet b/tables/scipy_special_tests/berp/Out_d-d.parquet new file mode 100644 index 00000000..46bd0994 Binary files /dev/null and b/tables/scipy_special_tests/berp/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/besselpoly/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/besselpoly/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..ae2f29ba Binary files /dev/null and b/tables/scipy_special_tests/besselpoly/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/besselpoly/In_d_d_d-d.parquet b/tables/scipy_special_tests/besselpoly/In_d_d_d-d.parquet new file mode 100644 index 00000000..251118d9 Binary files /dev/null and b/tables/scipy_special_tests/besselpoly/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/besselpoly/Out_d_d_d-d.parquet b/tables/scipy_special_tests/besselpoly/Out_d_d_d-d.parquet new file mode 100644 index 00000000..0ee9c446 Binary files /dev/null and b/tables/scipy_special_tests/besselpoly/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/beta/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/beta/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..e2e8785e Binary files /dev/null and b/tables/scipy_special_tests/beta/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/beta/In_d_d-d.parquet b/tables/scipy_special_tests/beta/In_d_d-d.parquet new file mode 100644 index 00000000..933abab3 Binary files /dev/null and b/tables/scipy_special_tests/beta/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/beta/Out_d_d-d.parquet b/tables/scipy_special_tests/beta/Out_d_d-d.parquet new file mode 100644 index 00000000..663c36a9 Binary files /dev/null and b/tables/scipy_special_tests/beta/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/betaln/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/betaln/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a13bb4be Binary files /dev/null and b/tables/scipy_special_tests/betaln/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/betaln/In_d_d-d.parquet b/tables/scipy_special_tests/betaln/In_d_d-d.parquet new file mode 100644 index 00000000..4970acbc Binary files /dev/null and b/tables/scipy_special_tests/betaln/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/betaln/Out_d_d-d.parquet b/tables/scipy_special_tests/betaln/Out_d_d-d.parquet new file mode 100644 index 00000000..17f70c51 Binary files /dev/null and b/tables/scipy_special_tests/betaln/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/binom/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/binom/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..66eb6d71 Binary files /dev/null and b/tables/scipy_special_tests/binom/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/binom/In_d_d-d.parquet b/tables/scipy_special_tests/binom/In_d_d-d.parquet new file mode 100644 index 00000000..916f3c27 Binary files /dev/null and b/tables/scipy_special_tests/binom/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/binom/Out_d_d-d.parquet b/tables/scipy_special_tests/binom/Out_d_d-d.parquet new file mode 100644 index 00000000..92307af0 Binary files /dev/null and b/tables/scipy_special_tests/binom/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cbrt/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cbrt/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..e3df8bba Binary files /dev/null and b/tables/scipy_special_tests/cbrt/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cbrt/In_d-d.parquet b/tables/scipy_special_tests/cbrt/In_d-d.parquet new file mode 100644 index 00000000..4d501a85 Binary files /dev/null and b/tables/scipy_special_tests/cbrt/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cbrt/Out_d-d.parquet b/tables/scipy_special_tests/cbrt/Out_d-d.parquet new file mode 100644 index 00000000..6678d54d Binary files /dev/null and b/tables/scipy_special_tests/cbrt/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cem/Err_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cem/Err_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..875d22c7 Binary files /dev/null and b/tables/scipy_special_tests/cem/Err_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cem/In_d_d_d-d_d.parquet b/tables/scipy_special_tests/cem/In_d_d_d-d_d.parquet new file mode 100644 index 00000000..53bac8e7 Binary files /dev/null and b/tables/scipy_special_tests/cem/In_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/cem/Out_d_d_d-d_d.parquet b/tables/scipy_special_tests/cem/Out_d_d_d-d_d.parquet new file mode 100644 index 00000000..33c8ef22 Binary files /dev/null and b/tables/scipy_special_tests/cem/Out_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/cem_cva/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cem_cva/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4517541d Binary files /dev/null and b/tables/scipy_special_tests/cem_cva/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cem_cva/In_d_d-d.parquet b/tables/scipy_special_tests/cem_cva/In_d_d-d.parquet new file mode 100644 index 00000000..93098e14 Binary files /dev/null and b/tables/scipy_special_tests/cem_cva/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cem_cva/Out_d_d-d.parquet b/tables/scipy_special_tests/cem_cva/Out_d_d-d.parquet new file mode 100644 index 00000000..9dd9eb71 Binary files /dev/null and b/tables/scipy_special_tests/cem_cva/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/chdtr/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/chdtr/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..74d820cf Binary files /dev/null and b/tables/scipy_special_tests/chdtr/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/chdtr/Err_f_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/chdtr/Err_f_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2b3caa1b Binary files /dev/null and b/tables/scipy_special_tests/chdtr/Err_f_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/chdtr/In_d_d-d.parquet b/tables/scipy_special_tests/chdtr/In_d_d-d.parquet new file mode 100644 index 00000000..8e38568c Binary files /dev/null and b/tables/scipy_special_tests/chdtr/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/chdtr/In_f_f-f.parquet b/tables/scipy_special_tests/chdtr/In_f_f-f.parquet new file mode 100644 index 00000000..44330412 Binary files /dev/null and b/tables/scipy_special_tests/chdtr/In_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/chdtr/Out_d_d-d.parquet b/tables/scipy_special_tests/chdtr/Out_d_d-d.parquet new file mode 100644 index 00000000..6e9658cf Binary files /dev/null and b/tables/scipy_special_tests/chdtr/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/chdtr/Out_f_f-f.parquet b/tables/scipy_special_tests/chdtr/Out_f_f-f.parquet new file mode 100644 index 00000000..9f6dc12d Binary files /dev/null and b/tables/scipy_special_tests/chdtr/Out_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/chdtrc/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/chdtrc/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..02702b68 Binary files /dev/null and b/tables/scipy_special_tests/chdtrc/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/chdtrc/Err_f_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/chdtrc/Err_f_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4dc1891c Binary files /dev/null and b/tables/scipy_special_tests/chdtrc/Err_f_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/chdtrc/In_d_d-d.parquet b/tables/scipy_special_tests/chdtrc/In_d_d-d.parquet new file mode 100644 index 00000000..d93e2975 Binary files /dev/null and b/tables/scipy_special_tests/chdtrc/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/chdtrc/In_f_f-f.parquet b/tables/scipy_special_tests/chdtrc/In_f_f-f.parquet new file mode 100644 index 00000000..8c4f5f20 Binary files /dev/null and b/tables/scipy_special_tests/chdtrc/In_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/chdtrc/Out_d_d-d.parquet b/tables/scipy_special_tests/chdtrc/Out_d_d-d.parquet new file mode 100644 index 00000000..3cbb9541 Binary files /dev/null and b/tables/scipy_special_tests/chdtrc/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/chdtrc/Out_f_f-f.parquet b/tables/scipy_special_tests/chdtrc/Out_f_f-f.parquet new file mode 100644 index 00000000..8080f5c9 Binary files /dev/null and b/tables/scipy_special_tests/chdtrc/Out_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/chdtri/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/chdtri/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d4628e23 Binary files /dev/null and b/tables/scipy_special_tests/chdtri/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/chdtri/In_d_d-d.parquet b/tables/scipy_special_tests/chdtri/In_d_d-d.parquet new file mode 100644 index 00000000..0c93bca9 Binary files /dev/null and b/tables/scipy_special_tests/chdtri/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/chdtri/Out_d_d-d.parquet b/tables/scipy_special_tests/chdtri/Out_d_d-d.parquet new file mode 100644 index 00000000..70c6a71d Binary files /dev/null and b/tables/scipy_special_tests/chdtri/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cosdg/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cosdg/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..828e77c1 Binary files /dev/null and b/tables/scipy_special_tests/cosdg/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cosdg/In_d-d.parquet b/tables/scipy_special_tests/cosdg/In_d-d.parquet new file mode 100644 index 00000000..9dbdb44d Binary files /dev/null and b/tables/scipy_special_tests/cosdg/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cosdg/Out_d-d.parquet b/tables/scipy_special_tests/cosdg/Out_d-d.parquet new file mode 100644 index 00000000..63e16ff3 Binary files /dev/null and b/tables/scipy_special_tests/cosdg/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cosm1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cosm1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4b6e56bf Binary files /dev/null and b/tables/scipy_special_tests/cosm1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cosm1/In_d-d.parquet b/tables/scipy_special_tests/cosm1/In_d-d.parquet new file mode 100644 index 00000000..4a08e971 Binary files /dev/null and b/tables/scipy_special_tests/cosm1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cosm1/Out_d-d.parquet b/tables/scipy_special_tests/cosm1/Out_d-d.parquet new file mode 100644 index 00000000..170ca1a7 Binary files /dev/null and b/tables/scipy_special_tests/cosm1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cospi/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cospi/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..e86cf157 Binary files /dev/null and b/tables/scipy_special_tests/cospi/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cospi/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cospi/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9ef7ec5a Binary files /dev/null and b/tables/scipy_special_tests/cospi/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cospi/In_cd-cd.parquet b/tables/scipy_special_tests/cospi/In_cd-cd.parquet new file mode 100644 index 00000000..3b83c010 Binary files /dev/null and b/tables/scipy_special_tests/cospi/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cospi/In_d-d.parquet b/tables/scipy_special_tests/cospi/In_d-d.parquet new file mode 100644 index 00000000..708ba74e Binary files /dev/null and b/tables/scipy_special_tests/cospi/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cospi/Out_cd-cd.parquet b/tables/scipy_special_tests/cospi/Out_cd-cd.parquet new file mode 100644 index 00000000..f8ff3ce9 Binary files /dev/null and b/tables/scipy_special_tests/cospi/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cospi/Out_d-d.parquet b/tables/scipy_special_tests/cospi/Out_d-d.parquet new file mode 100644 index 00000000..0687e131 Binary files /dev/null and b/tables/scipy_special_tests/cospi/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cotdg/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cotdg/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..81fb913c Binary files /dev/null and b/tables/scipy_special_tests/cotdg/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cotdg/In_d-d.parquet b/tables/scipy_special_tests/cotdg/In_d-d.parquet new file mode 100644 index 00000000..49cc2ee0 Binary files /dev/null and b/tables/scipy_special_tests/cotdg/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cotdg/Out_d-d.parquet b/tables/scipy_special_tests/cotdg/Out_d-d.parquet new file mode 100644 index 00000000..62ae6e3a Binary files /dev/null and b/tables/scipy_special_tests/cotdg/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..00077af4 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5c3d6e4e Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_i/In_d_cd-cd.parquet new file mode 100644 index 00000000..58f4ad4a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i/In_d_d-d.parquet new file mode 100644 index 00000000..5522a462 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_i/Out_d_cd-cd.parquet new file mode 100644 index 00000000..0701ebd3 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i/Out_d_d-d.parquet new file mode 100644 index 00000000..c49c1e85 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..bab9caa8 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i0/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..6b017091 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i0/In_d-d.parquet new file mode 100644 index 00000000..ca3f1e90 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0/In_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i0/In_f-f.parquet new file mode 100644 index 00000000..ce684fc2 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i0/Out_d-d.parquet new file mode 100644 index 00000000..725f98ac Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0/Out_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i0/Out_f-f.parquet new file mode 100644 index 00000000..85579f4a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0e/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i0e/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..70ac50ff Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0e/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0e/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i0e/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..24fd7b41 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0e/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0e/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i0e/In_d-d.parquet new file mode 100644 index 00000000..b3c90691 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0e/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0e/In_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i0e/In_f-f.parquet new file mode 100644 index 00000000..1bf63eb8 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0e/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0e/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i0e/Out_d-d.parquet new file mode 100644 index 00000000..a6c009c4 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0e/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i0e/Out_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i0e/Out_f-f.parquet new file mode 100644 index 00000000..ee541fcc Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i0e/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fbd10a8f Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i1/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b23d720c Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i1/In_d-d.parquet new file mode 100644 index 00000000..3f9ee994 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1/In_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i1/In_f-f.parquet new file mode 100644 index 00000000..15b6ceaf Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i1/Out_d-d.parquet new file mode 100644 index 00000000..2a952ea8 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1/Out_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i1/Out_f-f.parquet new file mode 100644 index 00000000..01098965 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1e/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i1e/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..86c67d14 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1e/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1e/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_i1e/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..65fb4bfe Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1e/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1e/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i1e/In_d-d.parquet new file mode 100644 index 00000000..4d2c3446 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1e/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1e/In_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i1e/In_f-f.parquet new file mode 100644 index 00000000..6eebd0d6 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1e/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1e/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_i1e/Out_d-d.parquet new file mode 100644 index 00000000..d060a058 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1e/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_i1e/Out_f-f.parquet b/tables/scipy_special_tests/cyl_bessel_i1e/Out_f-f.parquet new file mode 100644 index 00000000..b4388869 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_i1e/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ie/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_ie/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7aeb9495 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ie/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ie/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_ie/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..04fe65a1 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ie/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ie/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_ie/In_d_cd-cd.parquet new file mode 100644 index 00000000..b38fcb56 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ie/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ie/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_ie/In_d_d-d.parquet new file mode 100644 index 00000000..111343d4 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ie/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ie/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_ie/Out_d_cd-cd.parquet new file mode 100644 index 00000000..e10d4a29 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ie/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ie/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_ie/Out_d_d-d.parquet new file mode 100644 index 00000000..8e265ceb Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ie/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_j/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..42ed519c Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_j/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..50454f15 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_j/In_d_cd-cd.parquet new file mode 100644 index 00000000..c1ee3a52 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_j/In_d_d-d.parquet new file mode 100644 index 00000000..d6d042d7 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_j/Out_d_cd-cd.parquet new file mode 100644 index 00000000..51bd8b6b Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_j/Out_d_d-d.parquet new file mode 100644 index 00000000..e6ff6549 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_j0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a96469c6 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j0/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_j0/In_d-d.parquet new file mode 100644 index 00000000..1b2e6203 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j0/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_j0/Out_d-d.parquet new file mode 100644 index 00000000..a507f42d Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_j1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..ab2272eb Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j1/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_j1/In_d-d.parquet new file mode 100644 index 00000000..b3b949ad Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_j1/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_j1/Out_d-d.parquet new file mode 100644 index 00000000..a9a0977d Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_j1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_je/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_je/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..8b630543 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_je/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_je/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_je/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..db018963 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_je/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_je/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_je/In_d_cd-cd.parquet new file mode 100644 index 00000000..f72bfa44 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_je/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_je/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_je/In_d_d-d.parquet new file mode 100644 index 00000000..c2680f48 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_je/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_je/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_je/Out_d_cd-cd.parquet new file mode 100644 index 00000000..82f8333b Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_je/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_je/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_je/Out_d_d-d.parquet new file mode 100644 index 00000000..8aa8ee8c Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_je/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_k/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c2e795f0 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_k/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5c1c4de9 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_k/In_d_cd-cd.parquet new file mode 100644 index 00000000..9eccdb5a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k/In_d_d-d.parquet new file mode 100644 index 00000000..aca0a413 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_k/Out_d_cd-cd.parquet new file mode 100644 index 00000000..65c0a5a8 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k/Out_d_d-d.parquet new file mode 100644 index 00000000..8213e2f7 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_k0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..e953b7b5 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k0/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k0/In_d-d.parquet new file mode 100644 index 00000000..adf7635a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k0/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k0/Out_d-d.parquet new file mode 100644 index 00000000..f174c7c3 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k0e/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_k0e/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fe2f868f Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k0e/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k0e/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k0e/In_d-d.parquet new file mode 100644 index 00000000..07b013cf Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k0e/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k0e/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k0e/Out_d-d.parquet new file mode 100644 index 00000000..2b48a0fd Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k0e/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_k1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..de4d252e Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k1/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k1/In_d-d.parquet new file mode 100644 index 00000000..e0edb41a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k1/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k1/Out_d-d.parquet new file mode 100644 index 00000000..4b1c3d95 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k1e/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_k1e/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..04bb2100 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k1e/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k1e/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k1e/In_d-d.parquet new file mode 100644 index 00000000..12b162c5 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k1e/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_k1e/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_k1e/Out_d-d.parquet new file mode 100644 index 00000000..29e654c3 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_k1e/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ke/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_ke/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d5d7834b Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ke/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ke/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_ke/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..22801958 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ke/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ke/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_ke/In_d_cd-cd.parquet new file mode 100644 index 00000000..712b57d5 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ke/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ke/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_ke/In_d_d-d.parquet new file mode 100644 index 00000000..4438874b Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ke/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ke/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_ke/Out_d_cd-cd.parquet new file mode 100644 index 00000000..3c4ca67c Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ke/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ke/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_ke/Out_d_d-d.parquet new file mode 100644 index 00000000..e193812a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ke/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_y/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..420e1bf9 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_y/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f7c543da Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_y/In_d_cd-cd.parquet new file mode 100644 index 00000000..88d970f5 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_y/In_d_d-d.parquet new file mode 100644 index 00000000..e713930a Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_y/Out_d_cd-cd.parquet new file mode 100644 index 00000000..bef1a6c6 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_y/Out_d_d-d.parquet new file mode 100644 index 00000000..d9ad4b27 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_y0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..1828620f Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y0/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_y0/In_d-d.parquet new file mode 100644 index 00000000..e7171ef9 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y0/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_y0/Out_d-d.parquet new file mode 100644 index 00000000..ad650630 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_y1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b8154c22 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y1/In_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_y1/In_d-d.parquet new file mode 100644 index 00000000..cd4e4b28 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_y1/Out_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_y1/Out_d-d.parquet new file mode 100644 index 00000000..2582b37e Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_y1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ye/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_ye/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7aa627cd Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ye/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ye/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_bessel_ye/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..3f8e3e70 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ye/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ye/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_ye/In_d_cd-cd.parquet new file mode 100644 index 00000000..79419ffe Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ye/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ye/In_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_ye/In_d_d-d.parquet new file mode 100644 index 00000000..757a61f1 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ye/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ye/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_bessel_ye/Out_d_cd-cd.parquet new file mode 100644 index 00000000..94d66b07 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ye/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_bessel_ye/Out_d_d-d.parquet b/tables/scipy_special_tests/cyl_bessel_ye/Out_d_d-d.parquet new file mode 100644 index 00000000..dd8ae2d3 Binary files /dev/null and b/tables/scipy_special_tests/cyl_bessel_ye/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_1/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_hankel_1/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0ff17ccc Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_1/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_1/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_1/In_d_cd-cd.parquet new file mode 100644 index 00000000..fa78dc16 Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_1/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_1/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_1/Out_d_cd-cd.parquet new file mode 100644 index 00000000..979dfb31 Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_1/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_1e/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_hankel_1e/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..6618cbdf Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_1e/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_1e/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_1e/In_d_cd-cd.parquet new file mode 100644 index 00000000..10c81cfb Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_1e/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_1e/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_1e/Out_d_cd-cd.parquet new file mode 100644 index 00000000..f6f39ed5 Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_1e/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_2/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_hankel_2/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..e16ca733 Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_2/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_2/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_2/In_d_cd-cd.parquet new file mode 100644 index 00000000..01df150b Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_2/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_2/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_2/Out_d_cd-cd.parquet new file mode 100644 index 00000000..39d3e6e6 Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_2/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_2e/Err_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/cyl_hankel_2e/Err_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fb64270c Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_2e/Err_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_2e/In_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_2e/In_d_cd-cd.parquet new file mode 100644 index 00000000..db85ebf6 Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_2e/In_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/cyl_hankel_2e/Out_d_cd-cd.parquet b/tables/scipy_special_tests/cyl_hankel_2e/Out_d_cd-cd.parquet new file mode 100644 index 00000000..eaa9288b Binary files /dev/null and b/tables/scipy_special_tests/cyl_hankel_2e/Out_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/dawsn/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/dawsn/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..774f5b7f Binary files /dev/null and b/tables/scipy_special_tests/dawsn/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/dawsn/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/dawsn/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..1d9096e3 Binary files /dev/null and b/tables/scipy_special_tests/dawsn/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/dawsn/In_cd-cd.parquet b/tables/scipy_special_tests/dawsn/In_cd-cd.parquet new file mode 100644 index 00000000..ad607cf3 Binary files /dev/null and b/tables/scipy_special_tests/dawsn/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/dawsn/In_d-d.parquet b/tables/scipy_special_tests/dawsn/In_d-d.parquet new file mode 100644 index 00000000..2235e476 Binary files /dev/null and b/tables/scipy_special_tests/dawsn/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/dawsn/Out_cd-cd.parquet b/tables/scipy_special_tests/dawsn/Out_cd-cd.parquet new file mode 100644 index 00000000..5de9fd2e Binary files /dev/null and b/tables/scipy_special_tests/dawsn/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/dawsn/Out_d-d.parquet b/tables/scipy_special_tests/dawsn/Out_d-d.parquet new file mode 100644 index 00000000..f6422054 Binary files /dev/null and b/tables/scipy_special_tests/dawsn/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/digamma/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/digamma/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7303cece Binary files /dev/null and b/tables/scipy_special_tests/digamma/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/digamma/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/digamma/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..13ec63d7 Binary files /dev/null and b/tables/scipy_special_tests/digamma/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/digamma/In_cd-cd.parquet b/tables/scipy_special_tests/digamma/In_cd-cd.parquet new file mode 100644 index 00000000..a03d4671 Binary files /dev/null and b/tables/scipy_special_tests/digamma/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/digamma/In_d-d.parquet b/tables/scipy_special_tests/digamma/In_d-d.parquet new file mode 100644 index 00000000..630b7fda Binary files /dev/null and b/tables/scipy_special_tests/digamma/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/digamma/Out_cd-cd.parquet b/tables/scipy_special_tests/digamma/Out_cd-cd.parquet new file mode 100644 index 00000000..b92750ee Binary files /dev/null and b/tables/scipy_special_tests/digamma/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/digamma/Out_d-d.parquet b/tables/scipy_special_tests/digamma/Out_d-d.parquet new file mode 100644 index 00000000..5bce55a5 Binary files /dev/null and b/tables/scipy_special_tests/digamma/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipe/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ellipe/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..207daadd Binary files /dev/null and b/tables/scipy_special_tests/ellipe/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ellipe/In_d-d.parquet b/tables/scipy_special_tests/ellipe/In_d-d.parquet new file mode 100644 index 00000000..702cfcc2 Binary files /dev/null and b/tables/scipy_special_tests/ellipe/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipe/Out_d-d.parquet b/tables/scipy_special_tests/ellipe/Out_d-d.parquet new file mode 100644 index 00000000..0afc947a Binary files /dev/null and b/tables/scipy_special_tests/ellipe/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipeinc/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ellipeinc/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a3a3f5a2 Binary files /dev/null and b/tables/scipy_special_tests/ellipeinc/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ellipeinc/In_d_d-d.parquet b/tables/scipy_special_tests/ellipeinc/In_d_d-d.parquet new file mode 100644 index 00000000..52abd296 Binary files /dev/null and b/tables/scipy_special_tests/ellipeinc/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipeinc/Out_d_d-d.parquet b/tables/scipy_special_tests/ellipeinc/Out_d_d-d.parquet new file mode 100644 index 00000000..a842f2a3 Binary files /dev/null and b/tables/scipy_special_tests/ellipeinc/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipj/Err_d_d-d_d_d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ellipj/Err_d_d-d_d_d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..22acd831 Binary files /dev/null and b/tables/scipy_special_tests/ellipj/Err_d_d-d_d_d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ellipj/In_d_d-d_d_d_d.parquet b/tables/scipy_special_tests/ellipj/In_d_d-d_d_d_d.parquet new file mode 100644 index 00000000..8186ca3e Binary files /dev/null and b/tables/scipy_special_tests/ellipj/In_d_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/ellipj/Out_d_d-d_d_d_d.parquet b/tables/scipy_special_tests/ellipj/Out_d_d-d_d_d_d.parquet new file mode 100644 index 00000000..413c5afb Binary files /dev/null and b/tables/scipy_special_tests/ellipj/Out_d_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/ellipk/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ellipk/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..974c81a4 Binary files /dev/null and b/tables/scipy_special_tests/ellipk/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ellipk/In_d-d.parquet b/tables/scipy_special_tests/ellipk/In_d-d.parquet new file mode 100644 index 00000000..1949f96d Binary files /dev/null and b/tables/scipy_special_tests/ellipk/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipk/Out_d-d.parquet b/tables/scipy_special_tests/ellipk/Out_d-d.parquet new file mode 100644 index 00000000..9db46412 Binary files /dev/null and b/tables/scipy_special_tests/ellipk/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipkinc/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ellipkinc/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7e701901 Binary files /dev/null and b/tables/scipy_special_tests/ellipkinc/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ellipkinc/In_d_d-d.parquet b/tables/scipy_special_tests/ellipkinc/In_d_d-d.parquet new file mode 100644 index 00000000..fc5ca00f Binary files /dev/null and b/tables/scipy_special_tests/ellipkinc/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipkinc/Out_d_d-d.parquet b/tables/scipy_special_tests/ellipkinc/Out_d_d-d.parquet new file mode 100644 index 00000000..f72eea9c Binary files /dev/null and b/tables/scipy_special_tests/ellipkinc/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipkm1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ellipkm1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9db0081a Binary files /dev/null and b/tables/scipy_special_tests/ellipkm1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ellipkm1/In_d-d.parquet b/tables/scipy_special_tests/ellipkm1/In_d-d.parquet new file mode 100644 index 00000000..ded1d217 Binary files /dev/null and b/tables/scipy_special_tests/ellipkm1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ellipkm1/Out_d-d.parquet b/tables/scipy_special_tests/ellipkm1/Out_d-d.parquet new file mode 100644 index 00000000..48696fb3 Binary files /dev/null and b/tables/scipy_special_tests/ellipkm1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/erf/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erf/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..13594b79 Binary files /dev/null and b/tables/scipy_special_tests/erf/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erf/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erf/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2d430831 Binary files /dev/null and b/tables/scipy_special_tests/erf/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erf/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erf/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9554dcb9 Binary files /dev/null and b/tables/scipy_special_tests/erf/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erf/In_cd-cd.parquet b/tables/scipy_special_tests/erf/In_cd-cd.parquet new file mode 100644 index 00000000..222d3e9f Binary files /dev/null and b/tables/scipy_special_tests/erf/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erf/In_d-d.parquet b/tables/scipy_special_tests/erf/In_d-d.parquet new file mode 100644 index 00000000..c08cfab0 Binary files /dev/null and b/tables/scipy_special_tests/erf/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/erf/In_f-f.parquet b/tables/scipy_special_tests/erf/In_f-f.parquet new file mode 100644 index 00000000..618f90e5 Binary files /dev/null and b/tables/scipy_special_tests/erf/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/erf/Out_cd-cd.parquet b/tables/scipy_special_tests/erf/Out_cd-cd.parquet new file mode 100644 index 00000000..d8dab0bd Binary files /dev/null and b/tables/scipy_special_tests/erf/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erf/Out_d-d.parquet b/tables/scipy_special_tests/erf/Out_d-d.parquet new file mode 100644 index 00000000..0b038e84 Binary files /dev/null and b/tables/scipy_special_tests/erf/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/erf/Out_f-f.parquet b/tables/scipy_special_tests/erf/Out_f-f.parquet new file mode 100644 index 00000000..4cfb6e69 Binary files /dev/null and b/tables/scipy_special_tests/erf/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/erfc/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfc/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..6bdee260 Binary files /dev/null and b/tables/scipy_special_tests/erfc/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfc/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfc/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..669a69b7 Binary files /dev/null and b/tables/scipy_special_tests/erfc/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfc/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfc/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..932a593c Binary files /dev/null and b/tables/scipy_special_tests/erfc/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfc/In_cd-cd.parquet b/tables/scipy_special_tests/erfc/In_cd-cd.parquet new file mode 100644 index 00000000..07130a21 Binary files /dev/null and b/tables/scipy_special_tests/erfc/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erfc/In_d-d.parquet b/tables/scipy_special_tests/erfc/In_d-d.parquet new file mode 100644 index 00000000..b3f80135 Binary files /dev/null and b/tables/scipy_special_tests/erfc/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfc/In_f-f.parquet b/tables/scipy_special_tests/erfc/In_f-f.parquet new file mode 100644 index 00000000..323eee51 Binary files /dev/null and b/tables/scipy_special_tests/erfc/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/erfc/Out_cd-cd.parquet b/tables/scipy_special_tests/erfc/Out_cd-cd.parquet new file mode 100644 index 00000000..e9a1ed82 Binary files /dev/null and b/tables/scipy_special_tests/erfc/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erfc/Out_d-d.parquet b/tables/scipy_special_tests/erfc/Out_d-d.parquet new file mode 100644 index 00000000..90318dc2 Binary files /dev/null and b/tables/scipy_special_tests/erfc/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfc/Out_f-f.parquet b/tables/scipy_special_tests/erfc/Out_f-f.parquet new file mode 100644 index 00000000..3505b991 Binary files /dev/null and b/tables/scipy_special_tests/erfc/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/erfcinv/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfcinv/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..3afec454 Binary files /dev/null and b/tables/scipy_special_tests/erfcinv/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfcinv/In_d-d.parquet b/tables/scipy_special_tests/erfcinv/In_d-d.parquet new file mode 100644 index 00000000..ea96e673 Binary files /dev/null and b/tables/scipy_special_tests/erfcinv/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfcinv/Out_d-d.parquet b/tables/scipy_special_tests/erfcinv/Out_d-d.parquet new file mode 100644 index 00000000..6455c579 Binary files /dev/null and b/tables/scipy_special_tests/erfcinv/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfcx/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfcx/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..39b25314 Binary files /dev/null and b/tables/scipy_special_tests/erfcx/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfcx/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfcx/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..853c61fc Binary files /dev/null and b/tables/scipy_special_tests/erfcx/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfcx/In_cd-cd.parquet b/tables/scipy_special_tests/erfcx/In_cd-cd.parquet new file mode 100644 index 00000000..b7652d5d Binary files /dev/null and b/tables/scipy_special_tests/erfcx/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erfcx/In_d-d.parquet b/tables/scipy_special_tests/erfcx/In_d-d.parquet new file mode 100644 index 00000000..2d7e9b0a Binary files /dev/null and b/tables/scipy_special_tests/erfcx/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfcx/Out_cd-cd.parquet b/tables/scipy_special_tests/erfcx/Out_cd-cd.parquet new file mode 100644 index 00000000..83b7c115 Binary files /dev/null and b/tables/scipy_special_tests/erfcx/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erfcx/Out_d-d.parquet b/tables/scipy_special_tests/erfcx/Out_d-d.parquet new file mode 100644 index 00000000..3a1e150b Binary files /dev/null and b/tables/scipy_special_tests/erfcx/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfi/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfi/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2615b8aa Binary files /dev/null and b/tables/scipy_special_tests/erfi/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfi/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/erfi/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..696962a7 Binary files /dev/null and b/tables/scipy_special_tests/erfi/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/erfi/In_cd-cd.parquet b/tables/scipy_special_tests/erfi/In_cd-cd.parquet new file mode 100644 index 00000000..67b88938 Binary files /dev/null and b/tables/scipy_special_tests/erfi/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erfi/In_d-d.parquet b/tables/scipy_special_tests/erfi/In_d-d.parquet new file mode 100644 index 00000000..5bbf9970 Binary files /dev/null and b/tables/scipy_special_tests/erfi/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/erfi/Out_cd-cd.parquet b/tables/scipy_special_tests/erfi/Out_cd-cd.parquet new file mode 100644 index 00000000..71f0d150 Binary files /dev/null and b/tables/scipy_special_tests/erfi/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/erfi/Out_d-d.parquet b/tables/scipy_special_tests/erfi/Out_d-d.parquet new file mode 100644 index 00000000..2ecc21be Binary files /dev/null and b/tables/scipy_special_tests/erfi/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/exp1/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/exp1/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d7e5f26e Binary files /dev/null and b/tables/scipy_special_tests/exp1/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/exp1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/exp1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..8f531d23 Binary files /dev/null and b/tables/scipy_special_tests/exp1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/exp1/In_cd-cd.parquet b/tables/scipy_special_tests/exp1/In_cd-cd.parquet new file mode 100644 index 00000000..b4a9721f Binary files /dev/null and b/tables/scipy_special_tests/exp1/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/exp1/In_d-d.parquet b/tables/scipy_special_tests/exp1/In_d-d.parquet new file mode 100644 index 00000000..b7f8d364 Binary files /dev/null and b/tables/scipy_special_tests/exp1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/exp1/Out_cd-cd.parquet b/tables/scipy_special_tests/exp1/Out_cd-cd.parquet new file mode 100644 index 00000000..da05254c Binary files /dev/null and b/tables/scipy_special_tests/exp1/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/exp1/Out_d-d.parquet b/tables/scipy_special_tests/exp1/Out_d-d.parquet new file mode 100644 index 00000000..557947d0 Binary files /dev/null and b/tables/scipy_special_tests/exp1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/exp10/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/exp10/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..3d4c5484 Binary files /dev/null and b/tables/scipy_special_tests/exp10/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/exp10/In_d-d.parquet b/tables/scipy_special_tests/exp10/In_d-d.parquet new file mode 100644 index 00000000..4576255d Binary files /dev/null and b/tables/scipy_special_tests/exp10/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/exp10/Out_d-d.parquet b/tables/scipy_special_tests/exp10/Out_d-d.parquet new file mode 100644 index 00000000..c7dbe271 Binary files /dev/null and b/tables/scipy_special_tests/exp10/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/exp2/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/exp2/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4016c18a Binary files /dev/null and b/tables/scipy_special_tests/exp2/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/exp2/In_d-d.parquet b/tables/scipy_special_tests/exp2/In_d-d.parquet new file mode 100644 index 00000000..6a9d79e0 Binary files /dev/null and b/tables/scipy_special_tests/exp2/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/exp2/Out_d-d.parquet b/tables/scipy_special_tests/exp2/Out_d-d.parquet new file mode 100644 index 00000000..9bef80d4 Binary files /dev/null and b/tables/scipy_special_tests/exp2/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/expi/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expi/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..10737ff3 Binary files /dev/null and b/tables/scipy_special_tests/expi/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expi/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expi/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a8c9bdf0 Binary files /dev/null and b/tables/scipy_special_tests/expi/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expi/In_cd-cd.parquet b/tables/scipy_special_tests/expi/In_cd-cd.parquet new file mode 100644 index 00000000..0e8ab621 Binary files /dev/null and b/tables/scipy_special_tests/expi/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/expi/In_d-d.parquet b/tables/scipy_special_tests/expi/In_d-d.parquet new file mode 100644 index 00000000..ef39fa2f Binary files /dev/null and b/tables/scipy_special_tests/expi/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/expi/Out_cd-cd.parquet b/tables/scipy_special_tests/expi/Out_cd-cd.parquet new file mode 100644 index 00000000..a4ae726f Binary files /dev/null and b/tables/scipy_special_tests/expi/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/expi/Out_d-d.parquet b/tables/scipy_special_tests/expi/Out_d-d.parquet new file mode 100644 index 00000000..6676a94f Binary files /dev/null and b/tables/scipy_special_tests/expi/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/expit/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expit/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..90de00bc Binary files /dev/null and b/tables/scipy_special_tests/expit/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expit/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expit/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..66b6fe48 Binary files /dev/null and b/tables/scipy_special_tests/expit/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expit/In_d-d.parquet b/tables/scipy_special_tests/expit/In_d-d.parquet new file mode 100644 index 00000000..8193426c Binary files /dev/null and b/tables/scipy_special_tests/expit/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/expit/In_f-f.parquet b/tables/scipy_special_tests/expit/In_f-f.parquet new file mode 100644 index 00000000..d2a945cd Binary files /dev/null and b/tables/scipy_special_tests/expit/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/expit/Out_d-d.parquet b/tables/scipy_special_tests/expit/Out_d-d.parquet new file mode 100644 index 00000000..07f4800a Binary files /dev/null and b/tables/scipy_special_tests/expit/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/expit/Out_f-f.parquet b/tables/scipy_special_tests/expit/Out_f-f.parquet new file mode 100644 index 00000000..ed4ae3cf Binary files /dev/null and b/tables/scipy_special_tests/expit/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/expm1/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expm1/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..efa3030f Binary files /dev/null and b/tables/scipy_special_tests/expm1/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expm1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expm1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..57c9b03a Binary files /dev/null and b/tables/scipy_special_tests/expm1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expm1/In_cd-cd.parquet b/tables/scipy_special_tests/expm1/In_cd-cd.parquet new file mode 100644 index 00000000..27891058 Binary files /dev/null and b/tables/scipy_special_tests/expm1/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/expm1/In_d-d.parquet b/tables/scipy_special_tests/expm1/In_d-d.parquet new file mode 100644 index 00000000..5ec03ef5 Binary files /dev/null and b/tables/scipy_special_tests/expm1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/expm1/Out_cd-cd.parquet b/tables/scipy_special_tests/expm1/Out_cd-cd.parquet new file mode 100644 index 00000000..65038f2a Binary files /dev/null and b/tables/scipy_special_tests/expm1/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/expm1/Out_d-d.parquet b/tables/scipy_special_tests/expm1/Out_d-d.parquet new file mode 100644 index 00000000..1212b486 Binary files /dev/null and b/tables/scipy_special_tests/expm1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/expn/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expn/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..eb4ef0a5 Binary files /dev/null and b/tables/scipy_special_tests/expn/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expn/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/expn/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f1f87a64 Binary files /dev/null and b/tables/scipy_special_tests/expn/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/expn/In_d_d-d.parquet b/tables/scipy_special_tests/expn/In_d_d-d.parquet new file mode 100644 index 00000000..3ce40f6c Binary files /dev/null and b/tables/scipy_special_tests/expn/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/expn/In_p_d-d.parquet b/tables/scipy_special_tests/expn/In_p_d-d.parquet new file mode 100644 index 00000000..b104b25a Binary files /dev/null and b/tables/scipy_special_tests/expn/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/expn/Out_d_d-d.parquet b/tables/scipy_special_tests/expn/Out_d_d-d.parquet new file mode 100644 index 00000000..8607d26d Binary files /dev/null and b/tables/scipy_special_tests/expn/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/expn/Out_p_d-d.parquet b/tables/scipy_special_tests/expn/Out_p_d-d.parquet new file mode 100644 index 00000000..3a1da335 Binary files /dev/null and b/tables/scipy_special_tests/expn/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/exprel/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/exprel/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..1f90cc70 Binary files /dev/null and b/tables/scipy_special_tests/exprel/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/exprel/In_d-d.parquet b/tables/scipy_special_tests/exprel/In_d-d.parquet new file mode 100644 index 00000000..e7cc7bfb Binary files /dev/null and b/tables/scipy_special_tests/exprel/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/exprel/Out_d-d.parquet b/tables/scipy_special_tests/exprel/Out_d-d.parquet new file mode 100644 index 00000000..194cb9ed Binary files /dev/null and b/tables/scipy_special_tests/exprel/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/fdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/fdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d0b7aae2 Binary files /dev/null and b/tables/scipy_special_tests/fdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/fdtr/In_d_d_d-d.parquet b/tables/scipy_special_tests/fdtr/In_d_d_d-d.parquet new file mode 100644 index 00000000..44c8991c Binary files /dev/null and b/tables/scipy_special_tests/fdtr/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/fdtr/Out_d_d_d-d.parquet b/tables/scipy_special_tests/fdtr/Out_d_d_d-d.parquet new file mode 100644 index 00000000..8f79edf4 Binary files /dev/null and b/tables/scipy_special_tests/fdtr/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/fdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/fdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4d015cb9 Binary files /dev/null and b/tables/scipy_special_tests/fdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/fdtrc/In_d_d_d-d.parquet b/tables/scipy_special_tests/fdtrc/In_d_d_d-d.parquet new file mode 100644 index 00000000..8fe23b1d Binary files /dev/null and b/tables/scipy_special_tests/fdtrc/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/fdtrc/Out_d_d_d-d.parquet b/tables/scipy_special_tests/fdtrc/Out_d_d_d-d.parquet new file mode 100644 index 00000000..8bb18c87 Binary files /dev/null and b/tables/scipy_special_tests/fdtrc/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/fdtri/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/fdtri/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..88669c21 Binary files /dev/null and b/tables/scipy_special_tests/fdtri/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/fdtri/In_d_d_d-d.parquet b/tables/scipy_special_tests/fdtri/In_d_d_d-d.parquet new file mode 100644 index 00000000..94c5eb7b Binary files /dev/null and b/tables/scipy_special_tests/fdtri/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/fdtri/Out_d_d_d-d.parquet b/tables/scipy_special_tests/fdtri/Out_d_d_d-d.parquet new file mode 100644 index 00000000..bd9221b7 Binary files /dev/null and b/tables/scipy_special_tests/fdtri/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/fresnel/Err_cd-cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/fresnel/Err_cd-cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..76d1b617 Binary files /dev/null and b/tables/scipy_special_tests/fresnel/Err_cd-cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/fresnel/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/fresnel/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..85018d9c Binary files /dev/null and b/tables/scipy_special_tests/fresnel/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/fresnel/In_cd-cd_cd.parquet b/tables/scipy_special_tests/fresnel/In_cd-cd_cd.parquet new file mode 100644 index 00000000..30438f7d Binary files /dev/null and b/tables/scipy_special_tests/fresnel/In_cd-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/fresnel/In_d-d_d.parquet b/tables/scipy_special_tests/fresnel/In_d-d_d.parquet new file mode 100644 index 00000000..876cd778 Binary files /dev/null and b/tables/scipy_special_tests/fresnel/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/fresnel/Out_cd-cd_cd.parquet b/tables/scipy_special_tests/fresnel/Out_cd-cd_cd.parquet new file mode 100644 index 00000000..ec3b9783 Binary files /dev/null and b/tables/scipy_special_tests/fresnel/Out_cd-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/fresnel/Out_d-d_d.parquet b/tables/scipy_special_tests/fresnel/Out_d-d_d.parquet new file mode 100644 index 00000000..0390622a Binary files /dev/null and b/tables/scipy_special_tests/fresnel/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/gamma/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gamma/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..69dea0db Binary files /dev/null and b/tables/scipy_special_tests/gamma/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gamma/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gamma/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9392daba Binary files /dev/null and b/tables/scipy_special_tests/gamma/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gamma/In_cd-cd.parquet b/tables/scipy_special_tests/gamma/In_cd-cd.parquet new file mode 100644 index 00000000..f7b6a26d Binary files /dev/null and b/tables/scipy_special_tests/gamma/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/gamma/In_d-d.parquet b/tables/scipy_special_tests/gamma/In_d-d.parquet new file mode 100644 index 00000000..1a98cbf4 Binary files /dev/null and b/tables/scipy_special_tests/gamma/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/gamma/Out_cd-cd.parquet b/tables/scipy_special_tests/gamma/Out_cd-cd.parquet new file mode 100644 index 00000000..1e12a64f Binary files /dev/null and b/tables/scipy_special_tests/gamma/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/gamma/Out_d-d.parquet b/tables/scipy_special_tests/gamma/Out_d-d.parquet new file mode 100644 index 00000000..9438d4a6 Binary files /dev/null and b/tables/scipy_special_tests/gamma/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammainc/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammainc/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..419a17a7 Binary files /dev/null and b/tables/scipy_special_tests/gammainc/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammainc/Err_f_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammainc/Err_f_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..301009d7 Binary files /dev/null and b/tables/scipy_special_tests/gammainc/Err_f_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammainc/In_d_d-d.parquet b/tables/scipy_special_tests/gammainc/In_d_d-d.parquet new file mode 100644 index 00000000..ae84a407 Binary files /dev/null and b/tables/scipy_special_tests/gammainc/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammainc/In_f_f-f.parquet b/tables/scipy_special_tests/gammainc/In_f_f-f.parquet new file mode 100644 index 00000000..9f0b528a Binary files /dev/null and b/tables/scipy_special_tests/gammainc/In_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/gammainc/Out_d_d-d.parquet b/tables/scipy_special_tests/gammainc/Out_d_d-d.parquet new file mode 100644 index 00000000..0ea8d32b Binary files /dev/null and b/tables/scipy_special_tests/gammainc/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammainc/Out_f_f-f.parquet b/tables/scipy_special_tests/gammainc/Out_f_f-f.parquet new file mode 100644 index 00000000..a8ed414a Binary files /dev/null and b/tables/scipy_special_tests/gammainc/Out_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/gammaincc/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammaincc/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f2ee6bac Binary files /dev/null and b/tables/scipy_special_tests/gammaincc/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammaincc/Err_f_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammaincc/Err_f_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..84f1272f Binary files /dev/null and b/tables/scipy_special_tests/gammaincc/Err_f_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammaincc/In_d_d-d.parquet b/tables/scipy_special_tests/gammaincc/In_d_d-d.parquet new file mode 100644 index 00000000..6233c4f4 Binary files /dev/null and b/tables/scipy_special_tests/gammaincc/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaincc/In_f_f-f.parquet b/tables/scipy_special_tests/gammaincc/In_f_f-f.parquet new file mode 100644 index 00000000..30118fe3 Binary files /dev/null and b/tables/scipy_special_tests/gammaincc/In_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/gammaincc/Out_d_d-d.parquet b/tables/scipy_special_tests/gammaincc/Out_d_d-d.parquet new file mode 100644 index 00000000..c353437d Binary files /dev/null and b/tables/scipy_special_tests/gammaincc/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaincc/Out_f_f-f.parquet b/tables/scipy_special_tests/gammaincc/Out_f_f-f.parquet new file mode 100644 index 00000000..c833c058 Binary files /dev/null and b/tables/scipy_special_tests/gammaincc/Out_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/gammainccinv/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammainccinv/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..11952b14 Binary files /dev/null and b/tables/scipy_special_tests/gammainccinv/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammainccinv/In_d_d-d.parquet b/tables/scipy_special_tests/gammainccinv/In_d_d-d.parquet new file mode 100644 index 00000000..36750280 Binary files /dev/null and b/tables/scipy_special_tests/gammainccinv/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammainccinv/Out_d_d-d.parquet b/tables/scipy_special_tests/gammainccinv/Out_d_d-d.parquet new file mode 100644 index 00000000..9c092bbb Binary files /dev/null and b/tables/scipy_special_tests/gammainccinv/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaincinv/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammaincinv/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..3dfd24cb Binary files /dev/null and b/tables/scipy_special_tests/gammaincinv/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammaincinv/In_d_d-d.parquet b/tables/scipy_special_tests/gammaincinv/In_d_d-d.parquet new file mode 100644 index 00000000..49e53aae Binary files /dev/null and b/tables/scipy_special_tests/gammaincinv/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaincinv/Out_d_d-d.parquet b/tables/scipy_special_tests/gammaincinv/Out_d_d-d.parquet new file mode 100644 index 00000000..b3970cc7 Binary files /dev/null and b/tables/scipy_special_tests/gammaincinv/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaln/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammaln/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f8db4742 Binary files /dev/null and b/tables/scipy_special_tests/gammaln/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammaln/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammaln/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f98388b8 Binary files /dev/null and b/tables/scipy_special_tests/gammaln/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammaln/In_d-d.parquet b/tables/scipy_special_tests/gammaln/In_d-d.parquet new file mode 100644 index 00000000..12a44e51 Binary files /dev/null and b/tables/scipy_special_tests/gammaln/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaln/In_f-f.parquet b/tables/scipy_special_tests/gammaln/In_f-f.parquet new file mode 100644 index 00000000..f6a33c0c Binary files /dev/null and b/tables/scipy_special_tests/gammaln/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/gammaln/Out_d-d.parquet b/tables/scipy_special_tests/gammaln/Out_d-d.parquet new file mode 100644 index 00000000..b0f790ef Binary files /dev/null and b/tables/scipy_special_tests/gammaln/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammaln/Out_f-f.parquet b/tables/scipy_special_tests/gammaln/Out_f-f.parquet new file mode 100644 index 00000000..c0d2d518 Binary files /dev/null and b/tables/scipy_special_tests/gammaln/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/gammasgn/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gammasgn/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4490cdbc Binary files /dev/null and b/tables/scipy_special_tests/gammasgn/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gammasgn/In_d-d.parquet b/tables/scipy_special_tests/gammasgn/In_d-d.parquet new file mode 100644 index 00000000..c5981f24 Binary files /dev/null and b/tables/scipy_special_tests/gammasgn/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/gammasgn/Out_d-d.parquet b/tables/scipy_special_tests/gammasgn/Out_d-d.parquet new file mode 100644 index 00000000..518c2e8e Binary files /dev/null and b/tables/scipy_special_tests/gammasgn/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/gdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9e037dbb Binary files /dev/null and b/tables/scipy_special_tests/gdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gdtr/In_d_d_d-d.parquet b/tables/scipy_special_tests/gdtr/In_d_d_d-d.parquet new file mode 100644 index 00000000..095b553e Binary files /dev/null and b/tables/scipy_special_tests/gdtr/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gdtr/Out_d_d_d-d.parquet b/tables/scipy_special_tests/gdtr/Out_d_d_d-d.parquet new file mode 100644 index 00000000..8cfdc469 Binary files /dev/null and b/tables/scipy_special_tests/gdtr/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b4e82226 Binary files /dev/null and b/tables/scipy_special_tests/gdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gdtrc/In_d_d_d-d.parquet b/tables/scipy_special_tests/gdtrc/In_d_d_d-d.parquet new file mode 100644 index 00000000..b4abc810 Binary files /dev/null and b/tables/scipy_special_tests/gdtrc/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gdtrc/Out_d_d_d-d.parquet b/tables/scipy_special_tests/gdtrc/Out_d_d_d-d.parquet new file mode 100644 index 00000000..248b6205 Binary files /dev/null and b/tables/scipy_special_tests/gdtrc/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gdtrib/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/gdtrib/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d5ba74e0 Binary files /dev/null and b/tables/scipy_special_tests/gdtrib/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/gdtrib/In_d_d_d-d.parquet b/tables/scipy_special_tests/gdtrib/In_d_d_d-d.parquet new file mode 100644 index 00000000..c948303d Binary files /dev/null and b/tables/scipy_special_tests/gdtrib/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/gdtrib/Out_d_d_d-d.parquet b/tables/scipy_special_tests/gdtrib/Out_d_d_d-d.parquet new file mode 100644 index 00000000..9d2a35a6 Binary files /dev/null and b/tables/scipy_special_tests/gdtrib/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/hyp1f1/Err_d_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/hyp1f1/Err_d_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7bd134da Binary files /dev/null and b/tables/scipy_special_tests/hyp1f1/Err_d_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/hyp1f1/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/hyp1f1/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..076b141e Binary files /dev/null and b/tables/scipy_special_tests/hyp1f1/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/hyp1f1/In_d_d_cd-cd.parquet b/tables/scipy_special_tests/hyp1f1/In_d_d_cd-cd.parquet new file mode 100644 index 00000000..1ea90ebb Binary files /dev/null and b/tables/scipy_special_tests/hyp1f1/In_d_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/hyp1f1/In_d_d_d-d.parquet b/tables/scipy_special_tests/hyp1f1/In_d_d_d-d.parquet new file mode 100644 index 00000000..de62da92 Binary files /dev/null and b/tables/scipy_special_tests/hyp1f1/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/hyp1f1/Out_d_d_cd-cd.parquet b/tables/scipy_special_tests/hyp1f1/Out_d_d_cd-cd.parquet new file mode 100644 index 00000000..d45645c8 Binary files /dev/null and b/tables/scipy_special_tests/hyp1f1/Out_d_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/hyp1f1/Out_d_d_d-d.parquet b/tables/scipy_special_tests/hyp1f1/Out_d_d_d-d.parquet new file mode 100644 index 00000000..40867ba5 Binary files /dev/null and b/tables/scipy_special_tests/hyp1f1/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/hyp2f1/Err_d_d_d_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/hyp2f1/Err_d_d_d_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f7fcb5ec Binary files /dev/null and b/tables/scipy_special_tests/hyp2f1/Err_d_d_d_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/hyp2f1/Err_d_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/hyp2f1/Err_d_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4bfad0cc Binary files /dev/null and b/tables/scipy_special_tests/hyp2f1/Err_d_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/hyp2f1/In_d_d_d_cd-cd.parquet b/tables/scipy_special_tests/hyp2f1/In_d_d_d_cd-cd.parquet new file mode 100644 index 00000000..25d5ecd0 Binary files /dev/null and b/tables/scipy_special_tests/hyp2f1/In_d_d_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/hyp2f1/In_d_d_d_d-d.parquet b/tables/scipy_special_tests/hyp2f1/In_d_d_d_d-d.parquet new file mode 100644 index 00000000..742dddcd Binary files /dev/null and b/tables/scipy_special_tests/hyp2f1/In_d_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/hyp2f1/Out_d_d_d_cd-cd.parquet b/tables/scipy_special_tests/hyp2f1/Out_d_d_d_cd-cd.parquet new file mode 100644 index 00000000..1d312a63 Binary files /dev/null and b/tables/scipy_special_tests/hyp2f1/Out_d_d_d_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/hyp2f1/Out_d_d_d_d-d.parquet b/tables/scipy_special_tests/hyp2f1/Out_d_d_d_d-d.parquet new file mode 100644 index 00000000..36aa098e Binary files /dev/null and b/tables/scipy_special_tests/hyp2f1/Out_d_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/hyperu/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/hyperu/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c165713e Binary files /dev/null and b/tables/scipy_special_tests/hyperu/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/hyperu/In_d_d_d-d.parquet b/tables/scipy_special_tests/hyperu/In_d_d_d-d.parquet new file mode 100644 index 00000000..3873991f Binary files /dev/null and b/tables/scipy_special_tests/hyperu/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/hyperu/Out_d_d_d-d.parquet b/tables/scipy_special_tests/hyperu/Out_d_d_d-d.parquet new file mode 100644 index 00000000..697b7554 Binary files /dev/null and b/tables/scipy_special_tests/hyperu/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/it1i0k0/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/it1i0k0/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c0a952a4 Binary files /dev/null and b/tables/scipy_special_tests/it1i0k0/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/it1i0k0/In_d-d_d.parquet b/tables/scipy_special_tests/it1i0k0/In_d-d_d.parquet new file mode 100644 index 00000000..d8162157 Binary files /dev/null and b/tables/scipy_special_tests/it1i0k0/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it1i0k0/Out_d-d_d.parquet b/tables/scipy_special_tests/it1i0k0/Out_d-d_d.parquet new file mode 100644 index 00000000..d4693cb6 Binary files /dev/null and b/tables/scipy_special_tests/it1i0k0/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it1j0y0/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/it1j0y0/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..cab1478d Binary files /dev/null and b/tables/scipy_special_tests/it1j0y0/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/it1j0y0/In_d-d_d.parquet b/tables/scipy_special_tests/it1j0y0/In_d-d_d.parquet new file mode 100644 index 00000000..75b08685 Binary files /dev/null and b/tables/scipy_special_tests/it1j0y0/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it1j0y0/Out_d-d_d.parquet b/tables/scipy_special_tests/it1j0y0/Out_d-d_d.parquet new file mode 100644 index 00000000..779b8d7a Binary files /dev/null and b/tables/scipy_special_tests/it1j0y0/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it2i0k0/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/it2i0k0/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0e5b1520 Binary files /dev/null and b/tables/scipy_special_tests/it2i0k0/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/it2i0k0/In_d-d_d.parquet b/tables/scipy_special_tests/it2i0k0/In_d-d_d.parquet new file mode 100644 index 00000000..c6a4f0f5 Binary files /dev/null and b/tables/scipy_special_tests/it2i0k0/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it2i0k0/Out_d-d_d.parquet b/tables/scipy_special_tests/it2i0k0/Out_d-d_d.parquet new file mode 100644 index 00000000..1298c4c7 Binary files /dev/null and b/tables/scipy_special_tests/it2i0k0/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it2j0y0/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/it2j0y0/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..067efd87 Binary files /dev/null and b/tables/scipy_special_tests/it2j0y0/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/it2j0y0/In_d-d_d.parquet b/tables/scipy_special_tests/it2j0y0/In_d-d_d.parquet new file mode 100644 index 00000000..2d3a0bae Binary files /dev/null and b/tables/scipy_special_tests/it2j0y0/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it2j0y0/Out_d-d_d.parquet b/tables/scipy_special_tests/it2j0y0/Out_d-d_d.parquet new file mode 100644 index 00000000..2d4ac991 Binary files /dev/null and b/tables/scipy_special_tests/it2j0y0/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/it2struve0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/it2struve0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2ebbf2af Binary files /dev/null and b/tables/scipy_special_tests/it2struve0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/it2struve0/In_d-d.parquet b/tables/scipy_special_tests/it2struve0/In_d-d.parquet new file mode 100644 index 00000000..333b92b7 Binary files /dev/null and b/tables/scipy_special_tests/it2struve0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/it2struve0/Out_d-d.parquet b/tables/scipy_special_tests/it2struve0/Out_d-d.parquet new file mode 100644 index 00000000..bf402ae1 Binary files /dev/null and b/tables/scipy_special_tests/it2struve0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/itairy/Err_d-d_d_d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/itairy/Err_d-d_d_d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5168eb7d Binary files /dev/null and b/tables/scipy_special_tests/itairy/Err_d-d_d_d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/itairy/In_d-d_d_d_d.parquet b/tables/scipy_special_tests/itairy/In_d-d_d_d_d.parquet new file mode 100644 index 00000000..3f6dd332 Binary files /dev/null and b/tables/scipy_special_tests/itairy/In_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/itairy/Out_d-d_d_d_d.parquet b/tables/scipy_special_tests/itairy/Out_d-d_d_d_d.parquet new file mode 100644 index 00000000..2832a063 Binary files /dev/null and b/tables/scipy_special_tests/itairy/Out_d-d_d_d_d.parquet differ diff --git a/tables/scipy_special_tests/itmodstruve0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/itmodstruve0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..32a4dfb5 Binary files /dev/null and b/tables/scipy_special_tests/itmodstruve0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/itmodstruve0/In_d-d.parquet b/tables/scipy_special_tests/itmodstruve0/In_d-d.parquet new file mode 100644 index 00000000..52d09b94 Binary files /dev/null and b/tables/scipy_special_tests/itmodstruve0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/itmodstruve0/Out_d-d.parquet b/tables/scipy_special_tests/itmodstruve0/Out_d-d.parquet new file mode 100644 index 00000000..7353430e Binary files /dev/null and b/tables/scipy_special_tests/itmodstruve0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/itstruve0/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/itstruve0/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..79cc672b Binary files /dev/null and b/tables/scipy_special_tests/itstruve0/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/itstruve0/In_d-d.parquet b/tables/scipy_special_tests/itstruve0/In_d-d.parquet new file mode 100644 index 00000000..0c7db14d Binary files /dev/null and b/tables/scipy_special_tests/itstruve0/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/itstruve0/Out_d-d.parquet b/tables/scipy_special_tests/itstruve0/Out_d-d.parquet new file mode 100644 index 00000000..53f6ace1 Binary files /dev/null and b/tables/scipy_special_tests/itstruve0/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/iv_ratio/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/iv_ratio/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d45f0a6c Binary files /dev/null and b/tables/scipy_special_tests/iv_ratio/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/iv_ratio/In_d_d-d.parquet b/tables/scipy_special_tests/iv_ratio/In_d_d-d.parquet new file mode 100644 index 00000000..ef735207 Binary files /dev/null and b/tables/scipy_special_tests/iv_ratio/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/iv_ratio/Out_d_d-d.parquet b/tables/scipy_special_tests/iv_ratio/Out_d_d-d.parquet new file mode 100644 index 00000000..fa39bb94 Binary files /dev/null and b/tables/scipy_special_tests/iv_ratio/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/iv_ratio_c/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/iv_ratio_c/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a504055b Binary files /dev/null and b/tables/scipy_special_tests/iv_ratio_c/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/iv_ratio_c/In_d_d-d.parquet b/tables/scipy_special_tests/iv_ratio_c/In_d_d-d.parquet new file mode 100644 index 00000000..2a1fa97b Binary files /dev/null and b/tables/scipy_special_tests/iv_ratio_c/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/iv_ratio_c/Out_d_d-d.parquet b/tables/scipy_special_tests/iv_ratio_c/Out_d_d-d.parquet new file mode 100644 index 00000000..9e62d1ed Binary files /dev/null and b/tables/scipy_special_tests/iv_ratio_c/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/kei/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kei/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0d93c8e4 Binary files /dev/null and b/tables/scipy_special_tests/kei/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kei/In_d-d.parquet b/tables/scipy_special_tests/kei/In_d-d.parquet new file mode 100644 index 00000000..038538ab Binary files /dev/null and b/tables/scipy_special_tests/kei/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kei/Out_d-d.parquet b/tables/scipy_special_tests/kei/Out_d-d.parquet new file mode 100644 index 00000000..79eb890a Binary files /dev/null and b/tables/scipy_special_tests/kei/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/keip/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/keip/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..49787ad4 Binary files /dev/null and b/tables/scipy_special_tests/keip/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/keip/In_d-d.parquet b/tables/scipy_special_tests/keip/In_d-d.parquet new file mode 100644 index 00000000..808caf3e Binary files /dev/null and b/tables/scipy_special_tests/keip/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/keip/Out_d-d.parquet b/tables/scipy_special_tests/keip/Out_d-d.parquet new file mode 100644 index 00000000..45e69d92 Binary files /dev/null and b/tables/scipy_special_tests/keip/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kelvin/Err_d-cd_cd_cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kelvin/Err_d-cd_cd_cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..125d1d1e Binary files /dev/null and b/tables/scipy_special_tests/kelvin/Err_d-cd_cd_cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kelvin/In_d-cd_cd_cd_cd.parquet b/tables/scipy_special_tests/kelvin/In_d-cd_cd_cd_cd.parquet new file mode 100644 index 00000000..a6b4b6c9 Binary files /dev/null and b/tables/scipy_special_tests/kelvin/In_d-cd_cd_cd_cd.parquet differ diff --git a/tables/scipy_special_tests/kelvin/Out_d-cd_cd_cd_cd.parquet b/tables/scipy_special_tests/kelvin/Out_d-cd_cd_cd_cd.parquet new file mode 100644 index 00000000..87af553f Binary files /dev/null and b/tables/scipy_special_tests/kelvin/Out_d-cd_cd_cd_cd.parquet differ diff --git a/tables/scipy_special_tests/ker/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ker/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a1dfde79 Binary files /dev/null and b/tables/scipy_special_tests/ker/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ker/In_d-d.parquet b/tables/scipy_special_tests/ker/In_d-d.parquet new file mode 100644 index 00000000..fea732ea Binary files /dev/null and b/tables/scipy_special_tests/ker/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ker/Out_d-d.parquet b/tables/scipy_special_tests/ker/Out_d-d.parquet new file mode 100644 index 00000000..4f25b526 Binary files /dev/null and b/tables/scipy_special_tests/ker/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kerp/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kerp/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..18f9c661 Binary files /dev/null and b/tables/scipy_special_tests/kerp/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kerp/In_d-d.parquet b/tables/scipy_special_tests/kerp/In_d-d.parquet new file mode 100644 index 00000000..d2dcc4ad Binary files /dev/null and b/tables/scipy_special_tests/kerp/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kerp/Out_d-d.parquet b/tables/scipy_special_tests/kerp/Out_d-d.parquet new file mode 100644 index 00000000..e231dcca Binary files /dev/null and b/tables/scipy_special_tests/kerp/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogc/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kolmogc/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b51be5c7 Binary files /dev/null and b/tables/scipy_special_tests/kolmogc/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kolmogc/In_d-d.parquet b/tables/scipy_special_tests/kolmogc/In_d-d.parquet new file mode 100644 index 00000000..e3a91556 Binary files /dev/null and b/tables/scipy_special_tests/kolmogc/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogc/Out_d-d.parquet b/tables/scipy_special_tests/kolmogc/Out_d-d.parquet new file mode 100644 index 00000000..ddb3f29a Binary files /dev/null and b/tables/scipy_special_tests/kolmogc/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogci/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kolmogci/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..241e8e01 Binary files /dev/null and b/tables/scipy_special_tests/kolmogci/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kolmogci/In_d-d.parquet b/tables/scipy_special_tests/kolmogci/In_d-d.parquet new file mode 100644 index 00000000..842368a0 Binary files /dev/null and b/tables/scipy_special_tests/kolmogci/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogci/Out_d-d.parquet b/tables/scipy_special_tests/kolmogci/Out_d-d.parquet new file mode 100644 index 00000000..a8da4ad0 Binary files /dev/null and b/tables/scipy_special_tests/kolmogci/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogi/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kolmogi/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..8e020aa8 Binary files /dev/null and b/tables/scipy_special_tests/kolmogi/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kolmogi/In_d-d.parquet b/tables/scipy_special_tests/kolmogi/In_d-d.parquet new file mode 100644 index 00000000..af896940 Binary files /dev/null and b/tables/scipy_special_tests/kolmogi/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogi/Out_d-d.parquet b/tables/scipy_special_tests/kolmogi/Out_d-d.parquet new file mode 100644 index 00000000..6d4a4425 Binary files /dev/null and b/tables/scipy_special_tests/kolmogi/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogorov/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kolmogorov/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..ac2e65b9 Binary files /dev/null and b/tables/scipy_special_tests/kolmogorov/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kolmogorov/In_d-d.parquet b/tables/scipy_special_tests/kolmogorov/In_d-d.parquet new file mode 100644 index 00000000..569ad231 Binary files /dev/null and b/tables/scipy_special_tests/kolmogorov/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogorov/Out_d-d.parquet b/tables/scipy_special_tests/kolmogorov/Out_d-d.parquet new file mode 100644 index 00000000..53089832 Binary files /dev/null and b/tables/scipy_special_tests/kolmogorov/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogp/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/kolmogp/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a36b6ed7 Binary files /dev/null and b/tables/scipy_special_tests/kolmogp/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/kolmogp/In_d-d.parquet b/tables/scipy_special_tests/kolmogp/In_d-d.parquet new file mode 100644 index 00000000..cf51329c Binary files /dev/null and b/tables/scipy_special_tests/kolmogp/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/kolmogp/Out_d-d.parquet b/tables/scipy_special_tests/kolmogp/Out_d-d.parquet new file mode 100644 index 00000000..db5aaac6 Binary files /dev/null and b/tables/scipy_special_tests/kolmogp/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/lambertw/Err_cd_p_d-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/lambertw/Err_cd_p_d-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5364fddb Binary files /dev/null and b/tables/scipy_special_tests/lambertw/Err_cd_p_d-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/lambertw/In_cd_p_d-cd.parquet b/tables/scipy_special_tests/lambertw/In_cd_p_d-cd.parquet new file mode 100644 index 00000000..b85f8c01 Binary files /dev/null and b/tables/scipy_special_tests/lambertw/In_cd_p_d-cd.parquet differ diff --git a/tables/scipy_special_tests/lambertw/Out_cd_p_d-cd.parquet b/tables/scipy_special_tests/lambertw/Out_cd_p_d-cd.parquet new file mode 100644 index 00000000..51f671cb Binary files /dev/null and b/tables/scipy_special_tests/lambertw/Out_cd_p_d-cd.parquet differ diff --git a/tables/scipy_special_tests/lanczos_sum_expg_scaled/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/lanczos_sum_expg_scaled/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..51b96e60 Binary files /dev/null and b/tables/scipy_special_tests/lanczos_sum_expg_scaled/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/lanczos_sum_expg_scaled/In_d-d.parquet b/tables/scipy_special_tests/lanczos_sum_expg_scaled/In_d-d.parquet new file mode 100644 index 00000000..95fad80f Binary files /dev/null and b/tables/scipy_special_tests/lanczos_sum_expg_scaled/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/lanczos_sum_expg_scaled/Out_d-d.parquet b/tables/scipy_special_tests/lanczos_sum_expg_scaled/Out_d-d.parquet new file mode 100644 index 00000000..4e007570 Binary files /dev/null and b/tables/scipy_special_tests/lanczos_sum_expg_scaled/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/lgam1p/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/lgam1p/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..ce33f735 Binary files /dev/null and b/tables/scipy_special_tests/lgam1p/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/lgam1p/In_d-d.parquet b/tables/scipy_special_tests/lgam1p/In_d-d.parquet new file mode 100644 index 00000000..36a86ff8 Binary files /dev/null and b/tables/scipy_special_tests/lgam1p/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/lgam1p/Out_d-d.parquet b/tables/scipy_special_tests/lgam1p/Out_d-d.parquet new file mode 100644 index 00000000..1613d66f Binary files /dev/null and b/tables/scipy_special_tests/lgam1p/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/log1p/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/log1p/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..7eba437a Binary files /dev/null and b/tables/scipy_special_tests/log1p/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/log1p/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/log1p/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..75f2d84a Binary files /dev/null and b/tables/scipy_special_tests/log1p/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/log1p/In_cd-cd.parquet b/tables/scipy_special_tests/log1p/In_cd-cd.parquet new file mode 100644 index 00000000..5374fc3e Binary files /dev/null and b/tables/scipy_special_tests/log1p/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/log1p/In_d-d.parquet b/tables/scipy_special_tests/log1p/In_d-d.parquet new file mode 100644 index 00000000..534957b7 Binary files /dev/null and b/tables/scipy_special_tests/log1p/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/log1p/Out_cd-cd.parquet b/tables/scipy_special_tests/log1p/Out_cd-cd.parquet new file mode 100644 index 00000000..f0fa660d Binary files /dev/null and b/tables/scipy_special_tests/log1p/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/log1p/Out_d-d.parquet b/tables/scipy_special_tests/log1p/Out_d-d.parquet new file mode 100644 index 00000000..05e75f6d Binary files /dev/null and b/tables/scipy_special_tests/log1p/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/log1pmx/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/log1pmx/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..519994c6 Binary files /dev/null and b/tables/scipy_special_tests/log1pmx/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/log1pmx/In_d-d.parquet b/tables/scipy_special_tests/log1pmx/In_d-d.parquet new file mode 100644 index 00000000..f859b8d6 Binary files /dev/null and b/tables/scipy_special_tests/log1pmx/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/log1pmx/Out_d-d.parquet b/tables/scipy_special_tests/log1pmx/Out_d-d.parquet new file mode 100644 index 00000000..983ff714 Binary files /dev/null and b/tables/scipy_special_tests/log1pmx/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/log_expit/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/log_expit/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fc7381f8 Binary files /dev/null and b/tables/scipy_special_tests/log_expit/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/log_expit/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/log_expit/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..64f62e6a Binary files /dev/null and b/tables/scipy_special_tests/log_expit/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/log_expit/In_d-d.parquet b/tables/scipy_special_tests/log_expit/In_d-d.parquet new file mode 100644 index 00000000..3de7b9fe Binary files /dev/null and b/tables/scipy_special_tests/log_expit/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/log_expit/In_f-f.parquet b/tables/scipy_special_tests/log_expit/In_f-f.parquet new file mode 100644 index 00000000..eb71387a Binary files /dev/null and b/tables/scipy_special_tests/log_expit/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/log_expit/Out_d-d.parquet b/tables/scipy_special_tests/log_expit/Out_d-d.parquet new file mode 100644 index 00000000..106223c9 Binary files /dev/null and b/tables/scipy_special_tests/log_expit/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/log_expit/Out_f-f.parquet b/tables/scipy_special_tests/log_expit/Out_f-f.parquet new file mode 100644 index 00000000..7e5b7e5f Binary files /dev/null and b/tables/scipy_special_tests/log_expit/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/log_wright_bessel/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/log_wright_bessel/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..072c2d01 Binary files /dev/null and b/tables/scipy_special_tests/log_wright_bessel/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/log_wright_bessel/In_d_d_d-d.parquet b/tables/scipy_special_tests/log_wright_bessel/In_d_d_d-d.parquet new file mode 100644 index 00000000..80799c49 Binary files /dev/null and b/tables/scipy_special_tests/log_wright_bessel/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/log_wright_bessel/Out_d_d_d-d.parquet b/tables/scipy_special_tests/log_wright_bessel/Out_d_d_d-d.parquet new file mode 100644 index 00000000..ed43b5e8 Binary files /dev/null and b/tables/scipy_special_tests/log_wright_bessel/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/loggamma/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/loggamma/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..786f396d Binary files /dev/null and b/tables/scipy_special_tests/loggamma/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/loggamma/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/loggamma/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..ef980477 Binary files /dev/null and b/tables/scipy_special_tests/loggamma/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/loggamma/In_cd-cd.parquet b/tables/scipy_special_tests/loggamma/In_cd-cd.parquet new file mode 100644 index 00000000..3e560685 Binary files /dev/null and b/tables/scipy_special_tests/loggamma/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/loggamma/In_d-d.parquet b/tables/scipy_special_tests/loggamma/In_d-d.parquet new file mode 100644 index 00000000..3fcf142e Binary files /dev/null and b/tables/scipy_special_tests/loggamma/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/loggamma/Out_cd-cd.parquet b/tables/scipy_special_tests/loggamma/Out_cd-cd.parquet new file mode 100644 index 00000000..7c73f3dc Binary files /dev/null and b/tables/scipy_special_tests/loggamma/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/loggamma/Out_d-d.parquet b/tables/scipy_special_tests/loggamma/Out_d-d.parquet new file mode 100644 index 00000000..b5392636 Binary files /dev/null and b/tables/scipy_special_tests/loggamma/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/logit/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/logit/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2f5ca751 Binary files /dev/null and b/tables/scipy_special_tests/logit/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/logit/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/logit/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fffe8f7f Binary files /dev/null and b/tables/scipy_special_tests/logit/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/logit/In_d-d.parquet b/tables/scipy_special_tests/logit/In_d-d.parquet new file mode 100644 index 00000000..ec9183db Binary files /dev/null and b/tables/scipy_special_tests/logit/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/logit/In_f-f.parquet b/tables/scipy_special_tests/logit/In_f-f.parquet new file mode 100644 index 00000000..b51ffe76 Binary files /dev/null and b/tables/scipy_special_tests/logit/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/logit/Out_d-d.parquet b/tables/scipy_special_tests/logit/Out_d-d.parquet new file mode 100644 index 00000000..00b9f8b5 Binary files /dev/null and b/tables/scipy_special_tests/logit/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/logit/Out_f-f.parquet b/tables/scipy_special_tests/logit/Out_f-f.parquet new file mode 100644 index 00000000..4c3256c8 Binary files /dev/null and b/tables/scipy_special_tests/logit/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/mcm1/Err_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/mcm1/Err_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..12588a79 Binary files /dev/null and b/tables/scipy_special_tests/mcm1/Err_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/mcm1/In_d_d_d-d_d.parquet b/tables/scipy_special_tests/mcm1/In_d_d_d-d_d.parquet new file mode 100644 index 00000000..52aa4c6f Binary files /dev/null and b/tables/scipy_special_tests/mcm1/In_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/mcm1/Out_d_d_d-d_d.parquet b/tables/scipy_special_tests/mcm1/Out_d_d_d-d_d.parquet new file mode 100644 index 00000000..06de3f80 Binary files /dev/null and b/tables/scipy_special_tests/mcm1/Out_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/mcm2/Err_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/mcm2/Err_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..06004762 Binary files /dev/null and b/tables/scipy_special_tests/mcm2/Err_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/mcm2/In_d_d_d-d_d.parquet b/tables/scipy_special_tests/mcm2/In_d_d_d-d_d.parquet new file mode 100644 index 00000000..c8d3d055 Binary files /dev/null and b/tables/scipy_special_tests/mcm2/In_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/mcm2/Out_d_d_d-d_d.parquet b/tables/scipy_special_tests/mcm2/Out_d_d_d-d_d.parquet new file mode 100644 index 00000000..edb737e9 Binary files /dev/null and b/tables/scipy_special_tests/mcm2/Out_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/modified_fresnel_minus/Err_d-cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/modified_fresnel_minus/Err_d-cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..437ccf12 Binary files /dev/null and b/tables/scipy_special_tests/modified_fresnel_minus/Err_d-cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/modified_fresnel_minus/In_d-cd_cd.parquet b/tables/scipy_special_tests/modified_fresnel_minus/In_d-cd_cd.parquet new file mode 100644 index 00000000..ac3b65b7 Binary files /dev/null and b/tables/scipy_special_tests/modified_fresnel_minus/In_d-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/modified_fresnel_minus/Out_d-cd_cd.parquet b/tables/scipy_special_tests/modified_fresnel_minus/Out_d-cd_cd.parquet new file mode 100644 index 00000000..15e82faf Binary files /dev/null and b/tables/scipy_special_tests/modified_fresnel_minus/Out_d-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/modified_fresnel_plus/Err_d-cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/modified_fresnel_plus/Err_d-cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..551600e3 Binary files /dev/null and b/tables/scipy_special_tests/modified_fresnel_plus/Err_d-cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/modified_fresnel_plus/In_d-cd_cd.parquet b/tables/scipy_special_tests/modified_fresnel_plus/In_d-cd_cd.parquet new file mode 100644 index 00000000..5c5a19af Binary files /dev/null and b/tables/scipy_special_tests/modified_fresnel_plus/In_d-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/modified_fresnel_plus/Out_d-cd_cd.parquet b/tables/scipy_special_tests/modified_fresnel_plus/Out_d-cd_cd.parquet new file mode 100644 index 00000000..92da1bcd Binary files /dev/null and b/tables/scipy_special_tests/modified_fresnel_plus/Out_d-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/msm1/Err_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/msm1/Err_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..ab5c5a35 Binary files /dev/null and b/tables/scipy_special_tests/msm1/Err_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/msm1/In_d_d_d-d_d.parquet b/tables/scipy_special_tests/msm1/In_d_d_d-d_d.parquet new file mode 100644 index 00000000..3fb95404 Binary files /dev/null and b/tables/scipy_special_tests/msm1/In_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/msm1/Out_d_d_d-d_d.parquet b/tables/scipy_special_tests/msm1/Out_d_d_d-d_d.parquet new file mode 100644 index 00000000..8074c855 Binary files /dev/null and b/tables/scipy_special_tests/msm1/Out_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/msm2/Err_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/msm2/Err_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..1c7fe369 Binary files /dev/null and b/tables/scipy_special_tests/msm2/Err_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/msm2/In_d_d_d-d_d.parquet b/tables/scipy_special_tests/msm2/In_d_d_d-d_d.parquet new file mode 100644 index 00000000..e354d51f Binary files /dev/null and b/tables/scipy_special_tests/msm2/In_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/msm2/Out_d_d_d-d_d.parquet b/tables/scipy_special_tests/msm2/Out_d_d_d-d_d.parquet new file mode 100644 index 00000000..67765ae1 Binary files /dev/null and b/tables/scipy_special_tests/msm2/Out_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/nbdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/nbdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c2fb4ced Binary files /dev/null and b/tables/scipy_special_tests/nbdtr/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/nbdtr/Err_p_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/nbdtr/Err_p_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..21a5f127 Binary files /dev/null and b/tables/scipy_special_tests/nbdtr/Err_p_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/nbdtr/In_d_d_d-d.parquet b/tables/scipy_special_tests/nbdtr/In_d_d_d-d.parquet new file mode 100644 index 00000000..d416b7d1 Binary files /dev/null and b/tables/scipy_special_tests/nbdtr/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtr/In_p_p_d-d.parquet b/tables/scipy_special_tests/nbdtr/In_p_p_d-d.parquet new file mode 100644 index 00000000..406495d4 Binary files /dev/null and b/tables/scipy_special_tests/nbdtr/In_p_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtr/Out_d_d_d-d.parquet b/tables/scipy_special_tests/nbdtr/Out_d_d_d-d.parquet new file mode 100644 index 00000000..6651926a Binary files /dev/null and b/tables/scipy_special_tests/nbdtr/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtr/Out_p_p_d-d.parquet b/tables/scipy_special_tests/nbdtr/Out_p_p_d-d.parquet new file mode 100644 index 00000000..67802832 Binary files /dev/null and b/tables/scipy_special_tests/nbdtr/Out_p_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/nbdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..25068c06 Binary files /dev/null and b/tables/scipy_special_tests/nbdtrc/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/nbdtrc/Err_p_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/nbdtrc/Err_p_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..05ae0f88 Binary files /dev/null and b/tables/scipy_special_tests/nbdtrc/Err_p_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/nbdtrc/In_d_d_d-d.parquet b/tables/scipy_special_tests/nbdtrc/In_d_d_d-d.parquet new file mode 100644 index 00000000..77caeb62 Binary files /dev/null and b/tables/scipy_special_tests/nbdtrc/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtrc/In_p_p_d-d.parquet b/tables/scipy_special_tests/nbdtrc/In_p_p_d-d.parquet new file mode 100644 index 00000000..c3fe50b5 Binary files /dev/null and b/tables/scipy_special_tests/nbdtrc/In_p_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtrc/Out_d_d_d-d.parquet b/tables/scipy_special_tests/nbdtrc/Out_d_d_d-d.parquet new file mode 100644 index 00000000..1910903f Binary files /dev/null and b/tables/scipy_special_tests/nbdtrc/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/nbdtrc/Out_p_p_d-d.parquet b/tables/scipy_special_tests/nbdtrc/Out_p_p_d-d.parquet new file mode 100644 index 00000000..d54cf48e Binary files /dev/null and b/tables/scipy_special_tests/nbdtrc/Out_p_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/ndtr/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ndtr/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..1c0affc5 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ndtr/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ndtr/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..bd4e7a50 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ndtr/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ndtr/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..aa0c6f1d Binary files /dev/null and b/tables/scipy_special_tests/ndtr/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ndtr/In_cd-cd.parquet b/tables/scipy_special_tests/ndtr/In_cd-cd.parquet new file mode 100644 index 00000000..54793467 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/ndtr/In_d-d.parquet b/tables/scipy_special_tests/ndtr/In_d-d.parquet new file mode 100644 index 00000000..a7878323 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ndtr/In_f-f.parquet b/tables/scipy_special_tests/ndtr/In_f-f.parquet new file mode 100644 index 00000000..da963013 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/ndtr/Out_cd-cd.parquet b/tables/scipy_special_tests/ndtr/Out_cd-cd.parquet new file mode 100644 index 00000000..8b71690a Binary files /dev/null and b/tables/scipy_special_tests/ndtr/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/ndtr/Out_d-d.parquet b/tables/scipy_special_tests/ndtr/Out_d-d.parquet new file mode 100644 index 00000000..c4fbcfb9 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/ndtr/Out_f-f.parquet b/tables/scipy_special_tests/ndtr/Out_f-f.parquet new file mode 100644 index 00000000..a9959195 Binary files /dev/null and b/tables/scipy_special_tests/ndtr/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/ndtri/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ndtri/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..479feeee Binary files /dev/null and b/tables/scipy_special_tests/ndtri/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ndtri/Err_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/ndtri/Err_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2e5079ae Binary files /dev/null and b/tables/scipy_special_tests/ndtri/Err_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/ndtri/In_d-d.parquet b/tables/scipy_special_tests/ndtri/In_d-d.parquet new file mode 100644 index 00000000..db12f334 Binary files /dev/null and b/tables/scipy_special_tests/ndtri/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/ndtri/In_f-f.parquet b/tables/scipy_special_tests/ndtri/In_f-f.parquet new file mode 100644 index 00000000..90d5f166 Binary files /dev/null and b/tables/scipy_special_tests/ndtri/In_f-f.parquet differ diff --git a/tables/scipy_special_tests/ndtri/Out_d-d.parquet b/tables/scipy_special_tests/ndtri/Out_d-d.parquet new file mode 100644 index 00000000..9daa7280 Binary files /dev/null and b/tables/scipy_special_tests/ndtri/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/ndtri/Out_f-f.parquet b/tables/scipy_special_tests/ndtri/Out_f-f.parquet new file mode 100644 index 00000000..ab7fa4f2 Binary files /dev/null and b/tables/scipy_special_tests/ndtri/Out_f-f.parquet differ diff --git a/tables/scipy_special_tests/oblate_aswfa/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/oblate_aswfa/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..209d29ab Binary files /dev/null and b/tables/scipy_special_tests/oblate_aswfa/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/oblate_aswfa/In_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_aswfa/In_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..d0ee6b72 Binary files /dev/null and b/tables/scipy_special_tests/oblate_aswfa/In_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_aswfa/Out_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_aswfa/Out_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..6cbe7da3 Binary files /dev/null and b/tables/scipy_special_tests/oblate_aswfa/Out_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_aswfa_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/oblate_aswfa_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..bebc5b30 Binary files /dev/null and b/tables/scipy_special_tests/oblate_aswfa_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/oblate_aswfa_nocv/In_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_aswfa_nocv/In_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..014b7a04 Binary files /dev/null and b/tables/scipy_special_tests/oblate_aswfa_nocv/In_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_aswfa_nocv/Out_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_aswfa_nocv/Out_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..08c1aee6 Binary files /dev/null and b/tables/scipy_special_tests/oblate_aswfa_nocv/Out_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial1/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/oblate_radial1/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..bdaa0064 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial1/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial1/In_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial1/In_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..58482777 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial1/In_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial1/Out_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial1/Out_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..0c7869b7 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial1/Out_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial1_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/oblate_radial1_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4921bb3a Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial1_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial1_nocv/In_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial1_nocv/In_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..53510d20 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial1_nocv/In_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial1_nocv/Out_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial1_nocv/Out_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..ec7a22ad Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial1_nocv/Out_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial2/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/oblate_radial2/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0f66ba57 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial2/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial2/In_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial2/In_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..963f1fba Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial2/In_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial2/Out_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial2/Out_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..5fe1a475 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial2/Out_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial2_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/oblate_radial2_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b6766555 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial2_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial2_nocv/In_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial2_nocv/In_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..9ac8ceca Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial2_nocv/In_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/oblate_radial2_nocv/Out_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/oblate_radial2_nocv/Out_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..b39abb66 Binary files /dev/null and b/tables/scipy_special_tests/oblate_radial2_nocv/Out_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/owens_t/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/owens_t/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4481478f Binary files /dev/null and b/tables/scipy_special_tests/owens_t/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/owens_t/In_d_d-d.parquet b/tables/scipy_special_tests/owens_t/In_d_d-d.parquet new file mode 100644 index 00000000..a718855c Binary files /dev/null and b/tables/scipy_special_tests/owens_t/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/owens_t/Out_d_d-d.parquet b/tables/scipy_special_tests/owens_t/Out_d_d-d.parquet new file mode 100644 index 00000000..9cd75bd7 Binary files /dev/null and b/tables/scipy_special_tests/owens_t/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pbdv/Err_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pbdv/Err_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b36715f6 Binary files /dev/null and b/tables/scipy_special_tests/pbdv/Err_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pbdv/In_d_d-d_d.parquet b/tables/scipy_special_tests/pbdv/In_d_d-d_d.parquet new file mode 100644 index 00000000..c814455b Binary files /dev/null and b/tables/scipy_special_tests/pbdv/In_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/pbdv/Out_d_d-d_d.parquet b/tables/scipy_special_tests/pbdv/Out_d_d-d_d.parquet new file mode 100644 index 00000000..c4fdafe3 Binary files /dev/null and b/tables/scipy_special_tests/pbdv/Out_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/pbvv/Err_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pbvv/Err_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a586d5e1 Binary files /dev/null and b/tables/scipy_special_tests/pbvv/Err_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pbvv/In_d_d-d_d.parquet b/tables/scipy_special_tests/pbvv/In_d_d-d_d.parquet new file mode 100644 index 00000000..29d05c70 Binary files /dev/null and b/tables/scipy_special_tests/pbvv/In_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/pbvv/Out_d_d-d_d.parquet b/tables/scipy_special_tests/pbvv/Out_d_d-d_d.parquet new file mode 100644 index 00000000..db8fa87c Binary files /dev/null and b/tables/scipy_special_tests/pbvv/Out_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/pbwa/Err_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pbwa/Err_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..822ac53d Binary files /dev/null and b/tables/scipy_special_tests/pbwa/Err_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pbwa/In_d_d-d_d.parquet b/tables/scipy_special_tests/pbwa/In_d_d-d_d.parquet new file mode 100644 index 00000000..1110d1c6 Binary files /dev/null and b/tables/scipy_special_tests/pbwa/In_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/pbwa/Out_d_d-d_d.parquet b/tables/scipy_special_tests/pbwa/Out_d_d-d_d.parquet new file mode 100644 index 00000000..de541b99 Binary files /dev/null and b/tables/scipy_special_tests/pbwa/Out_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/pdtr/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pdtr/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5131e47b Binary files /dev/null and b/tables/scipy_special_tests/pdtr/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pdtr/In_d_d-d.parquet b/tables/scipy_special_tests/pdtr/In_d_d-d.parquet new file mode 100644 index 00000000..8e8ab92e Binary files /dev/null and b/tables/scipy_special_tests/pdtr/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtr/Out_d_d-d.parquet b/tables/scipy_special_tests/pdtr/Out_d_d-d.parquet new file mode 100644 index 00000000..fd33b653 Binary files /dev/null and b/tables/scipy_special_tests/pdtr/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtrc/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pdtrc/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5ab1e62c Binary files /dev/null and b/tables/scipy_special_tests/pdtrc/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pdtrc/In_d_d-d.parquet b/tables/scipy_special_tests/pdtrc/In_d_d-d.parquet new file mode 100644 index 00000000..8c340f87 Binary files /dev/null and b/tables/scipy_special_tests/pdtrc/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtrc/Out_d_d-d.parquet b/tables/scipy_special_tests/pdtrc/Out_d_d-d.parquet new file mode 100644 index 00000000..59f428b1 Binary files /dev/null and b/tables/scipy_special_tests/pdtrc/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtri/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pdtri/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fbe7e9f0 Binary files /dev/null and b/tables/scipy_special_tests/pdtri/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pdtri/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pdtri/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..5caf2b9e Binary files /dev/null and b/tables/scipy_special_tests/pdtri/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pdtri/In_d_d-d.parquet b/tables/scipy_special_tests/pdtri/In_d_d-d.parquet new file mode 100644 index 00000000..b5499efe Binary files /dev/null and b/tables/scipy_special_tests/pdtri/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtri/In_p_d-d.parquet b/tables/scipy_special_tests/pdtri/In_p_d-d.parquet new file mode 100644 index 00000000..77c85abe Binary files /dev/null and b/tables/scipy_special_tests/pdtri/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtri/Out_d_d-d.parquet b/tables/scipy_special_tests/pdtri/Out_d_d-d.parquet new file mode 100644 index 00000000..ccabf7a0 Binary files /dev/null and b/tables/scipy_special_tests/pdtri/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pdtri/Out_p_d-d.parquet b/tables/scipy_special_tests/pdtri/Out_p_d-d.parquet new file mode 100644 index 00000000..d221fdd3 Binary files /dev/null and b/tables/scipy_special_tests/pdtri/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/pmv/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/pmv/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a8c4aa79 Binary files /dev/null and b/tables/scipy_special_tests/pmv/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/pmv/In_d_d_d-d.parquet b/tables/scipy_special_tests/pmv/In_d_d_d-d.parquet new file mode 100644 index 00000000..a923394c Binary files /dev/null and b/tables/scipy_special_tests/pmv/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/pmv/Out_d_d_d-d.parquet b/tables/scipy_special_tests/pmv/Out_d_d_d-d.parquet new file mode 100644 index 00000000..ec3138fd Binary files /dev/null and b/tables/scipy_special_tests/pmv/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/poch/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/poch/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b7db9c55 Binary files /dev/null and b/tables/scipy_special_tests/poch/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/poch/In_d_d-d.parquet b/tables/scipy_special_tests/poch/In_d_d-d.parquet new file mode 100644 index 00000000..2c39268e Binary files /dev/null and b/tables/scipy_special_tests/poch/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/poch/Out_d_d-d.parquet b/tables/scipy_special_tests/poch/Out_d_d-d.parquet new file mode 100644 index 00000000..5ae2f076 Binary files /dev/null and b/tables/scipy_special_tests/poch/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/prolate_aswfa/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_aswfa/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..986aa01b Binary files /dev/null and b/tables/scipy_special_tests/prolate_aswfa/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_aswfa/In_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_aswfa/In_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..26c998e4 Binary files /dev/null and b/tables/scipy_special_tests/prolate_aswfa/In_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_aswfa/Out_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_aswfa/Out_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..8b2d6acb Binary files /dev/null and b/tables/scipy_special_tests/prolate_aswfa/Out_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_aswfa_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_aswfa_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..95c40195 Binary files /dev/null and b/tables/scipy_special_tests/prolate_aswfa_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_aswfa_nocv/In_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_aswfa_nocv/In_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..7b5847f2 Binary files /dev/null and b/tables/scipy_special_tests/prolate_aswfa_nocv/In_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_aswfa_nocv/Out_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_aswfa_nocv/Out_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..f686d01e Binary files /dev/null and b/tables/scipy_special_tests/prolate_aswfa_nocv/Out_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial1/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_radial1/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..71caf9de Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial1/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial1/In_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial1/In_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..7930225f Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial1/In_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial1/Out_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial1/Out_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..27521ed2 Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial1/Out_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial1_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_radial1_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4ad7f42a Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial1_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial1_nocv/In_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial1_nocv/In_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..81d7032a Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial1_nocv/In_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial1_nocv/Out_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial1_nocv/Out_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..a671fe49 Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial1_nocv/Out_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial2/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_radial2/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a309f622 Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial2/Err_d_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial2/In_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial2/In_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..bbe46980 Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial2/In_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial2/Out_d_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial2/Out_d_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..564c8b0e Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial2/Out_d_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial2_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_radial2_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..2ab2e7ee Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial2_nocv/Err_d_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial2_nocv/In_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial2_nocv/In_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..f85018d6 Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial2_nocv/In_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_radial2_nocv/Out_d_d_d_d-d_d.parquet b/tables/scipy_special_tests/prolate_radial2_nocv/Out_d_d_d_d-d_d.parquet new file mode 100644 index 00000000..ff691e18 Binary files /dev/null and b/tables/scipy_special_tests/prolate_radial2_nocv/Out_d_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/prolate_segv/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/prolate_segv/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..eb3b6aab Binary files /dev/null and b/tables/scipy_special_tests/prolate_segv/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/prolate_segv/In_d_d_d-d.parquet b/tables/scipy_special_tests/prolate_segv/In_d_d_d-d.parquet new file mode 100644 index 00000000..3078ad28 Binary files /dev/null and b/tables/scipy_special_tests/prolate_segv/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/prolate_segv/Out_d_d_d-d.parquet b/tables/scipy_special_tests/prolate_segv/Out_d_d_d-d.parquet new file mode 100644 index 00000000..3faae76e Binary files /dev/null and b/tables/scipy_special_tests/prolate_segv/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/radian/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/radian/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..35cba119 Binary files /dev/null and b/tables/scipy_special_tests/radian/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/radian/In_d_d_d-d.parquet b/tables/scipy_special_tests/radian/In_d_d_d-d.parquet new file mode 100644 index 00000000..663c3fc8 Binary files /dev/null and b/tables/scipy_special_tests/radian/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/radian/Out_d_d_d-d.parquet b/tables/scipy_special_tests/radian/Out_d_d_d-d.parquet new file mode 100644 index 00000000..79f955b4 Binary files /dev/null and b/tables/scipy_special_tests/radian/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/rgamma/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/rgamma/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0b6b6055 Binary files /dev/null and b/tables/scipy_special_tests/rgamma/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/rgamma/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/rgamma/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a469c072 Binary files /dev/null and b/tables/scipy_special_tests/rgamma/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/rgamma/In_cd-cd.parquet b/tables/scipy_special_tests/rgamma/In_cd-cd.parquet new file mode 100644 index 00000000..97042325 Binary files /dev/null and b/tables/scipy_special_tests/rgamma/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/rgamma/In_d-d.parquet b/tables/scipy_special_tests/rgamma/In_d-d.parquet new file mode 100644 index 00000000..0248dade Binary files /dev/null and b/tables/scipy_special_tests/rgamma/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/rgamma/Out_cd-cd.parquet b/tables/scipy_special_tests/rgamma/Out_cd-cd.parquet new file mode 100644 index 00000000..df494f75 Binary files /dev/null and b/tables/scipy_special_tests/rgamma/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/rgamma/Out_d-d.parquet b/tables/scipy_special_tests/rgamma/Out_d-d.parquet new file mode 100644 index 00000000..692732c6 Binary files /dev/null and b/tables/scipy_special_tests/rgamma/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/riemann_zeta/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/riemann_zeta/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..fc512a9b Binary files /dev/null and b/tables/scipy_special_tests/riemann_zeta/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/riemann_zeta/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/riemann_zeta/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..07ca225e Binary files /dev/null and b/tables/scipy_special_tests/riemann_zeta/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/riemann_zeta/In_cd-cd.parquet b/tables/scipy_special_tests/riemann_zeta/In_cd-cd.parquet new file mode 100644 index 00000000..c7fb397c Binary files /dev/null and b/tables/scipy_special_tests/riemann_zeta/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/riemann_zeta/In_d-d.parquet b/tables/scipy_special_tests/riemann_zeta/In_d-d.parquet new file mode 100644 index 00000000..13966491 Binary files /dev/null and b/tables/scipy_special_tests/riemann_zeta/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/riemann_zeta/Out_cd-cd.parquet b/tables/scipy_special_tests/riemann_zeta/Out_cd-cd.parquet new file mode 100644 index 00000000..2a2b6fe1 Binary files /dev/null and b/tables/scipy_special_tests/riemann_zeta/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/riemann_zeta/Out_d-d.parquet b/tables/scipy_special_tests/riemann_zeta/Out_d-d.parquet new file mode 100644 index 00000000..786e7b9f Binary files /dev/null and b/tables/scipy_special_tests/riemann_zeta/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/round/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/round/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..21739503 Binary files /dev/null and b/tables/scipy_special_tests/round/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/round/In_d-d.parquet b/tables/scipy_special_tests/round/In_d-d.parquet new file mode 100644 index 00000000..2592f668 Binary files /dev/null and b/tables/scipy_special_tests/round/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/round/Out_d-d.parquet b/tables/scipy_special_tests/round/Out_d-d.parquet new file mode 100644 index 00000000..90db5cf0 Binary files /dev/null and b/tables/scipy_special_tests/round/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/scaled_exp1/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/scaled_exp1/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..19c22f77 Binary files /dev/null and b/tables/scipy_special_tests/scaled_exp1/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/scaled_exp1/In_d-d.parquet b/tables/scipy_special_tests/scaled_exp1/In_d-d.parquet new file mode 100644 index 00000000..7c4a7e32 Binary files /dev/null and b/tables/scipy_special_tests/scaled_exp1/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/scaled_exp1/Out_d-d.parquet b/tables/scipy_special_tests/scaled_exp1/Out_d-d.parquet new file mode 100644 index 00000000..b8a2ba3f Binary files /dev/null and b/tables/scipy_special_tests/scaled_exp1/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/sem/Err_d_d_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sem/Err_d_d_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..4074bcd4 Binary files /dev/null and b/tables/scipy_special_tests/sem/Err_d_d_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sem/In_d_d_d-d_d.parquet b/tables/scipy_special_tests/sem/In_d_d_d-d_d.parquet new file mode 100644 index 00000000..e0eea51f Binary files /dev/null and b/tables/scipy_special_tests/sem/In_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/sem/Out_d_d_d-d_d.parquet b/tables/scipy_special_tests/sem/Out_d_d_d-d_d.parquet new file mode 100644 index 00000000..62c4c76b Binary files /dev/null and b/tables/scipy_special_tests/sem/Out_d_d_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/sem_cva/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sem_cva/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..d3fcf0e6 Binary files /dev/null and b/tables/scipy_special_tests/sem_cva/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sem_cva/In_d_d-d.parquet b/tables/scipy_special_tests/sem_cva/In_d_d-d.parquet new file mode 100644 index 00000000..fafb4f32 Binary files /dev/null and b/tables/scipy_special_tests/sem_cva/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/sem_cva/Out_d_d-d.parquet b/tables/scipy_special_tests/sem_cva/Out_d_d-d.parquet new file mode 100644 index 00000000..d0421fcf Binary files /dev/null and b/tables/scipy_special_tests/sem_cva/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/shichi/Err_cd-cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/shichi/Err_cd-cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..b40e1755 Binary files /dev/null and b/tables/scipy_special_tests/shichi/Err_cd-cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/shichi/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/shichi/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a9b24f99 Binary files /dev/null and b/tables/scipy_special_tests/shichi/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/shichi/In_cd-cd_cd.parquet b/tables/scipy_special_tests/shichi/In_cd-cd_cd.parquet new file mode 100644 index 00000000..2083fee9 Binary files /dev/null and b/tables/scipy_special_tests/shichi/In_cd-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/shichi/In_d-d_d.parquet b/tables/scipy_special_tests/shichi/In_d-d_d.parquet new file mode 100644 index 00000000..c2f9e4dc Binary files /dev/null and b/tables/scipy_special_tests/shichi/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/shichi/Out_cd-cd_cd.parquet b/tables/scipy_special_tests/shichi/Out_cd-cd_cd.parquet new file mode 100644 index 00000000..7e828454 Binary files /dev/null and b/tables/scipy_special_tests/shichi/Out_cd-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/shichi/Out_d-d_d.parquet b/tables/scipy_special_tests/shichi/Out_d-d_d.parquet new file mode 100644 index 00000000..b6307a20 Binary files /dev/null and b/tables/scipy_special_tests/shichi/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/sici/Err_cd-cd_cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sici/Err_cd-cd_cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f6ca6740 Binary files /dev/null and b/tables/scipy_special_tests/sici/Err_cd-cd_cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sici/Err_d-d_d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sici/Err_d-d_d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0676f6f2 Binary files /dev/null and b/tables/scipy_special_tests/sici/Err_d-d_d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sici/In_cd-cd_cd.parquet b/tables/scipy_special_tests/sici/In_cd-cd_cd.parquet new file mode 100644 index 00000000..f92ae205 Binary files /dev/null and b/tables/scipy_special_tests/sici/In_cd-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/sici/In_d-d_d.parquet b/tables/scipy_special_tests/sici/In_d-d_d.parquet new file mode 100644 index 00000000..c271dcf8 Binary files /dev/null and b/tables/scipy_special_tests/sici/In_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/sici/Out_cd-cd_cd.parquet b/tables/scipy_special_tests/sici/Out_cd-cd_cd.parquet new file mode 100644 index 00000000..e9deaf99 Binary files /dev/null and b/tables/scipy_special_tests/sici/Out_cd-cd_cd.parquet differ diff --git a/tables/scipy_special_tests/sici/Out_d-d_d.parquet b/tables/scipy_special_tests/sici/Out_d-d_d.parquet new file mode 100644 index 00000000..db615abf Binary files /dev/null and b/tables/scipy_special_tests/sici/Out_d-d_d.parquet differ diff --git a/tables/scipy_special_tests/sindg/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sindg/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..8c99f984 Binary files /dev/null and b/tables/scipy_special_tests/sindg/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sindg/In_d-d.parquet b/tables/scipy_special_tests/sindg/In_d-d.parquet new file mode 100644 index 00000000..f492b42b Binary files /dev/null and b/tables/scipy_special_tests/sindg/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/sindg/Out_d-d.parquet b/tables/scipy_special_tests/sindg/Out_d-d.parquet new file mode 100644 index 00000000..39f74f0e Binary files /dev/null and b/tables/scipy_special_tests/sindg/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/sinpi/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sinpi/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..1ca30ed7 Binary files /dev/null and b/tables/scipy_special_tests/sinpi/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sinpi/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/sinpi/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..aaaec7b0 Binary files /dev/null and b/tables/scipy_special_tests/sinpi/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/sinpi/In_cd-cd.parquet b/tables/scipy_special_tests/sinpi/In_cd-cd.parquet new file mode 100644 index 00000000..5a337ddb Binary files /dev/null and b/tables/scipy_special_tests/sinpi/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/sinpi/In_d-d.parquet b/tables/scipy_special_tests/sinpi/In_d-d.parquet new file mode 100644 index 00000000..bcdbc49b Binary files /dev/null and b/tables/scipy_special_tests/sinpi/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/sinpi/Out_cd-cd.parquet b/tables/scipy_special_tests/sinpi/Out_cd-cd.parquet new file mode 100644 index 00000000..251c38ec Binary files /dev/null and b/tables/scipy_special_tests/sinpi/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/sinpi/Out_d-d.parquet b/tables/scipy_special_tests/sinpi/Out_d-d.parquet new file mode 100644 index 00000000..babfb269 Binary files /dev/null and b/tables/scipy_special_tests/sinpi/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnov/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnov/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..cb4188ef Binary files /dev/null and b/tables/scipy_special_tests/smirnov/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnov/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnov/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0ccb80c1 Binary files /dev/null and b/tables/scipy_special_tests/smirnov/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnov/In_d_d-d.parquet b/tables/scipy_special_tests/smirnov/In_d_d-d.parquet new file mode 100644 index 00000000..58303baa Binary files /dev/null and b/tables/scipy_special_tests/smirnov/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnov/In_p_d-d.parquet b/tables/scipy_special_tests/smirnov/In_p_d-d.parquet new file mode 100644 index 00000000..ba2d46b7 Binary files /dev/null and b/tables/scipy_special_tests/smirnov/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnov/Out_d_d-d.parquet b/tables/scipy_special_tests/smirnov/Out_d_d-d.parquet new file mode 100644 index 00000000..7dd7d6f3 Binary files /dev/null and b/tables/scipy_special_tests/smirnov/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnov/Out_p_d-d.parquet b/tables/scipy_special_tests/smirnov/Out_p_d-d.parquet new file mode 100644 index 00000000..df701ef0 Binary files /dev/null and b/tables/scipy_special_tests/smirnov/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovc/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnovc/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0b8f1711 Binary files /dev/null and b/tables/scipy_special_tests/smirnovc/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnovc/In_p_d-d.parquet b/tables/scipy_special_tests/smirnovc/In_p_d-d.parquet new file mode 100644 index 00000000..85c0886f Binary files /dev/null and b/tables/scipy_special_tests/smirnovc/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovc/Out_p_d-d.parquet b/tables/scipy_special_tests/smirnovc/Out_p_d-d.parquet new file mode 100644 index 00000000..d60b7c9f Binary files /dev/null and b/tables/scipy_special_tests/smirnovc/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovci/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnovci/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..896c493a Binary files /dev/null and b/tables/scipy_special_tests/smirnovci/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnovci/In_p_d-d.parquet b/tables/scipy_special_tests/smirnovci/In_p_d-d.parquet new file mode 100644 index 00000000..826c465a Binary files /dev/null and b/tables/scipy_special_tests/smirnovci/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovci/Out_p_d-d.parquet b/tables/scipy_special_tests/smirnovci/Out_p_d-d.parquet new file mode 100644 index 00000000..15a8e843 Binary files /dev/null and b/tables/scipy_special_tests/smirnovci/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovi/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnovi/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9af79297 Binary files /dev/null and b/tables/scipy_special_tests/smirnovi/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnovi/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnovi/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..9ee7b3d8 Binary files /dev/null and b/tables/scipy_special_tests/smirnovi/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnovi/In_d_d-d.parquet b/tables/scipy_special_tests/smirnovi/In_d_d-d.parquet new file mode 100644 index 00000000..8e3da5dd Binary files /dev/null and b/tables/scipy_special_tests/smirnovi/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovi/In_p_d-d.parquet b/tables/scipy_special_tests/smirnovi/In_p_d-d.parquet new file mode 100644 index 00000000..89875609 Binary files /dev/null and b/tables/scipy_special_tests/smirnovi/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovi/Out_d_d-d.parquet b/tables/scipy_special_tests/smirnovi/Out_d_d-d.parquet new file mode 100644 index 00000000..05bc27ce Binary files /dev/null and b/tables/scipy_special_tests/smirnovi/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovi/Out_p_d-d.parquet b/tables/scipy_special_tests/smirnovi/Out_p_d-d.parquet new file mode 100644 index 00000000..938599d0 Binary files /dev/null and b/tables/scipy_special_tests/smirnovi/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovp/Err_p_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/smirnovp/Err_p_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..0e907d13 Binary files /dev/null and b/tables/scipy_special_tests/smirnovp/Err_p_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/smirnovp/In_p_d-d.parquet b/tables/scipy_special_tests/smirnovp/In_p_d-d.parquet new file mode 100644 index 00000000..56bf656e Binary files /dev/null and b/tables/scipy_special_tests/smirnovp/In_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/smirnovp/Out_p_d-d.parquet b/tables/scipy_special_tests/smirnovp/Out_p_d-d.parquet new file mode 100644 index 00000000..b38bc5fd Binary files /dev/null and b/tables/scipy_special_tests/smirnovp/Out_p_d-d.parquet differ diff --git a/tables/scipy_special_tests/spence/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/spence/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..31b2b960 Binary files /dev/null and b/tables/scipy_special_tests/spence/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/spence/In_d-d.parquet b/tables/scipy_special_tests/spence/In_d-d.parquet new file mode 100644 index 00000000..0db85e29 Binary files /dev/null and b/tables/scipy_special_tests/spence/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/spence/Out_d-d.parquet b/tables/scipy_special_tests/spence/Out_d-d.parquet new file mode 100644 index 00000000..63cd2931 Binary files /dev/null and b/tables/scipy_special_tests/spence/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/struve_h/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/struve_h/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..a26719d3 Binary files /dev/null and b/tables/scipy_special_tests/struve_h/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/struve_h/In_d_d-d.parquet b/tables/scipy_special_tests/struve_h/In_d_d-d.parquet new file mode 100644 index 00000000..9b6f5ae8 Binary files /dev/null and b/tables/scipy_special_tests/struve_h/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/struve_h/Out_d_d-d.parquet b/tables/scipy_special_tests/struve_h/Out_d_d-d.parquet new file mode 100644 index 00000000..6caf5739 Binary files /dev/null and b/tables/scipy_special_tests/struve_h/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/struve_l/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/struve_l/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f96db50f Binary files /dev/null and b/tables/scipy_special_tests/struve_l/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/struve_l/In_d_d-d.parquet b/tables/scipy_special_tests/struve_l/In_d_d-d.parquet new file mode 100644 index 00000000..858766d9 Binary files /dev/null and b/tables/scipy_special_tests/struve_l/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/struve_l/Out_d_d-d.parquet b/tables/scipy_special_tests/struve_l/Out_d_d-d.parquet new file mode 100644 index 00000000..a0f721b6 Binary files /dev/null and b/tables/scipy_special_tests/struve_l/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/tandg/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/tandg/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..c2af5d8f Binary files /dev/null and b/tables/scipy_special_tests/tandg/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/tandg/In_d-d.parquet b/tables/scipy_special_tests/tandg/In_d-d.parquet new file mode 100644 index 00000000..e3211431 Binary files /dev/null and b/tables/scipy_special_tests/tandg/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/tandg/Out_d-d.parquet b/tables/scipy_special_tests/tandg/Out_d-d.parquet new file mode 100644 index 00000000..b46fad14 Binary files /dev/null and b/tables/scipy_special_tests/tandg/Out_d-d.parquet differ diff --git a/tables/scipy_special_tests/voigt_profile/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/voigt_profile/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..02b0c8d1 Binary files /dev/null and b/tables/scipy_special_tests/voigt_profile/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/voigt_profile/In_d_d_d-d.parquet b/tables/scipy_special_tests/voigt_profile/In_d_d_d-d.parquet new file mode 100644 index 00000000..6056fb8f Binary files /dev/null and b/tables/scipy_special_tests/voigt_profile/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/voigt_profile/Out_d_d_d-d.parquet b/tables/scipy_special_tests/voigt_profile/Out_d_d_d-d.parquet new file mode 100644 index 00000000..529efb30 Binary files /dev/null and b/tables/scipy_special_tests/voigt_profile/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/wofz/Err_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/wofz/Err_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..246e1492 Binary files /dev/null and b/tables/scipy_special_tests/wofz/Err_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/wofz/In_cd-cd.parquet b/tables/scipy_special_tests/wofz/In_cd-cd.parquet new file mode 100644 index 00000000..0ebfc380 Binary files /dev/null and b/tables/scipy_special_tests/wofz/In_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/wofz/Out_cd-cd.parquet b/tables/scipy_special_tests/wofz/Out_cd-cd.parquet new file mode 100644 index 00000000..93be9d80 Binary files /dev/null and b/tables/scipy_special_tests/wofz/Out_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/wright_bessel/Err_d_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/wright_bessel/Err_d_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f3fab2c0 Binary files /dev/null and b/tables/scipy_special_tests/wright_bessel/Err_d_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/wright_bessel/In_d_d_d-d.parquet b/tables/scipy_special_tests/wright_bessel/In_d_d_d-d.parquet new file mode 100644 index 00000000..37c0cc44 Binary files /dev/null and b/tables/scipy_special_tests/wright_bessel/In_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/wright_bessel/Out_d_d_d-d.parquet b/tables/scipy_special_tests/wright_bessel/Out_d_d_d-d.parquet new file mode 100644 index 00000000..1d876af8 Binary files /dev/null and b/tables/scipy_special_tests/wright_bessel/Out_d_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/xlog1py/Err_cd_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/xlog1py/Err_cd_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..94a4d843 Binary files /dev/null and b/tables/scipy_special_tests/xlog1py/Err_cd_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/xlog1py/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/xlog1py/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..111ce9e3 Binary files /dev/null and b/tables/scipy_special_tests/xlog1py/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/xlog1py/In_cd_cd-cd.parquet b/tables/scipy_special_tests/xlog1py/In_cd_cd-cd.parquet new file mode 100644 index 00000000..c7b951a5 Binary files /dev/null and b/tables/scipy_special_tests/xlog1py/In_cd_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/xlog1py/In_d_d-d.parquet b/tables/scipy_special_tests/xlog1py/In_d_d-d.parquet new file mode 100644 index 00000000..133879a9 Binary files /dev/null and b/tables/scipy_special_tests/xlog1py/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/xlog1py/Out_cd_cd-cd.parquet b/tables/scipy_special_tests/xlog1py/Out_cd_cd-cd.parquet new file mode 100644 index 00000000..c41e3ec0 Binary files /dev/null and b/tables/scipy_special_tests/xlog1py/Out_cd_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/xlog1py/Out_d_d-d.parquet b/tables/scipy_special_tests/xlog1py/Out_d_d-d.parquet new file mode 100644 index 00000000..1ae2ac08 Binary files /dev/null and b/tables/scipy_special_tests/xlog1py/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/xlogy/Err_cd_cd-cd_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/xlogy/Err_cd_cd-cd_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..cd6bd170 Binary files /dev/null and b/tables/scipy_special_tests/xlogy/Err_cd_cd-cd_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/xlogy/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/xlogy/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..75b1d758 Binary files /dev/null and b/tables/scipy_special_tests/xlogy/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/xlogy/Err_f_f-f_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/xlogy/Err_f_f-f_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..cb5e6282 Binary files /dev/null and b/tables/scipy_special_tests/xlogy/Err_f_f-f_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/xlogy/In_cd_cd-cd.parquet b/tables/scipy_special_tests/xlogy/In_cd_cd-cd.parquet new file mode 100644 index 00000000..0490c88f Binary files /dev/null and b/tables/scipy_special_tests/xlogy/In_cd_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/xlogy/In_d_d-d.parquet b/tables/scipy_special_tests/xlogy/In_d_d-d.parquet new file mode 100644 index 00000000..6b885eb8 Binary files /dev/null and b/tables/scipy_special_tests/xlogy/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/xlogy/In_f_f-f.parquet b/tables/scipy_special_tests/xlogy/In_f_f-f.parquet new file mode 100644 index 00000000..d5b6c1ed Binary files /dev/null and b/tables/scipy_special_tests/xlogy/In_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/xlogy/Out_cd_cd-cd.parquet b/tables/scipy_special_tests/xlogy/Out_cd_cd-cd.parquet new file mode 100644 index 00000000..c879766b Binary files /dev/null and b/tables/scipy_special_tests/xlogy/Out_cd_cd-cd.parquet differ diff --git a/tables/scipy_special_tests/xlogy/Out_d_d-d.parquet b/tables/scipy_special_tests/xlogy/Out_d_d-d.parquet new file mode 100644 index 00000000..ee20be13 Binary files /dev/null and b/tables/scipy_special_tests/xlogy/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/xlogy/Out_f_f-f.parquet b/tables/scipy_special_tests/xlogy/Out_f_f-f.parquet new file mode 100644 index 00000000..ed740abe Binary files /dev/null and b/tables/scipy_special_tests/xlogy/Out_f_f-f.parquet differ diff --git a/tables/scipy_special_tests/zeta/Err_d_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/zeta/Err_d_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..f0edf4f5 Binary files /dev/null and b/tables/scipy_special_tests/zeta/Err_d_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/zeta/In_d_d-d.parquet b/tables/scipy_special_tests/zeta/In_d_d-d.parquet new file mode 100644 index 00000000..2ad52c27 Binary files /dev/null and b/tables/scipy_special_tests/zeta/In_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/zeta/Out_d_d-d.parquet b/tables/scipy_special_tests/zeta/Out_d_d-d.parquet new file mode 100644 index 00000000..77797f51 Binary files /dev/null and b/tables/scipy_special_tests/zeta/Out_d_d-d.parquet differ diff --git a/tables/scipy_special_tests/zetac/Err_d-d_gcc-linux-x86_64.parquet b/tables/scipy_special_tests/zetac/Err_d-d_gcc-linux-x86_64.parquet new file mode 100644 index 00000000..91df4bda Binary files /dev/null and b/tables/scipy_special_tests/zetac/Err_d-d_gcc-linux-x86_64.parquet differ diff --git a/tables/scipy_special_tests/zetac/In_d-d.parquet b/tables/scipy_special_tests/zetac/In_d-d.parquet new file mode 100644 index 00000000..5eb8e41d Binary files /dev/null and b/tables/scipy_special_tests/zetac/In_d-d.parquet differ diff --git a/tables/scipy_special_tests/zetac/Out_d-d.parquet b/tables/scipy_special_tests/zetac/Out_d-d.parquet new file mode 100644 index 00000000..4fee7c67 Binary files /dev/null and b/tables/scipy_special_tests/zetac/Out_d-d.parquet differ diff --git a/tests/test_tables.py b/tests/test_tables.py new file mode 100644 index 00000000..9fa4150e --- /dev/null +++ b/tests/test_tables.py @@ -0,0 +1,187 @@ +import numpy as np +import os +import polars as pl +import pprint +import pyarrow as pa +import pyarrow.parquet as pq +import pytest +import warnings + +from numpy.testing import assert_allclose +from pathlib import Path + +import xsref + +from xsref.float_tools import extended_relative_error +from xsref.tables import _calculate_checksum, get_input_rows, get_output_rows +from xsref._reference._framework import XSRefFallbackWarning + + +def get_tables_paths(): + root_tables_path = Path(__file__).parents[1] / "tables" + output = [] + for input_table_path in root_tables_path.glob("**/In_*.parquet"): + output_table_path = ( + input_table_path.parent / input_table_path.name.replace("In_", "Out_") + ) + if not os.path.exists(output_table_path): + output_table_path = None + tol_pattern = input_table_path.name.replace( + "In_", "Err_" + ).removesuffix(".parquet") + tol_pattern = rf"{tol_pattern}*.parquet" + tol_table_paths = list(input_table_path.glob(tol_pattern)) + output.append((input_table_path, output_table_path, tol_table_paths)) + return output + + +def assert_typecode_matches_datatype(typecode, datatype): + match typecode: + case "d": + assert datatype == pa.float64() + case "f": + assert datatype == pa.float32() + case "i": + assert datatype == pa.int32() + case "p": + # intp types are 32bit on 32bit platforms and 64bit on 64 + # bit platforms. This is the default numpy int. We store + # these as 64 bit and cast to the correct type at test + # time. + assert datatype == pa.int64() + case _: + raise ValueError(f"Unsupported typecode {typecode}.") + + +@pytest.mark.parametrize( + "input_table_path,output_table_path,tol_table_paths", + get_tables_paths() +) +class TestTableIntegrity: + def test_checksums_match( + self, input_table_path, output_table_path, tol_table_paths + ): + # Test that the Sha256 checksum for the input table stored in the + # output table's metadata matches the actual Sha256 checksum of the + # input table. + if output_table_path is None: + return + input_table_checksum_expected = _calculate_checksum(input_table_path) + output_metadata = pq.read_schema(output_table_path).metadata + input_table_checksum_observed = ( + output_metadata[b"input_checksum"].decode("ascii") + ) + assert input_table_checksum_observed == input_table_checksum_expected + + output_table_checksum_expected = _calculate_checksum(output_table_path) + for tol_table_path in tol_table_paths: + tol_metadata = pq.read_schema(tol_table_path).metadata + input_table_checksum_observed = ( + tol_metadata[b"input_checksum"].decode("ascii") + ) + output_table_checksum_observed = ( + tol_metadata[b"output_checksum"].decode("ascii") + ) + + def test_consistent_type_signatures_metadata( + self, input_table_path, output_table_path, tol_table_paths + ): + if output_table_path is None: + return + # Tests that signature in input table metadata matches that in the + # output table metadata. + input_metadata = pq.read_schema(input_table_path).metadata + output_metadata = pq.read_schema(output_table_path).metadata + assert input_metadata[b"in"] == output_metadata[b"in"] + assert input_metadata[b"out"] == output_metadata[b"out"] + + for tol_table_path in tol_table_paths: + tol_metadata = pq.read_schema(tol_table_path).metadata + assert tol_metadata[b"in"] == output_metadata[b"in"] + assert tol_metadata[b"out"] == output_metadata[b"out"] + + def test_consistent_type_signatures_metadata_filename( + self, input_table_path, output_table_path, tol_table_paths + ): + # Tests that signature in the input table filename matches that in the + # input table metadata. + input_metadata = pq.read_schema(input_table_path).metadata + input_table_types_from_filename = ( + input_table_path.name.removesuffix(".parquet") + ).replace("In_", "").replace("cd", "D").replace("cf", "F").replace("_", "") + + intypes_filename, outtypes_filename = input_table_types_from_filename.split("-") + assert input_metadata[b"in"] == intypes_filename.encode("ascii") + assert input_metadata[b"out"] == outtypes_filename.encode("ascii") + + def test_consistent_column_types_input( + self, input_table_path, output_table_path, tol_table_paths + ): + # Test input types in parquet columns match input types in metadata. + input_schema = pq.read_schema(input_table_path) + in_typecodes = input_schema.metadata[b"in"].decode("ascii") + in_types = input_schema.types + + i = 0 + for typecode in in_typecodes: + if typecode == "F": + assert in_types[i] == pa.float32() + assert in_types[i+1] == pa.float32() + i += 2 + elif typecode == "D": + assert in_types[i] == pa.float64() + assert in_types[i+1] == pa.float64() + i += 2 + else: + assert_typecode_matches_datatype(typecode, in_types[i]) + i += 1 + + def test_consistent_column_types_output( + self, input_table_path, output_table_path, tol_table_paths + ): + # Test input types in parquet columns match input types in metadata. + output_schema = pq.read_schema(output_table_path) + out_typecodes = output_schema.metadata[b"out"].decode("ascii") + out_types = output_schema.types + + i = 0 + for typecode in out_typecodes: + if typecode == "F": + assert out_types[i] == pa.float32() + assert out_types[i+1] == pa.float32() + i += 2 + elif typecode == "D": + assert out_types[i] == pa.float64() + assert out_types[i+1] == pa.float64() + i += 2 + else: + assert_typecode_matches_datatype(typecode, out_types[i]) + i += 1 + + + def test_num_rows_match( + self, input_table_path, output_table_path, tol_table_paths + ): + # Check that the inputs table as the same number of rows as + # the outputs table. + if output_table_path is None: + return + input_table = pq.read_table(input_table_path) + output_table = pq.read_table(output_table_path) + assert len(input_table) == len(output_table) + + for tol_table_path in tol_table_paths: + tol_table = pq.read_table(tol_table_path) + assert len(tol_table) == len(output_table) + + def test_working_tree_clean( + self, input_table_path, output_table_path, tol_table_paths + ): + output_metadata = pq.read_schema(output_table_path).metadata + working_tree_state = output_metadata[b"working_tree_state"].decode("ascii") + assert working_tree_state == "clean" + + for tol_table_path in tol_table_paths: + tol_metadata = pq.read_schema(tol_table_path).metadata + working_tree_state = tol_metadata[b"working_tree_state"].decode("ascii") + assert working_tree_state == "clean"