linalg.eigh incorrect results for complex data on osx-arm64

[jcmgray]

Solution to issue cannot be found in the documentation.

• I checked the documentation.

Issue

On osx-arm64 with numpy==1.24 installed from conda-forge, np.linalg.eigh produces incorrect results for complex data types:

import numpy as np

d = 3
A = np.random.randn(d, d) + 1j * np.random.randn(d, d)
A = (A + A.conj().T)

el, ev = np.linalg.eigh(A)

# following should all be close to zero
print(np.linalg.norm(np.identity(d) - (ev @ ev.conj().T)))
# 4.115852147734368
print(np.linalg.norm(np.identity(d) - (ev.conj().T @ ev)))
# 4.115852147734368
print(np.linalg.norm(A - (ev @ np.diag(el) @ ev.conj().T)))
# 11.555496471473255

Other linalg such as svd appears to be working (though I haven't checked exhaustively).

I have checked this with:

• blas=*=acclerate
• blas=*=netlib

(Can't check with blas=*=openblas as this doesn't appear to work more generally)

Using numpy from pypi the code is working fine. Thus raising the issue here assuming it is something to do with the linked lapack, but apologies if this should be in the main numpy repo.

Possibly related to #21950, thought the issue here is not simply normalization of the eigenvectors.

Installed packages

# packages in environment at /Users/johnnie/conda/envs/numpy-latest:
#
# Name                    Version                   Build  Channel
bzip2                     1.0.8                h620ffc9_4  
ca-certificates           2022.10.11           hca03da5_0  
certifi                   2022.9.24       py311hca03da5_0  
libblas                   3.9.0           1_h9886b1c_netlib  
libcblas                  3.9.0           1_h9886b1c_netlib  
libcxx                    14.0.6               h848a8c0_0  
libffi                    3.4.2                hca03da5_6  
libgfortran               5.0.0           11_3_0_hca03da5_28  
libgfortran5              11.3.0              h009349e_28  
liblapack                 3.9.0           1_h9886b1c_netlib  
libsqlite                 3.40.0               h76d750c_0    conda-forge
libzlib                   1.2.13               h03a7124_4    conda-forge
llvm-openmp               14.0.6               hc6e5704_0  
ncurses                   6.3                  h1a28f6b_3  
numpy                     1.24.1          py311ha92fb03_0    conda-forge
openssl                   3.0.7                h03a7124_1    conda-forge
pip                       22.2.2          py311hca03da5_0  
python                    3.11.0          h3ba56d0_1_cpython    conda-forge
python_abi                3.11                    3_cp311    conda-forge
readline                  8.2                  h1a28f6b_0  
setuptools                65.5.0          py311hca03da5_0  
tk                        8.6.12               hb8d0fd4_0  
tzdata                    2022g                h04d1e81_0  
wheel                     0.37.1             pyhd3eb1b0_0  
xz                        5.2.8                h80987f9_0  
zlib                      1.2.13               h03a7124_4    conda-forge

Environment info

active environment : numpy-latest
    active env location : /Users/johnnie/conda/envs/numpy-latest
            shell level : 2
       user config file : /Users/johnnie/.condarc
 populated config files : /Users/johnnie/.condarc
          conda version : 22.11.1
    conda-build version : not installed
         python version : 3.9.15.final.0
       virtual packages : __archspec=1=arm64
                          __osx=13.1=0
                          __unix=0=0
       base environment : /Users/johnnie/conda  (writable)
      conda av data dir : /Users/johnnie/conda/etc/conda
  conda av metadata url : None
           channel URLs : https://repo.anaconda.com/pkgs/main/osx-arm64
                          https://repo.anaconda.com/pkgs/main/noarch
                          https://repo.anaconda.com/pkgs/r/osx-arm64
                          https://repo.anaconda.com/pkgs/r/noarch
                          https://conda.anaconda.org/conda-forge/osx-arm64
                          https://conda.anaconda.org/conda-forge/noarch
          package cache : /Users/johnnie/conda/pkgs
                          /Users/johnnie/.conda/pkgs
       envs directories : /Users/johnnie/conda/envs
                          /Users/johnnie/.conda/envs
               platform : osx-arm64
             user-agent : conda/22.11.1 requests/2.28.1 CPython/3.9.15 Darwin/22.2.0 OSX/13.1
                UID:GID : 501:20
             netrc file : None
           offline mode : False

[rgommers]

Thanks for the report @jcmgray. This looks suspiciously similar to numpy/numpy#21950, which ended up being a gfortran bug.

(Can't check with blas=*=openblas as this doesn't appear to work more generally)

That's a little odd. Either way, openblas is the default so a simple mamba create -n tmp-env numpy=1.24.1 will use openblas.

[rgommers]

I can confirm the problem with netlib and accelerate, while openblas works fine:

% mamba create -n numpy-arm64-issue python=3.11 numpy=1.24.1  # uses openblas
% mamba activate numpy-arm64-issue
% python eigh_issue.py
7.67097720664267e-16
7.703544722840589e-16
4.057796502112606e-15

% mamba install "libblas=*=*netlib"
% python eigh_issue.py
1.7417791256257247
1.741779125625725
7.5457859052319

% mamba install "libblas=*=*accelerate"
% python eigh_issue.py
1.7299060495984222
1.7299060495984222
7.154916026621027

% mamba install "libblas=*=*openblas"  # works fine

[rgommers]

There are other test failures. Here is the numpy.linalg test suite result for accelerate:

FAILED tests/test_linalg.py::TestSVDHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestPinvHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestEighCases::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
3 failed, 383 passed, 2 skipped, 27 deselected, 2 xfailed in 1.63s

python -c "import numpy; numpy.linalg.test()"
/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/_pytesttester.py:143: DeprecationWarning:

  `numpy.distutils` is deprecated since NumPy 1.23.0, as a result
  of the deprecation of `distutils` itself. It will be removed for
  Python >= 3.12. For older Python versions it will remain present.
  It is recommended to use `setuptools < 60.0` for those Python versions.
  For more details, see:
    https://numpy.org/devdocs/reference/distutils_status_migration.html


  from numpy.distutils import cpuinfo
NumPy version 1.24.1
NumPy relaxed strides checking option: True
NumPy CPU features:  NEON NEON_FP16 NEON_VFPV4 ASIMD ASIMDHP* ASIMDDP* ASIMDFHM?
.........................................F.....x.....F.................................................................................. [ 34%]
.....................................................................................F.................................................. [ 69%]
..................................................................................s........................sx.........                   [100%]
=================================================================== FAILURES ===================================================================
_______________________________________________________ TestSVDHermitian.test_herm_cases _______________________________________________________

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
>               case.check(self.do)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...-08j,  3.780841+3.951701e+00j],\n       [ 3.780841-3.951701e+00j,  0.848612-5.960464e-08j]],\n      dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:350:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <LinalgCase: hcsingle>
do = <bound method SVDHermitianCases.do of <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>>

    def check(self, do):
        """
        Run the function `do` on this test case, expanding arguments
        """
>       do(self.a, self.b, tags=self.tags)

do         = <bound method SVDHermitianCases.do of <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>>
self       = <LinalgCase: hcsingle>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:85:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>
a = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), b = None, tags = frozenset({'hermitian'})

    def do(self, a, b, tags):
        u, s, vt = linalg.svd(a, False, hermitian=True)
>       assert_allclose(a, dot_generalized(np.asarray(u) * np.asarray(s)[..., None, :],
                                           np.asarray(vt)),
                        rtol=get_rtol(u.dtype))

a          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
b          = None
s          = array([4.6055512, 2.6055512], dtype=float32)
self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>
tags       = frozenset({'hermitian'})
u          = array([[-0.70710677-0.20710678j, -0.70710677-0.70710677j],
       [-0.8082574 +0.31099832j,  0.9805807 -0.19611613j]],
      dtype=complex64)
vt         = array([[-0.70710677+0.20710678j, -0.8082574 -0.31099832j],
       [ 0.70710677-0.70710677j, -0.9805807 -0.19611613j]],
      dtype=complex64)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:680:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
desired = array([[-0.10522884+5.9604645e-08j,  3.780841  +3.9517009e+00j],
       [ 3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j]],
      dtype=complex64)
rtol = 1e-05, atol = 0, equal_nan = True, err_msg = '', verbose = True

    def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
                        err_msg='', verbose=True):
        """
        Raises an AssertionError if two objects are not equal up to desired
        tolerance.

        Given two array_like objects, check that their shapes and all elements
        are equal (but see the Notes for the special handling of a scalar). An
        exception is raised if the shapes mismatch or any values conflict. In
        contrast to the standard usage in numpy, NaNs are compared like numbers,
        no assertion is raised if both objects have NaNs in the same positions.

        The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
        that ``allclose`` has different default values). It compares the difference
        between `actual` and `desired` to ``atol + rtol * abs(desired)``.

        .. versionadded:: 1.5.0

        Parameters
        ----------
        actual : array_like
            Array obtained.
        desired : array_like
            Array desired.
        rtol : float, optional
            Relative tolerance.
        atol : float, optional
            Absolute tolerance.
        equal_nan : bool, optional.
            If True, NaNs will compare equal.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
            If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_array_almost_equal_nulp, assert_array_max_ulp

        Notes
        -----
        When one of `actual` and `desired` is a scalar and the other is
        array_like, the function checks that each element of the array_like
        object is equal to the scalar.

        Examples
        --------
        >>> x = [1e-5, 1e-3, 1e-1]
        >>> y = np.arccos(np.cos(x))
        >>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        import numpy as np

        def compare(x, y):
            return np.core.numeric.isclose(x, y, rtol=rtol, atol=atol,
                                           equal_nan=equal_nan)

        actual, desired = np.asanyarray(actual), np.asanyarray(desired)
        header = f'Not equal to tolerance rtol={rtol:g}, atol={atol:g}'
>       assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
                             verbose=verbose, header=header, equal_nan=equal_nan)

__tracebackhide__ = True
actual     = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
atol       = 0
compare    = <function assert_allclose.<locals>.compare at 0x10c89ab60>
desired    = array([[-0.10522884+5.9604645e-08j,  3.780841  +3.9517009e+00j],
       [ 3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j]],
      dtype=complex64)
equal_nan  = True
err_msg    = ''
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
np         = <module 'numpy' from '/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/__init__.py'>
rtol       = 1e-05
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:1590:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (<function assert_allclose.<locals>.compare at 0x10c89ab60>, array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=...  3.780841  +3.9517009e+00j],
       [ 3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j]],
      dtype=complex64))
kwds = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (<function assert_allclose.<locals>.compare at 0x10c89ab60>, array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=...  3.780841  +3.9517009e+00j],
       [ 3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j]],
      dtype=complex64))
func       = <function assert_array_compare at 0x107ecaac0>
kwds       = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}
self       = <contextlib._GeneratorContextManager object at 0x107edb750>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

comparison = <function assert_allclose.<locals>.compare at 0x10c89ab60>, x = array([1.+0.j, 2.+3.j, 2.-3.j, 1.+0.j], dtype=complex64)
y = array([-0.10522884+5.9604645e-08j,  3.780841  +3.9517009e+00j,
        3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j],
      dtype=complex64)
err_msg = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 2.0191903\nMax relative difference: 10.5030985', verbose = True
header = 'Not equal to tolerance rtol=1e-05, atol=0', precision = 6, equal_nan = True, equal_inf = True

    @np._no_nep50_warning()
    def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                             precision=6, equal_nan=True, equal_inf=True,
                             *, strict=False):
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_

        x = np.asanyarray(x)
        y = np.asanyarray(y)

        # original array for output formatting
        ox, oy = x, y

        def isnumber(x):
            return x.dtype.char in '?bhilqpBHILQPefdgFDG'

        def istime(x):
            return x.dtype.char in "Mm"

        def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
            """Handling nan/inf.

            Combine results of running func on x and y, checking that they are True
            at the same locations.

            """
            __tracebackhide__ = True  # Hide traceback for py.test

            x_id = func(x)
            y_id = func(y)
            # We include work-arounds here to handle three types of slightly
            # pathological ndarray subclasses:
            # (1) all() on `masked` array scalars can return masked arrays, so we
            #     use != True
            # (2) __eq__ on some ndarray subclasses returns Python booleans
            #     instead of element-wise comparisons, so we cast to bool_() and
            #     use isinstance(..., bool) checks
            # (3) subclasses with bare-bones __array_function__ implementations may
            #     not implement np.all(), so favor using the .all() method
            # We are not committed to supporting such subclasses, but it's nice to
            # support them if possible.
            if bool_(x_id == y_id).all() != True:
                msg = build_err_msg([x, y],
                                    err_msg + '\nx and y %s location mismatch:'
                                    % (hasval), verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)
            # If there is a scalar, then here we know the array has the same
            # flag as it everywhere, so we should return the scalar flag.
            if isinstance(x_id, bool) or x_id.ndim == 0:
                return bool_(x_id)
            elif isinstance(y_id, bool) or y_id.ndim == 0:
                return bool_(y_id)
            else:
                return y_id

        try:
            if strict:
                cond = x.shape == y.shape and x.dtype == y.dtype
            else:
                cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
            if not cond:
                if x.shape != y.shape:
                    reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
                else:
                    reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
                msg = build_err_msg([x, y],
                                    err_msg
                                    + reason,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)

            flagged = bool_(False)
            if isnumber(x) and isnumber(y):
                if equal_nan:
                    flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')

                if equal_inf:
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == +inf,
                                                    hasval='+inf')
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == -inf,
                                                    hasval='-inf')

            elif istime(x) and istime(y):
                # If one is datetime64 and the other timedelta64 there is no point
                if equal_nan and x.dtype.type == y.dtype.type:
                    flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")

            if flagged.ndim > 0:
                x, y = x[~flagged], y[~flagged]
                # Only do the comparison if actual values are left
                if x.size == 0:
                    return
            elif flagged:
                # no sense doing comparison if everything is flagged.
                return

            val = comparison(x, y)

            if isinstance(val, bool):
                cond = val
                reduced = array([val])
            else:
                reduced = val.ravel()
                cond = reduced.all()

            # The below comparison is a hack to ensure that fully masked
            # results, for which val.ravel().all() returns np.ma.masked,
            # do not trigger a failure (np.ma.masked != True evaluates as
            # np.ma.masked, which is falsy).
            if cond != True:
                n_mismatch = reduced.size - reduced.sum(dtype=intp)
                n_elements = flagged.size if flagged.ndim != 0 else reduced.size
                percent_mismatch = 100 * n_mismatch / n_elements
                remarks = [
                    'Mismatched elements: {} / {} ({:.3g}%)'.format(
                        n_mismatch, n_elements, percent_mismatch)]

                with errstate(all='ignore'):
                    # ignore errors for non-numeric types
                    with contextlib.suppress(TypeError):
                        error = abs(x - y)
                        if np.issubdtype(x.dtype, np.unsignedinteger):
                            error2 = abs(y - x)
                            np.minimum(error, error2, out=error)
                        max_abs_error = max(error)
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max absolute difference: '
                                            + str(max_abs_error))
                        else:
                            remarks.append('Max absolute difference: '
                                            + array2string(max_abs_error))

                        # note: this definition of relative error matches that one
                        # used by assert_allclose (found in np.isclose)
                        # Filter values where the divisor would be zero
                        nonzero = bool_(y != 0)
                        if all(~nonzero):
                            max_rel_error = array(inf)
                        else:
                            max_rel_error = max(error[nonzero] / abs(y[nonzero]))
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max relative difference: '
                                            + str(max_rel_error))
                        else:
                            remarks.append('Max relative difference: '
                                            + array2string(max_rel_error))

                err_msg += '\n' + '\n'.join(remarks)
                msg = build_err_msg([ox, oy], err_msg,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
>               raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 2.0191903
E               Max relative difference: 10.5030985
E                x: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)
E                y: array([[-0.105229+5.960464e-08j,  3.780841+3.951701e+00j],
E                      [ 3.780841-3.951701e+00j,  0.848612-5.960464e-08j]],
E                     dtype=complex64)

__tracebackhide__ = True
all        = <function all at 0x1054b8720>
array      = <built-in function array>
array2string = <function array2string at 0x1054c7560>
bool_      = <class 'numpy.bool_'>
comparison = <function assert_allclose.<locals>.compare at 0x10c89ab60>
cond       = False
equal_inf  = True
equal_nan  = True
err_msg    = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 2.0191903\nMax relative difference: 10.5030985'
error      = array([1.1052289 , 2.0191903 , 2.0191903 , 0.15138829], dtype=float32)
errstate   = <class 'numpy.errstate'>
flagged    = array([[False, False],
       [False, False]])
func_assert_same_pos = <function assert_array_compare.<locals>.func_assert_same_pos at 0x10c89ad40>
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
inf        = inf
isnan      = <ufunc 'isnan'>
isnumber   = <function assert_array_compare.<locals>.isnumber at 0x10c89ac00>
istime     = <function assert_array_compare.<locals>.istime at 0x10c89aca0>
max        = <function amax at 0x1054b8cc0>
max_abs_error = 2.0191903
max_rel_error = 10.5030985
msg        = '\nNot equal to tolerance rtol=1e-05, atol=0\n\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 2.0191903\...4e-08j,  3.780841+3.951701e+00j],\n       [ 3.780841-3.951701e+00j,  0.848612-5.960464e-08j]],\n      dtype=complex64)'
n_elements = 4
n_mismatch = 4
nonzero    = array([ True,  True,  True,  True])
object_    = <class 'numpy.object_'>
ox         = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
oy         = array([[-0.10522884+5.9604645e-08j,  3.780841  +3.9517009e+00j],
       [ 3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j]],
      dtype=complex64)
percent_mismatch = 100.0
precision  = 6
reduced    = array([False, False, False, False])
remarks    = ['Mismatched elements: 4 / 4 (100%)', 'Max absolute difference: 2.0191903', 'Max relative difference: 10.5030985']
strict     = False
val        = array([False, False, False, False])
verbose    = True
x          = array([1.+0.j, 2.+3.j, 2.-3.j, 1.+0.j], dtype=complex64)
y          = array([-0.10522884+5.9604645e-08j,  3.780841  +3.9517009e+00j,
        3.780841  -3.9517009e+00j,  0.8486117 -5.9604645e-08j],
      dtype=complex64)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:862: AssertionError

The above exception was the direct cause of the following exception:

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>

    def test_herm_cases(self):
>       self.check_cases(require={'hermitian'},
                         exclude={'generalized', 'size-0'})

self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:382:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
                case.check(self.do)
            except Exception as e:
                msg = f'In test case: {case!r}\n\n'
                msg += traceback.format_exc()
>               raise AssertionError(msg) from e
E               AssertionError: In test case: <LinalgCase: hcsingle>
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 350, in check_cases
E                   case.check(self.do)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 85, in check
E                   do(self.a, self.b, tags=self.tags)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 680, in do
E                   assert_allclose(a, dot_generalized(np.asarray(u) * np.asarray(s)[..., None, :],
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 1590, in assert_allclose
E                   assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 862, in assert_array_compare
E                   raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 2.0191903
E               Max relative difference: 10.5030985
E                x: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)
E                y: array([[-0.105229+5.960464e-08j,  3.780841+3.951701e+00j],
E                      [ 3.780841-3.951701e+00j,  0.848612-5.960464e-08j]],
E                     dtype=complex64)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...-08j,  3.780841+3.951701e+00j],\n       [ 3.780841-3.951701e+00j,  0.848612-5.960464e-08j]],\n      dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x10af68450>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:354: AssertionError
______________________________________________________ TestPinvHermitian.test_herm_cases _______________________________________________________

actual = array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64)
desired = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
        """
        Raises an AssertionError if two items are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies that the elements of `actual` and `desired` satisfy.

            ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``

        That is a looser test than originally documented, but agrees with what the
        actual implementation in `assert_array_almost_equal` did up to rounding
        vagaries. An exception is raised at conflicting values. For ndarrays this
        delegates to assert_array_almost_equal

        Parameters
        ----------
        actual : array_like
            The object to check.
        desired : array_like
            The expected object.
        decimal : int, optional
            Desired precision, default is 7.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
          If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        >>> from numpy.testing import assert_almost_equal
        >>> assert_almost_equal(2.3333333333333, 2.33333334)
        >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 10 decimals
         ACTUAL: 2.3333333333333
         DESIRED: 2.33333334

        >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
        ...                     np.array([1.0,2.33333334]), decimal=9)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 9 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 2 (50%)
        Max absolute difference: 6.66669964e-09
        Max relative difference: 2.85715698e-09
         x: array([1.         , 2.333333333])
         y: array([1.        , 2.33333334])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import ndarray
        from numpy.lib import iscomplexobj, real, imag

        # Handle complex numbers: separate into real/imag to handle
        # nan/inf/negative zero correctly
        # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
        try:
            usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
        except ValueError:
            usecomplex = False

        def _build_err_msg():
            header = ('Arrays are not almost equal to %d decimals' % decimal)
            return build_err_msg([actual, desired], err_msg, verbose=verbose,
                                 header=header)

        if usecomplex:
            if iscomplexobj(actual):
                actualr = real(actual)
                actuali = imag(actual)
            else:
                actualr = actual
                actuali = 0
            if iscomplexobj(desired):
                desiredr = real(desired)
                desiredi = imag(desired)
            else:
                desiredr = desired
                desiredi = 0
            try:
>               assert_almost_equal(actualr, desiredr, decimal=decimal)

__tracebackhide__ = True
_build_err_msg = <function assert_almost_equal.<locals>._build_err_msg at 0x10c970360>
actual     = array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64)
actuali    = array([[ 2.3841858e-07,  4.2373457e+00],
       [-4.2373452e+00,  5.9604645e-08]], dtype=float32)
actualr    = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32)
decimal    = 5
desired    = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
desiredi   = array([[ 0.,  3.],
       [-3.,  0.]], dtype=float32)
desiredr   = array([[1., 2.],
       [2., 1.]], dtype=float32)
err_msg    = ''
imag       = <function imag at 0x1055d80e0>
iscomplexobj = <function iscomplexobj at 0x1055d8540>
ndarray    = <class 'numpy.ndarray'>
real       = <function real at 0x1055cfec0>
usecomplex = True
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:581:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
kwds = {'decimal': 5}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
func       = <function assert_almost_equal at 0x107eca840>
kwds       = {'decimal': 5}
self       = <contextlib._GeneratorContextManager object at 0x107ed3210>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32)
desired = array([[1., 2.],
       [2., 1.]], dtype=float32), decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
        """
        Raises an AssertionError if two items are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies that the elements of `actual` and `desired` satisfy.

            ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``

        That is a looser test than originally documented, but agrees with what the
        actual implementation in `assert_array_almost_equal` did up to rounding
        vagaries. An exception is raised at conflicting values. For ndarrays this
        delegates to assert_array_almost_equal

        Parameters
        ----------
        actual : array_like
            The object to check.
        desired : array_like
            The expected object.
        decimal : int, optional
            Desired precision, default is 7.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
          If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        >>> from numpy.testing import assert_almost_equal
        >>> assert_almost_equal(2.3333333333333, 2.33333334)
        >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 10 decimals
         ACTUAL: 2.3333333333333
         DESIRED: 2.33333334

        >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
        ...                     np.array([1.0,2.33333334]), decimal=9)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 9 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 2 (50%)
        Max absolute difference: 6.66669964e-09
        Max relative difference: 2.85715698e-09
         x: array([1.         , 2.333333333])
         y: array([1.        , 2.33333334])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import ndarray
        from numpy.lib import iscomplexobj, real, imag

        # Handle complex numbers: separate into real/imag to handle
        # nan/inf/negative zero correctly
        # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
        try:
            usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
        except ValueError:
            usecomplex = False

        def _build_err_msg():
            header = ('Arrays are not almost equal to %d decimals' % decimal)
            return build_err_msg([actual, desired], err_msg, verbose=verbose,
                                 header=header)

        if usecomplex:
            if iscomplexobj(actual):
                actualr = real(actual)
                actuali = imag(actual)
            else:
                actualr = actual
                actuali = 0
            if iscomplexobj(desired):
                desiredr = real(desired)
                desiredi = imag(desired)
            else:
                desiredr = desired
                desiredi = 0
            try:
                assert_almost_equal(actualr, desiredr, decimal=decimal)
                assert_almost_equal(actuali, desiredi, decimal=decimal)
            except AssertionError:
                raise AssertionError(_build_err_msg())

        if isinstance(actual, (ndarray, tuple, list)) \
                or isinstance(desired, (ndarray, tuple, list)):
>           return assert_array_almost_equal(actual, desired, decimal, err_msg)

__tracebackhide__ = True
_build_err_msg = <function assert_almost_equal.<locals>._build_err_msg at 0x10c970540>
actual     = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32)
decimal    = 5
desired    = array([[1., 2.],
       [2., 1.]], dtype=float32)
err_msg    = ''
imag       = <function imag at 0x1055d80e0>
iscomplexobj = <function iscomplexobj at 0x1055d8540>
ndarray    = <class 'numpy.ndarray'>
real       = <function real at 0x1055cfec0>
usecomplex = False
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:588:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32), 5, '')
kwds = {}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32), 5, '')
func       = <function assert_array_almost_equal at 0x107ecaca0>
kwds       = {}
self       = <contextlib._GeneratorContextManager object at 0x107edb910>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), y = array([[1., 2.],
       [2., 1.]], dtype=float32)
decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
        """
        Raises an AssertionError if two objects are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies identical shapes and that the elements of ``actual`` and
        ``desired`` satisfy.

            ``abs(desired-actual) < 1.5 * 10**(-decimal)``

        That is a looser test than originally documented, but agrees with what the
        actual implementation did up to rounding vagaries. An exception is raised
        at shape mismatch or conflicting values. In contrast to the standard usage
        in numpy, NaNs are compared like numbers, no assertion is raised if both
        objects have NaNs in the same positions.

        Parameters
        ----------
        x : array_like
            The actual object to check.
        y : array_like
            The desired, expected object.
        decimal : int, optional
            Desired precision, default is 6.
        err_msg : str, optional
          The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
            If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        the first assert does not raise an exception

        >>> np.testing.assert_array_almost_equal([1.0,2.333,np.nan],
        ...                                      [1.0,2.333,np.nan])

        >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
        ...                                      [1.0,2.33339,np.nan], decimal=5)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 5 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 3 (33.3%)
        Max absolute difference: 6.e-05
        Max relative difference: 2.57136612e-05
         x: array([1.     , 2.33333,     nan])
         y: array([1.     , 2.33339,     nan])

        >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
        ...                                      [1.0,2.33333, 5], decimal=5)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 5 decimals
        <BLANKLINE>
        x and y nan location mismatch:
         x: array([1.     , 2.33333,     nan])
         y: array([1.     , 2.33333, 5.     ])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import number, float_, result_type, array
        from numpy.core.numerictypes import issubdtype
        from numpy.core.fromnumeric import any as npany

        def compare(x, y):
            try:
                if npany(gisinf(x)) or npany( gisinf(y)):
                    xinfid = gisinf(x)
                    yinfid = gisinf(y)
                    if not (xinfid == yinfid).all():
                        return False
                    # if one item, x and y is +- inf
                    if x.size == y.size == 1:
                        return x == y
                    x = x[~xinfid]
                    y = y[~yinfid]
            except (TypeError, NotImplementedError):
                pass

            # make sure y is an inexact type to avoid abs(MIN_INT); will cause
            # casting of x later.
            dtype = result_type(y, 1.)
            y = np.asanyarray(y, dtype)
            z = abs(x - y)

            if not issubdtype(z.dtype, number):
                z = z.astype(float_)  # handle object arrays

            return z < 1.5 * 10.0**(-decimal)

>       assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
                 header=('Arrays are not almost equal to %d decimals' % decimal),
                 precision=decimal)

__tracebackhide__ = True
array      = <built-in function array>
compare    = <function assert_array_almost_equal.<locals>.compare at 0x10c9705e0>
decimal    = 5
err_msg    = ''
float_     = <class 'numpy.float64'>
issubdtype = <function issubdtype at 0x104dc44a0>
npany      = <function any at 0x1054b8540>
number     = <class 'numpy.number'>
result_type = <function result_type at 0x10545f920>
verbose    = True
x          = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32)
y          = array([[1., 2.],
       [2., 1.]], dtype=float32)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:1097:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (<function assert_array_almost_equal.<locals>.compare at 0x10c9705e0>, array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
kwds = {'err_msg': '', 'header': 'Arrays are not almost equal to 5 decimals', 'precision': 5, 'verbose': True}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (<function assert_array_almost_equal.<locals>.compare at 0x10c9705e0>, array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
func       = <function assert_array_compare at 0x107ecaac0>
kwds       = {'err_msg': '', 'header': 'Arrays are not almost equal to 5 decimals', 'precision': 5, 'verbose': True}
self       = <contextlib._GeneratorContextManager object at 0x107edb750>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

comparison = <function assert_array_almost_equal.<locals>.compare at 0x10c9705e0>
x = array([0.5743457 , 3.473448  , 3.4734483 , 0.03471792], dtype=float32), y = array([1., 2., 2., 1.], dtype=float32)
err_msg = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 1.4734483\nMax relative difference: 0.9652821', verbose = True
header = 'Arrays are not almost equal to 5 decimals', precision = 5, equal_nan = True, equal_inf = True

    @np._no_nep50_warning()
    def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                             precision=6, equal_nan=True, equal_inf=True,
                             *, strict=False):
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_

        x = np.asanyarray(x)
        y = np.asanyarray(y)

        # original array for output formatting
        ox, oy = x, y

        def isnumber(x):
            return x.dtype.char in '?bhilqpBHILQPefdgFDG'

        def istime(x):
            return x.dtype.char in "Mm"

        def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
            """Handling nan/inf.

            Combine results of running func on x and y, checking that they are True
            at the same locations.

            """
            __tracebackhide__ = True  # Hide traceback for py.test

            x_id = func(x)
            y_id = func(y)
            # We include work-arounds here to handle three types of slightly
            # pathological ndarray subclasses:
            # (1) all() on `masked` array scalars can return masked arrays, so we
            #     use != True
            # (2) __eq__ on some ndarray subclasses returns Python booleans
            #     instead of element-wise comparisons, so we cast to bool_() and
            #     use isinstance(..., bool) checks
            # (3) subclasses with bare-bones __array_function__ implementations may
            #     not implement np.all(), so favor using the .all() method
            # We are not committed to supporting such subclasses, but it's nice to
            # support them if possible.
            if bool_(x_id == y_id).all() != True:
                msg = build_err_msg([x, y],
                                    err_msg + '\nx and y %s location mismatch:'
                                    % (hasval), verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)
            # If there is a scalar, then here we know the array has the same
            # flag as it everywhere, so we should return the scalar flag.
            if isinstance(x_id, bool) or x_id.ndim == 0:
                return bool_(x_id)
            elif isinstance(y_id, bool) or y_id.ndim == 0:
                return bool_(y_id)
            else:
                return y_id

        try:
            if strict:
                cond = x.shape == y.shape and x.dtype == y.dtype
            else:
                cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
            if not cond:
                if x.shape != y.shape:
                    reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
                else:
                    reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
                msg = build_err_msg([x, y],
                                    err_msg
                                    + reason,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)

            flagged = bool_(False)
            if isnumber(x) and isnumber(y):
                if equal_nan:
                    flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')

                if equal_inf:
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == +inf,
                                                    hasval='+inf')
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == -inf,
                                                    hasval='-inf')

            elif istime(x) and istime(y):
                # If one is datetime64 and the other timedelta64 there is no point
                if equal_nan and x.dtype.type == y.dtype.type:
                    flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")

            if flagged.ndim > 0:
                x, y = x[~flagged], y[~flagged]
                # Only do the comparison if actual values are left
                if x.size == 0:
                    return
            elif flagged:
                # no sense doing comparison if everything is flagged.
                return

            val = comparison(x, y)

            if isinstance(val, bool):
                cond = val
                reduced = array([val])
            else:
                reduced = val.ravel()
                cond = reduced.all()

            # The below comparison is a hack to ensure that fully masked
            # results, for which val.ravel().all() returns np.ma.masked,
            # do not trigger a failure (np.ma.masked != True evaluates as
            # np.ma.masked, which is falsy).
            if cond != True:
                n_mismatch = reduced.size - reduced.sum(dtype=intp)
                n_elements = flagged.size if flagged.ndim != 0 else reduced.size
                percent_mismatch = 100 * n_mismatch / n_elements
                remarks = [
                    'Mismatched elements: {} / {} ({:.3g}%)'.format(
                        n_mismatch, n_elements, percent_mismatch)]

                with errstate(all='ignore'):
                    # ignore errors for non-numeric types
                    with contextlib.suppress(TypeError):
                        error = abs(x - y)
                        if np.issubdtype(x.dtype, np.unsignedinteger):
                            error2 = abs(y - x)
                            np.minimum(error, error2, out=error)
                        max_abs_error = max(error)
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max absolute difference: '
                                            + str(max_abs_error))
                        else:
                            remarks.append('Max absolute difference: '
                                            + array2string(max_abs_error))

                        # note: this definition of relative error matches that one
                        # used by assert_allclose (found in np.isclose)
                        # Filter values where the divisor would be zero
                        nonzero = bool_(y != 0)
                        if all(~nonzero):
                            max_rel_error = array(inf)
                        else:
                            max_rel_error = max(error[nonzero] / abs(y[nonzero]))
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max relative difference: '
                                            + str(max_rel_error))
                        else:
                            remarks.append('Max relative difference: '
                                            + array2string(max_rel_error))

                err_msg += '\n' + '\n'.join(remarks)
                msg = build_err_msg([ox, oy], err_msg,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
>               raise AssertionError(msg)
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 1.4734483
E               Max relative difference: 0.9652821
E                x: array([[0.57435, 3.47345],
E                      [3.47345, 0.03472]], dtype=float32)
E                y: array([[1., 2.],
E                      [2., 1.]], dtype=float32)

__tracebackhide__ = True
all        = <function all at 0x1054b8720>
array      = <built-in function array>
array2string = <function array2string at 0x1054c7560>
bool_      = <class 'numpy.bool_'>
comparison = <function assert_array_almost_equal.<locals>.compare at 0x10c9705e0>
cond       = False
equal_inf  = True
equal_nan  = True
err_msg    = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 1.4734483\nMax relative difference: 0.9652821'
error      = array([0.4256543, 1.473448 , 1.4734483, 0.9652821], dtype=float32)
errstate   = <class 'numpy.errstate'>
flagged    = array([[False, False],
       [False, False]])
func_assert_same_pos = <function assert_array_compare.<locals>.func_assert_same_pos at 0x10c9707c0>
header     = 'Arrays are not almost equal to 5 decimals'
inf        = inf
isnan      = <ufunc 'isnan'>
isnumber   = <function assert_array_compare.<locals>.isnumber at 0x10c970680>
istime     = <function assert_array_compare.<locals>.istime at 0x10c970720>
max        = <function amax at 0x1054b8cc0>
max_abs_error = 1.4734483
max_rel_error = 0.9652821
msg        = '\nArrays are not almost equal to 5 decimals\n\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 1.4734483\...0.57435, 3.47345],\n       [3.47345, 0.03472]], dtype=float32)\n y: array([[1., 2.],\n       [2., 1.]], dtype=float32)'
n_elements = 4
n_mismatch = 4
nonzero    = array([ True,  True,  True,  True])
object_    = <class 'numpy.object_'>
ox         = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32)
oy         = array([[1., 2.],
       [2., 1.]], dtype=float32)
percent_mismatch = 100.0
precision  = 5
reduced    = array([False, False, False, False])
remarks    = ['Mismatched elements: 4 / 4 (100%)', 'Max absolute difference: 1.4734483', 'Max relative difference: 0.9652821']
strict     = False
val        = array([False, False, False, False])
verbose    = True
x          = array([0.5743457 , 3.473448  , 3.4734483 , 0.03471792], dtype=float32)
y          = array([1., 2., 2., 1.], dtype=float32)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:862: AssertionError

During handling of the above exception, another exception occurred:

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
>               case.check(self.do)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...4645e-08j]],\n      dtype=complex64)\n DESIRED: array([[1.+0.j, 2.+3.j],\n       [2.-3.j, 1.+0.j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:350:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <LinalgCase: hcsingle>
do = <bound method PinvHermitianCases.do of <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>>

    def check(self, do):
        """
        Run the function `do` on this test case, expanding arguments
        """
>       do(self.a, self.b, tags=self.tags)

do         = <bound method PinvHermitianCases.do of <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>>
self       = <LinalgCase: hcsingle>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:85:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>
a = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), b = None, tags = frozenset({'hermitian'})

    def do(self, a, b, tags):
        a_ginv = linalg.pinv(a, hermitian=True)
        # `a @ a_ginv == I` does not hold if a is singular
        dot = dot_generalized
>       assert_almost_equal(dot(dot(a, a_ginv), a), a, single_decimal=5, double_decimal=11)

a          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
a_ginv     = array([[-0.26591796+0.0000000e+00j,  0.24816822+4.5332125e-01j],
       [ 0.24816824-4.5332125e-01j, -0.220949  +7.4505806e-09j]],
      dtype=complex64)
b          = None
dot        = <function dot_generalized at 0x107f7bd80>
self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>
tags       = frozenset({'hermitian'})

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:835:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

a = array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64)
b = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), single_decimal = 5, double_decimal = 11, kw = {}, decimal = 5

    def assert_almost_equal(a, b, single_decimal=6, double_decimal=12, **kw):
        if asarray(a).dtype.type in (single, csingle):
            decimal = single_decimal
        else:
            decimal = double_decimal
>       old_assert_almost_equal(a, b, decimal=decimal, **kw)

a          = array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64)
b          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
decimal    = 5
double_decimal = 11
kw         = {}
single_decimal = 5

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:41:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64), array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64))
kwds = {'decimal': 5}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64), array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64))
func       = <function assert_almost_equal at 0x107eca840>
kwds       = {'decimal': 5}
self       = <contextlib._GeneratorContextManager object at 0x107ed3210>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64)
desired = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
        """
        Raises an AssertionError if two items are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies that the elements of `actual` and `desired` satisfy.

            ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``

        That is a looser test than originally documented, but agrees with what the
        actual implementation in `assert_array_almost_equal` did up to rounding
        vagaries. An exception is raised at conflicting values. For ndarrays this
        delegates to assert_array_almost_equal

        Parameters
        ----------
        actual : array_like
            The object to check.
        desired : array_like
            The expected object.
        decimal : int, optional
            Desired precision, default is 7.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
          If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        >>> from numpy.testing import assert_almost_equal
        >>> assert_almost_equal(2.3333333333333, 2.33333334)
        >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 10 decimals
         ACTUAL: 2.3333333333333
         DESIRED: 2.33333334

        >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
        ...                     np.array([1.0,2.33333334]), decimal=9)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 9 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 2 (50%)
        Max absolute difference: 6.66669964e-09
        Max relative difference: 2.85715698e-09
         x: array([1.         , 2.333333333])
         y: array([1.        , 2.33333334])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import ndarray
        from numpy.lib import iscomplexobj, real, imag

        # Handle complex numbers: separate into real/imag to handle
        # nan/inf/negative zero correctly
        # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
        try:
            usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
        except ValueError:
            usecomplex = False

        def _build_err_msg():
            header = ('Arrays are not almost equal to %d decimals' % decimal)
            return build_err_msg([actual, desired], err_msg, verbose=verbose,
                                 header=header)

        if usecomplex:
            if iscomplexobj(actual):
                actualr = real(actual)
                actuali = imag(actual)
            else:
                actualr = actual
                actuali = 0
            if iscomplexobj(desired):
                desiredr = real(desired)
                desiredi = imag(desired)
            else:
                desiredr = desired
                desiredi = 0
            try:
                assert_almost_equal(actualr, desiredr, decimal=decimal)
                assert_almost_equal(actuali, desiredi, decimal=decimal)
            except AssertionError:
>               raise AssertionError(_build_err_msg())
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E                ACTUAL: array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
E                      [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
E                     dtype=complex64)
E                DESIRED: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)

__tracebackhide__ = True
_build_err_msg = <function assert_almost_equal.<locals>._build_err_msg at 0x10c970360>
actual     = array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
      dtype=complex64)
actuali    = array([[ 2.3841858e-07,  4.2373457e+00],
       [-4.2373452e+00,  5.9604645e-08]], dtype=float32)
actualr    = array([[0.5743457 , 3.473448  ],
       [3.4734483 , 0.03471792]], dtype=float32)
decimal    = 5
desired    = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
desiredi   = array([[ 0.,  3.],
       [-3.,  0.]], dtype=float32)
desiredr   = array([[1., 2.],
       [2., 1.]], dtype=float32)
err_msg    = ''
imag       = <function imag at 0x1055d80e0>
iscomplexobj = <function iscomplexobj at 0x1055d8540>
ndarray    = <class 'numpy.ndarray'>
real       = <function real at 0x1055cfec0>
usecomplex = True
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:584: AssertionError

The above exception was the direct cause of the following exception:

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>

    def test_herm_cases(self):
>       self.check_cases(require={'hermitian'},
                         exclude={'generalized', 'size-0'})

self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:382:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
                case.check(self.do)
            except Exception as e:
                msg = f'In test case: {case!r}\n\n'
                msg += traceback.format_exc()
>               raise AssertionError(msg) from e
E               AssertionError: In test case: <LinalgCase: hcsingle>
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 581, in assert_almost_equal
E                   assert_almost_equal(actualr, desiredr, decimal=decimal)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 588, in assert_almost_equal
E                   return assert_array_almost_equal(actual, desired, decimal, err_msg)
E                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 1097, in assert_array_almost_equal
E                   assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 862, in assert_array_compare
E                   raise AssertionError(msg)
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 1.4734483
E               Max relative difference: 0.9652821
E                x: array([[0.57435, 3.47345],
E                      [3.47345, 0.03472]], dtype=float32)
E                y: array([[1., 2.],
E                      [2., 1.]], dtype=float32)
E
E               During handling of the above exception, another exception occurred:
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 350, in check_cases
E                   case.check(self.do)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 85, in check
E                   do(self.a, self.b, tags=self.tags)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 835, in do
E                   assert_almost_equal(dot(dot(a, a_ginv), a), a, single_decimal=5, double_decimal=11)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 41, in assert_almost_equal
E                   old_assert_almost_equal(a, b, decimal=decimal, **kw)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 584, in assert_almost_equal
E                   raise AssertionError(_build_err_msg())
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E                ACTUAL: array([[0.5743457 +2.3841858e-07j, 3.473448  +4.2373457e+00j],
E                      [3.4734483 -4.2373452e+00j, 0.03471792+5.9604645e-08j]],
E                     dtype=complex64)
E                DESIRED: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...4645e-08j]],\n      dtype=complex64)\n DESIRED: array([[1.+0.j, 2.+3.j],\n       [2.-3.j, 1.+0.j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10af7c850>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:354: AssertionError
________________________________________________________ TestEighCases.test_herm_cases _________________________________________________________

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
>               case.check(self.do)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...y([[ 1.842403+1.842403j, -3.256616-0.953841j],\n       [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:350:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <LinalgCase: hcsingle>, do = <bound method TestEighCases.do of <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>>

    def check(self, do):
        """
        Run the function `do` on this test case, expanding arguments
        """
>       do(self.a, self.b, tags=self.tags)

do         = <bound method TestEighCases.do of <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>>
self       = <LinalgCase: hcsingle>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:85:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>
a = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), b = None, tags = frozenset({'hermitian'})

    def do(self, a, b, tags):
        # note that eigenvalue arrays returned by eig must be sorted since
        # their order isn't guaranteed.
        ev, evc = linalg.eigh(a)
        evalues, evectors = linalg.eig(a)
        evalues.sort(axis=-1)
        assert_almost_equal(ev, evalues)

>       assert_allclose(dot_generalized(a, evc),
                        np.asarray(ev)[..., None, :] * np.asarray(evc),
                        rtol=get_rtol(ev.dtype))

a          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
b          = None
ev         = array([-2.6055512,  4.6055512], dtype=float32)
evalues    = array([-2.6055512-1.110223e-16j,  4.6055512+1.110223e-16j],
      dtype=complex64)
evc        = array([[-0.70710677-0.70710677j, -0.70710677-0.20710678j],
       [ 0.9805807 -0.19611613j, -0.8082574 +0.31099832j]],
      dtype=complex64)
evectors   = array([[ 0.39223227+0.5883484j, -0.39223227-0.5883484j],
       [ 0.70710677+0.j       ,  0.70710677+0.j       ]], dtype=complex64)
self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>
tags       = frozenset({'hermitian'})

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1152:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 1.8424029+1.8424029j, -3.2566166-2.0098825j],
       [-2.554953 +0.5109906j, -2.8437915+2.018105j ]], dtype=complex64)
desired = array([[ 1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64)
rtol = 1e-05, atol = 0, equal_nan = True, err_msg = '', verbose = True

    def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
                        err_msg='', verbose=True):
        """
        Raises an AssertionError if two objects are not equal up to desired
        tolerance.

        Given two array_like objects, check that their shapes and all elements
        are equal (but see the Notes for the special handling of a scalar). An
        exception is raised if the shapes mismatch or any values conflict. In
        contrast to the standard usage in numpy, NaNs are compared like numbers,
        no assertion is raised if both objects have NaNs in the same positions.

        The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
        that ``allclose`` has different default values). It compares the difference
        between `actual` and `desired` to ``atol + rtol * abs(desired)``.

        .. versionadded:: 1.5.0

        Parameters
        ----------
        actual : array_like
            Array obtained.
        desired : array_like
            Array desired.
        rtol : float, optional
            Relative tolerance.
        atol : float, optional
            Absolute tolerance.
        equal_nan : bool, optional.
            If True, NaNs will compare equal.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
            If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_array_almost_equal_nulp, assert_array_max_ulp

        Notes
        -----
        When one of `actual` and `desired` is a scalar and the other is
        array_like, the function checks that each element of the array_like
        object is equal to the scalar.

        Examples
        --------
        >>> x = [1e-5, 1e-3, 1e-1]
        >>> y = np.arccos(np.cos(x))
        >>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        import numpy as np

        def compare(x, y):
            return np.core.numeric.isclose(x, y, rtol=rtol, atol=atol,
                                           equal_nan=equal_nan)

        actual, desired = np.asanyarray(actual), np.asanyarray(desired)
        header = f'Not equal to tolerance rtol={rtol:g}, atol={atol:g}'
>       assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
                             verbose=verbose, header=header, equal_nan=equal_nan)

__tracebackhide__ = True
actual     = array([[ 1.8424029+1.8424029j, -3.2566166-2.0098825j],
       [-2.554953 +0.5109906j, -2.8437915+2.018105j ]], dtype=complex64)
atol       = 0
compare    = <function assert_allclose.<locals>.compare at 0x10c9c6520>
desired    = array([[ 1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64)
equal_nan  = True
err_msg    = ''
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
np         = <module 'numpy' from '/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/__init__.py'>
rtol       = 1e-05
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:1590:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (<function assert_allclose.<locals>.compare at 0x10c9c6520>, array([[ 1.8424029+1.8424029j, -3.2566166-2.0098825j],
  ...1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64))
kwds = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (<function assert_allclose.<locals>.compare at 0x10c9c6520>, array([[ 1.8424029+1.8424029j, -3.2566166-2.0098825j],
  ...1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64))
func       = <function assert_array_compare at 0x107ecaac0>
kwds       = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}
self       = <contextlib._GeneratorContextManager object at 0x107edb750>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

comparison = <function assert_allclose.<locals>.compare at 0x10c9c6520>
x = array([ 1.8424029+1.8424029j, -3.2566166-2.0098825j,
       -2.554953 +0.5109906j, -2.8437915+2.018105j ], dtype=complex64)
y = array([ 1.8424029+1.8424029j, -3.2566164-0.9538409j,
       -2.5549533+0.5109906j, -3.7224708+1.4323187j], dtype=complex64)
err_msg = '\nMismatched elements: 2 / 4 (50%)\nMax absolute difference: 1.0560415\nMax relative difference: 0.31120184', verbose = True
header = 'Not equal to tolerance rtol=1e-05, atol=0', precision = 6, equal_nan = True, equal_inf = True

    @np._no_nep50_warning()
    def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                             precision=6, equal_nan=True, equal_inf=True,
                             *, strict=False):
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_

        x = np.asanyarray(x)
        y = np.asanyarray(y)

        # original array for output formatting
        ox, oy = x, y

        def isnumber(x):
            return x.dtype.char in '?bhilqpBHILQPefdgFDG'

        def istime(x):
            return x.dtype.char in "Mm"

        def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
            """Handling nan/inf.

            Combine results of running func on x and y, checking that they are True
            at the same locations.

            """
            __tracebackhide__ = True  # Hide traceback for py.test

            x_id = func(x)
            y_id = func(y)
            # We include work-arounds here to handle three types of slightly
            # pathological ndarray subclasses:
            # (1) all() on `masked` array scalars can return masked arrays, so we
            #     use != True
            # (2) __eq__ on some ndarray subclasses returns Python booleans
            #     instead of element-wise comparisons, so we cast to bool_() and
            #     use isinstance(..., bool) checks
            # (3) subclasses with bare-bones __array_function__ implementations may
            #     not implement np.all(), so favor using the .all() method
            # We are not committed to supporting such subclasses, but it's nice to
            # support them if possible.
            if bool_(x_id == y_id).all() != True:
                msg = build_err_msg([x, y],
                                    err_msg + '\nx and y %s location mismatch:'
                                    % (hasval), verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)
            # If there is a scalar, then here we know the array has the same
            # flag as it everywhere, so we should return the scalar flag.
            if isinstance(x_id, bool) or x_id.ndim == 0:
                return bool_(x_id)
            elif isinstance(y_id, bool) or y_id.ndim == 0:
                return bool_(y_id)
            else:
                return y_id

        try:
            if strict:
                cond = x.shape == y.shape and x.dtype == y.dtype
            else:
                cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
            if not cond:
                if x.shape != y.shape:
                    reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
                else:
                    reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
                msg = build_err_msg([x, y],
                                    err_msg
                                    + reason,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)

            flagged = bool_(False)
            if isnumber(x) and isnumber(y):
                if equal_nan:
                    flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')

                if equal_inf:
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == +inf,
                                                    hasval='+inf')
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == -inf,
                                                    hasval='-inf')

            elif istime(x) and istime(y):
                # If one is datetime64 and the other timedelta64 there is no point
                if equal_nan and x.dtype.type == y.dtype.type:
                    flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")

            if flagged.ndim > 0:
                x, y = x[~flagged], y[~flagged]
                # Only do the comparison if actual values are left
                if x.size == 0:
                    return
            elif flagged:
                # no sense doing comparison if everything is flagged.
                return

            val = comparison(x, y)

            if isinstance(val, bool):
                cond = val
                reduced = array([val])
            else:
                reduced = val.ravel()
                cond = reduced.all()

            # The below comparison is a hack to ensure that fully masked
            # results, for which val.ravel().all() returns np.ma.masked,
            # do not trigger a failure (np.ma.masked != True evaluates as
            # np.ma.masked, which is falsy).
            if cond != True:
                n_mismatch = reduced.size - reduced.sum(dtype=intp)
                n_elements = flagged.size if flagged.ndim != 0 else reduced.size
                percent_mismatch = 100 * n_mismatch / n_elements
                remarks = [
                    'Mismatched elements: {} / {} ({:.3g}%)'.format(
                        n_mismatch, n_elements, percent_mismatch)]

                with errstate(all='ignore'):
                    # ignore errors for non-numeric types
                    with contextlib.suppress(TypeError):
                        error = abs(x - y)
                        if np.issubdtype(x.dtype, np.unsignedinteger):
                            error2 = abs(y - x)
                            np.minimum(error, error2, out=error)
                        max_abs_error = max(error)
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max absolute difference: '
                                            + str(max_abs_error))
                        else:
                            remarks.append('Max absolute difference: '
                                            + array2string(max_abs_error))

                        # note: this definition of relative error matches that one
                        # used by assert_allclose (found in np.isclose)
                        # Filter values where the divisor would be zero
                        nonzero = bool_(y != 0)
                        if all(~nonzero):
                            max_rel_error = array(inf)
                        else:
                            max_rel_error = max(error[nonzero] / abs(y[nonzero]))
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max relative difference: '
                                            + str(max_rel_error))
                        else:
                            remarks.append('Max relative difference: '
                                            + array2string(max_rel_error))

                err_msg += '\n' + '\n'.join(remarks)
                msg = build_err_msg([ox, oy], err_msg,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
>               raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 2 / 4 (50%)
E               Max absolute difference: 1.0560415
E               Max relative difference: 0.31120184
E                x: array([[ 1.842403+1.842403j, -3.256617-2.009882j],
E                      [-2.554953+0.510991j, -2.843791+2.018105j]], dtype=complex64)
E                y: array([[ 1.842403+1.842403j, -3.256616-0.953841j],
E                      [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)

__tracebackhide__ = True
all        = <function all at 0x1054b8720>
array      = <built-in function array>
array2string = <function array2string at 0x1054c7560>
bool_      = <class 'numpy.bool_'>
comparison = <function assert_allclose.<locals>.compare at 0x10c9c6520>
cond       = False
equal_inf  = True
equal_nan  = True
err_msg    = '\nMismatched elements: 2 / 4 (50%)\nMax absolute difference: 1.0560415\nMax relative difference: 0.31120184'
error      = array([0.0000000e+00, 1.0560415e+00, 2.3841858e-07, 1.0560411e+00],
      dtype=float32)
errstate   = <class 'numpy.errstate'>
flagged    = array([[False, False],
       [False, False]])
func_assert_same_pos = <function assert_array_compare.<locals>.func_assert_same_pos at 0x10c9c6700>
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
inf        = inf
isnan      = <ufunc 'isnan'>
isnumber   = <function assert_array_compare.<locals>.isnumber at 0x10c9c65c0>
istime     = <function assert_array_compare.<locals>.istime at 0x10c9c67a0>
max        = <function amax at 0x1054b8cc0>
max_abs_error = 1.0560415
max_rel_error = 0.31120184
msg        = '\nNot equal to tolerance rtol=1e-05, atol=0\n\nMismatched elements: 2 / 4 (50%)\nMax absolute difference: 1.0560415\n...ray([[ 1.842403+1.842403j, -3.256616-0.953841j],\n       [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)'
n_elements = 4
n_mismatch = 2
nonzero    = array([ True,  True,  True,  True])
object_    = <class 'numpy.object_'>
ox         = array([[ 1.8424029+1.8424029j, -3.2566166-2.0098825j],
       [-2.554953 +0.5109906j, -2.8437915+2.018105j ]], dtype=complex64)
oy         = array([[ 1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64)
percent_mismatch = 50.0
precision  = 6
reduced    = array([ True, False,  True, False])
remarks    = ['Mismatched elements: 2 / 4 (50%)', 'Max absolute difference: 1.0560415', 'Max relative difference: 0.31120184']
strict     = False
val        = array([ True, False,  True, False])
verbose    = True
x          = array([ 1.8424029+1.8424029j, -3.2566166-2.0098825j,
       -2.554953 +0.5109906j, -2.8437915+2.018105j ], dtype=complex64)
y          = array([ 1.8424029+1.8424029j, -3.2566164-0.9538409j,
       -2.5549533+0.5109906j, -3.7224708+1.4323187j], dtype=complex64)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:862: AssertionError

The above exception was the direct cause of the following exception:

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>

    def test_herm_cases(self):
>       self.check_cases(require={'hermitian'},
                         exclude={'generalized', 'size-0'})

self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:382:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
                case.check(self.do)
            except Exception as e:
                msg = f'In test case: {case!r}\n\n'
                msg += traceback.format_exc()
>               raise AssertionError(msg) from e
E               AssertionError: In test case: <LinalgCase: hcsingle>
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 350, in check_cases
E                   case.check(self.do)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 85, in check
E                   do(self.a, self.b, tags=self.tags)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 1152, in do
E                   assert_allclose(dot_generalized(a, evc),
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 1590, in assert_allclose
E                   assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 862, in assert_array_compare
E                   raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 2 / 4 (50%)
E               Max absolute difference: 1.0560415
E               Max relative difference: 0.31120184
E                x: array([[ 1.842403+1.842403j, -3.256617-2.009882j],
E                      [-2.554953+0.510991j, -2.843791+2.018105j]], dtype=complex64)
E                y: array([[ 1.842403+1.842403j, -3.256616-0.953841j],
E                      [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...y([[ 1.842403+1.842403j, -3.256616-0.953841j],\n       [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x10aff7250>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:354: AssertionError
=========================================================== short test summary info ============================================================
FAILED tests/test_linalg.py::TestSVDHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestPinvHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestEighCases::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
3 failed, 383 passed, 2 skipped, 27 deselected, 2 xfailed in 1.63s

And for netlib:

FAILED tests/test_linalg.py::TestSVDHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestPinvHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestEighCases::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape1] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape2] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape3] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape4] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape1] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape2] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape3] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape4] - numpy.linalg.LinAlgError: Matrix is not positive definite
11 failed, 375 passed, 2 skipped, 27 deselected, 2 xfailed in 1.93s

python -c "import numpy; numpy.linalg.test()"

/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/_pytesttester.py:143: DeprecationWarning:

  `numpy.distutils` is deprecated since NumPy 1.23.0, as a result
  of the deprecation of `distutils` itself. It will be removed for
  Python >= 3.12. For older Python versions it will remain present.
  It is recommended to use `setuptools < 60.0` for those Python versions.
  For more details, see:
    https://numpy.org/devdocs/reference/distutils_status_migration.html


  from numpy.distutils import cpuinfo
NumPy version 1.24.1
NumPy relaxed strides checking option: True
NumPy CPU features:  NEON NEON_FP16 NEON_VFPV4 ASIMD ASIMDHP* ASIMDDP* ASIMDFHM?
.........................................F.....x.....F.................................................................................. [ 34%]
.....................................................................................F.................................................. [ 69%]
......................................................................FFFF.FFFF...s........................sx.........                   [100%]
=================================================================== FAILURES ===================================================================
_______________________________________________________ TestSVDHermitian.test_herm_cases _______________________________________________________

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
>               case.check(self.do)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...-08j,  3.780841+3.951701e+00j],\n       [ 3.780841-3.951701e+00j,  0.848612-4.494268e-08j]],\n      dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:350:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <LinalgCase: hcsingle>
do = <bound method SVDHermitianCases.do of <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>>

    def check(self, do):
        """
        Run the function `do` on this test case, expanding arguments
        """
>       do(self.a, self.b, tags=self.tags)

do         = <bound method SVDHermitianCases.do of <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>>
self       = <LinalgCase: hcsingle>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:85:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>
a = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), b = None, tags = frozenset({'hermitian'})

    def do(self, a, b, tags):
        u, s, vt = linalg.svd(a, False, hermitian=True)
>       assert_allclose(a, dot_generalized(np.asarray(u) * np.asarray(s)[..., None, :],
                                           np.asarray(vt)),
                        rtol=get_rtol(u.dtype))

a          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
b          = None
s          = array([4.6055512, 2.6055512], dtype=float32)
self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>
tags       = frozenset({'hermitian'})
u          = array([[-0.70710677-0.20710678j, -0.70710677-0.70710677j],
       [-0.8082574 +0.31099832j,  0.9805807 -0.19611613j]],
      dtype=complex64)
vt         = array([[-0.70710677+0.20710678j, -0.8082574 -0.31099832j],
       [ 0.70710677-0.70710677j, -0.9805807 -0.19611613j]],
      dtype=complex64)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:680:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
desired = array([[-0.1052289 +7.4536189e-08j,  3.7808409 +3.9517009e+00j],
       [ 3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j]],
      dtype=complex64)
rtol = 1e-05, atol = 0, equal_nan = True, err_msg = '', verbose = True

    def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
                        err_msg='', verbose=True):
        """
        Raises an AssertionError if two objects are not equal up to desired
        tolerance.

        Given two array_like objects, check that their shapes and all elements
        are equal (but see the Notes for the special handling of a scalar). An
        exception is raised if the shapes mismatch or any values conflict. In
        contrast to the standard usage in numpy, NaNs are compared like numbers,
        no assertion is raised if both objects have NaNs in the same positions.

        The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
        that ``allclose`` has different default values). It compares the difference
        between `actual` and `desired` to ``atol + rtol * abs(desired)``.

        .. versionadded:: 1.5.0

        Parameters
        ----------
        actual : array_like
            Array obtained.
        desired : array_like
            Array desired.
        rtol : float, optional
            Relative tolerance.
        atol : float, optional
            Absolute tolerance.
        equal_nan : bool, optional.
            If True, NaNs will compare equal.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
            If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_array_almost_equal_nulp, assert_array_max_ulp

        Notes
        -----
        When one of `actual` and `desired` is a scalar and the other is
        array_like, the function checks that each element of the array_like
        object is equal to the scalar.

        Examples
        --------
        >>> x = [1e-5, 1e-3, 1e-1]
        >>> y = np.arccos(np.cos(x))
        >>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        import numpy as np

        def compare(x, y):
            return np.core.numeric.isclose(x, y, rtol=rtol, atol=atol,
                                           equal_nan=equal_nan)

        actual, desired = np.asanyarray(actual), np.asanyarray(desired)
        header = f'Not equal to tolerance rtol={rtol:g}, atol={atol:g}'
>       assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
                             verbose=verbose, header=header, equal_nan=equal_nan)

__tracebackhide__ = True
actual     = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
atol       = 0
compare    = <function assert_allclose.<locals>.compare at 0x10979ab60>
desired    = array([[-0.1052289 +7.4536189e-08j,  3.7808409 +3.9517009e+00j],
       [ 3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j]],
      dtype=complex64)
equal_nan  = True
err_msg    = ''
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
np         = <module 'numpy' from '/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/__init__.py'>
rtol       = 1e-05
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:1590:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (<function assert_allclose.<locals>.compare at 0x10979ab60>, array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=...  3.7808409 +3.9517009e+00j],
       [ 3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j]],
      dtype=complex64))
kwds = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (<function assert_allclose.<locals>.compare at 0x10979ab60>, array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=...  3.7808409 +3.9517009e+00j],
       [ 3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j]],
      dtype=complex64))
func       = <function assert_array_compare at 0x106656ac0>
kwds       = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}
self       = <contextlib._GeneratorContextManager object at 0x106674090>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

comparison = <function assert_allclose.<locals>.compare at 0x10979ab60>, x = array([1.+0.j, 2.+3.j, 2.-3.j, 1.+0.j], dtype=complex64)
y = array([-0.1052289 +7.4536189e-08j,  3.7808409 +3.9517009e+00j,
        3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j],
      dtype=complex64)
err_msg = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 2.0191903\nMax relative difference: 10.503093', verbose = True
header = 'Not equal to tolerance rtol=1e-05, atol=0', precision = 6, equal_nan = True, equal_inf = True

    @np._no_nep50_warning()
    def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                             precision=6, equal_nan=True, equal_inf=True,
                             *, strict=False):
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_

        x = np.asanyarray(x)
        y = np.asanyarray(y)

        # original array for output formatting
        ox, oy = x, y

        def isnumber(x):
            return x.dtype.char in '?bhilqpBHILQPefdgFDG'

        def istime(x):
            return x.dtype.char in "Mm"

        def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
            """Handling nan/inf.

            Combine results of running func on x and y, checking that they are True
            at the same locations.

            """
            __tracebackhide__ = True  # Hide traceback for py.test

            x_id = func(x)
            y_id = func(y)
            # We include work-arounds here to handle three types of slightly
            # pathological ndarray subclasses:
            # (1) all() on `masked` array scalars can return masked arrays, so we
            #     use != True
            # (2) __eq__ on some ndarray subclasses returns Python booleans
            #     instead of element-wise comparisons, so we cast to bool_() and
            #     use isinstance(..., bool) checks
            # (3) subclasses with bare-bones __array_function__ implementations may
            #     not implement np.all(), so favor using the .all() method
            # We are not committed to supporting such subclasses, but it's nice to
            # support them if possible.
            if bool_(x_id == y_id).all() != True:
                msg = build_err_msg([x, y],
                                    err_msg + '\nx and y %s location mismatch:'
                                    % (hasval), verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)
            # If there is a scalar, then here we know the array has the same
            # flag as it everywhere, so we should return the scalar flag.
            if isinstance(x_id, bool) or x_id.ndim == 0:
                return bool_(x_id)
            elif isinstance(y_id, bool) or y_id.ndim == 0:
                return bool_(y_id)
            else:
                return y_id

        try:
            if strict:
                cond = x.shape == y.shape and x.dtype == y.dtype
            else:
                cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
            if not cond:
                if x.shape != y.shape:
                    reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
                else:
                    reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
                msg = build_err_msg([x, y],
                                    err_msg
                                    + reason,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)

            flagged = bool_(False)
            if isnumber(x) and isnumber(y):
                if equal_nan:
                    flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')

                if equal_inf:
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == +inf,
                                                    hasval='+inf')
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == -inf,
                                                    hasval='-inf')

            elif istime(x) and istime(y):
                # If one is datetime64 and the other timedelta64 there is no point
                if equal_nan and x.dtype.type == y.dtype.type:
                    flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")

            if flagged.ndim > 0:
                x, y = x[~flagged], y[~flagged]
                # Only do the comparison if actual values are left
                if x.size == 0:
                    return
            elif flagged:
                # no sense doing comparison if everything is flagged.
                return

            val = comparison(x, y)

            if isinstance(val, bool):
                cond = val
                reduced = array([val])
            else:
                reduced = val.ravel()
                cond = reduced.all()

            # The below comparison is a hack to ensure that fully masked
            # results, for which val.ravel().all() returns np.ma.masked,
            # do not trigger a failure (np.ma.masked != True evaluates as
            # np.ma.masked, which is falsy).
            if cond != True:
                n_mismatch = reduced.size - reduced.sum(dtype=intp)
                n_elements = flagged.size if flagged.ndim != 0 else reduced.size
                percent_mismatch = 100 * n_mismatch / n_elements
                remarks = [
                    'Mismatched elements: {} / {} ({:.3g}%)'.format(
                        n_mismatch, n_elements, percent_mismatch)]

                with errstate(all='ignore'):
                    # ignore errors for non-numeric types
                    with contextlib.suppress(TypeError):
                        error = abs(x - y)
                        if np.issubdtype(x.dtype, np.unsignedinteger):
                            error2 = abs(y - x)
                            np.minimum(error, error2, out=error)
                        max_abs_error = max(error)
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max absolute difference: '
                                            + str(max_abs_error))
                        else:
                            remarks.append('Max absolute difference: '
                                            + array2string(max_abs_error))

                        # note: this definition of relative error matches that one
                        # used by assert_allclose (found in np.isclose)
                        # Filter values where the divisor would be zero
                        nonzero = bool_(y != 0)
                        if all(~nonzero):
                            max_rel_error = array(inf)
                        else:
                            max_rel_error = max(error[nonzero] / abs(y[nonzero]))
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max relative difference: '
                                            + str(max_rel_error))
                        else:
                            remarks.append('Max relative difference: '
                                            + array2string(max_rel_error))

                err_msg += '\n' + '\n'.join(remarks)
                msg = build_err_msg([ox, oy], err_msg,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
>               raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 2.0191903
E               Max relative difference: 10.503093
E                x: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)
E                y: array([[-0.105229+7.453619e-08j,  3.780841+3.951701e+00j],
E                      [ 3.780841-3.951701e+00j,  0.848612-4.494268e-08j]],
E                     dtype=complex64)

__tracebackhide__ = True
all        = <function all at 0x103970720>
array      = <built-in function array>
array2string = <function array2string at 0x10397f560>
bool_      = <class 'numpy.bool_'>
comparison = <function assert_allclose.<locals>.compare at 0x10979ab60>
cond       = False
equal_inf  = True
equal_nan  = True
err_msg    = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 2.0191903\nMax relative difference: 10.503093'
error      = array([1.1052289 , 2.01919   , 2.0191903 , 0.15138817], dtype=float32)
errstate   = <class 'numpy.errstate'>
flagged    = array([[False, False],
       [False, False]])
func_assert_same_pos = <function assert_array_compare.<locals>.func_assert_same_pos at 0x10979ad40>
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
inf        = inf
isnan      = <ufunc 'isnan'>
isnumber   = <function assert_array_compare.<locals>.isnumber at 0x10979ac00>
istime     = <function assert_array_compare.<locals>.istime at 0x10979aca0>
max        = <function amax at 0x103970cc0>
max_abs_error = 2.0191903
max_rel_error = 10.503093
msg        = '\nNot equal to tolerance rtol=1e-05, atol=0\n\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 2.0191903\...9e-08j,  3.780841+3.951701e+00j],\n       [ 3.780841-3.951701e+00j,  0.848612-4.494268e-08j]],\n      dtype=complex64)'
n_elements = 4
n_mismatch = 4
nonzero    = array([ True,  True,  True,  True])
object_    = <class 'numpy.object_'>
ox         = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
oy         = array([[-0.1052289 +7.4536189e-08j,  3.7808409 +3.9517009e+00j],
       [ 3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j]],
      dtype=complex64)
percent_mismatch = 100.0
precision  = 6
reduced    = array([False, False, False, False])
remarks    = ['Mismatched elements: 4 / 4 (100%)', 'Max absolute difference: 2.0191903', 'Max relative difference: 10.503093']
strict     = False
val        = array([False, False, False, False])
verbose    = True
x          = array([1.+0.j, 2.+3.j, 2.-3.j, 1.+0.j], dtype=complex64)
y          = array([-0.1052289 +7.4536189e-08j,  3.7808409 +3.9517009e+00j,
        3.780841  -3.9517007e+00j,  0.84861183-4.4942681e-08j],
      dtype=complex64)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:862: AssertionError

The above exception was the direct cause of the following exception:

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>

    def test_herm_cases(self):
>       self.check_cases(require={'hermitian'},
                         exclude={'generalized', 'size-0'})

self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:382:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
                case.check(self.do)
            except Exception as e:
                msg = f'In test case: {case!r}\n\n'
                msg += traceback.format_exc()
>               raise AssertionError(msg) from e
E               AssertionError: In test case: <LinalgCase: hcsingle>
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 350, in check_cases
E                   case.check(self.do)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 85, in check
E                   do(self.a, self.b, tags=self.tags)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 680, in do
E                   assert_allclose(a, dot_generalized(np.asarray(u) * np.asarray(s)[..., None, :],
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 1590, in assert_allclose
E                   assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 862, in assert_array_compare
E                   raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 2.0191903
E               Max relative difference: 10.503093
E                x: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)
E                y: array([[-0.105229+7.453619e-08j,  3.780841+3.951701e+00j],
E                      [ 3.780841-3.951701e+00j,  0.848612-4.494268e-08j]],
E                     dtype=complex64)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...-08j,  3.780841+3.951701e+00j],\n       [ 3.780841-3.951701e+00j,  0.848612-4.494268e-08j]],\n      dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestSVDHermitian object at 0x109667d90>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:354: AssertionError
______________________________________________________ TestPinvHermitian.test_herm_cases _______________________________________________________

actual = array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64)
desired = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
        """
        Raises an AssertionError if two items are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies that the elements of `actual` and `desired` satisfy.

            ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``

        That is a looser test than originally documented, but agrees with what the
        actual implementation in `assert_array_almost_equal` did up to rounding
        vagaries. An exception is raised at conflicting values. For ndarrays this
        delegates to assert_array_almost_equal

        Parameters
        ----------
        actual : array_like
            The object to check.
        desired : array_like
            The expected object.
        decimal : int, optional
            Desired precision, default is 7.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
          If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        >>> from numpy.testing import assert_almost_equal
        >>> assert_almost_equal(2.3333333333333, 2.33333334)
        >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 10 decimals
         ACTUAL: 2.3333333333333
         DESIRED: 2.33333334

        >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
        ...                     np.array([1.0,2.33333334]), decimal=9)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 9 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 2 (50%)
        Max absolute difference: 6.66669964e-09
        Max relative difference: 2.85715698e-09
         x: array([1.         , 2.333333333])
         y: array([1.        , 2.33333334])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import ndarray
        from numpy.lib import iscomplexobj, real, imag

        # Handle complex numbers: separate into real/imag to handle
        # nan/inf/negative zero correctly
        # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
        try:
            usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
        except ValueError:
            usecomplex = False

        def _build_err_msg():
            header = ('Arrays are not almost equal to %d decimals' % decimal)
            return build_err_msg([actual, desired], err_msg, verbose=verbose,
                                 header=header)

        if usecomplex:
            if iscomplexobj(actual):
                actualr = real(actual)
                actuali = imag(actual)
            else:
                actualr = actual
                actuali = 0
            if iscomplexobj(desired):
                desiredr = real(desired)
                desiredi = imag(desired)
            else:
                desiredr = desired
                desiredi = 0
            try:
>               assert_almost_equal(actualr, desiredr, decimal=decimal)

__tracebackhide__ = True
_build_err_msg = <function assert_almost_equal.<locals>._build_err_msg at 0x10b074360>
actual     = array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64)
actuali    = array([[ 2.9802322e-08,  4.2373457e+00],
       [-4.2373452e+00, -1.4901161e-08]], dtype=float32)
actualr    = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32)
decimal    = 5
desired    = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
desiredi   = array([[ 0.,  3.],
       [-3.,  0.]], dtype=float32)
desiredr   = array([[1., 2.],
       [2., 1.]], dtype=float32)
err_msg    = ''
imag       = <function imag at 0x103a900e0>
iscomplexobj = <function iscomplexobj at 0x103a90540>
ndarray    = <class 'numpy.ndarray'>
real       = <function real at 0x103a87ec0>
usecomplex = True
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:581:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
kwds = {'decimal': 5}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
func       = <function assert_almost_equal at 0x106656840>
kwds       = {'decimal': 5}
self       = <contextlib._GeneratorContextManager object at 0x106660890>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32)
desired = array([[1., 2.],
       [2., 1.]], dtype=float32), decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
        """
        Raises an AssertionError if two items are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies that the elements of `actual` and `desired` satisfy.

            ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``

        That is a looser test than originally documented, but agrees with what the
        actual implementation in `assert_array_almost_equal` did up to rounding
        vagaries. An exception is raised at conflicting values. For ndarrays this
        delegates to assert_array_almost_equal

        Parameters
        ----------
        actual : array_like
            The object to check.
        desired : array_like
            The expected object.
        decimal : int, optional
            Desired precision, default is 7.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
          If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        >>> from numpy.testing import assert_almost_equal
        >>> assert_almost_equal(2.3333333333333, 2.33333334)
        >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 10 decimals
         ACTUAL: 2.3333333333333
         DESIRED: 2.33333334

        >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
        ...                     np.array([1.0,2.33333334]), decimal=9)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 9 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 2 (50%)
        Max absolute difference: 6.66669964e-09
        Max relative difference: 2.85715698e-09
         x: array([1.         , 2.333333333])
         y: array([1.        , 2.33333334])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import ndarray
        from numpy.lib import iscomplexobj, real, imag

        # Handle complex numbers: separate into real/imag to handle
        # nan/inf/negative zero correctly
        # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
        try:
            usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
        except ValueError:
            usecomplex = False

        def _build_err_msg():
            header = ('Arrays are not almost equal to %d decimals' % decimal)
            return build_err_msg([actual, desired], err_msg, verbose=verbose,
                                 header=header)

        if usecomplex:
            if iscomplexobj(actual):
                actualr = real(actual)
                actuali = imag(actual)
            else:
                actualr = actual
                actuali = 0
            if iscomplexobj(desired):
                desiredr = real(desired)
                desiredi = imag(desired)
            else:
                desiredr = desired
                desiredi = 0
            try:
                assert_almost_equal(actualr, desiredr, decimal=decimal)
                assert_almost_equal(actuali, desiredi, decimal=decimal)
            except AssertionError:
                raise AssertionError(_build_err_msg())

        if isinstance(actual, (ndarray, tuple, list)) \
                or isinstance(desired, (ndarray, tuple, list)):
>           return assert_array_almost_equal(actual, desired, decimal, err_msg)

__tracebackhide__ = True
_build_err_msg = <function assert_almost_equal.<locals>._build_err_msg at 0x10b074540>
actual     = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32)
decimal    = 5
desired    = array([[1., 2.],
       [2., 1.]], dtype=float32)
err_msg    = ''
imag       = <function imag at 0x103a900e0>
iscomplexobj = <function iscomplexobj at 0x103a90540>
ndarray    = <class 'numpy.ndarray'>
real       = <function real at 0x103a87ec0>
usecomplex = False
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:588:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32), 5, '')
kwds = {}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32), 5, '')
func       = <function assert_array_almost_equal at 0x106656ca0>
kwds       = {}
self       = <contextlib._GeneratorContextManager object at 0x106674250>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), y = array([[1., 2.],
       [2., 1.]], dtype=float32)
decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
        """
        Raises an AssertionError if two objects are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies identical shapes and that the elements of ``actual`` and
        ``desired`` satisfy.

            ``abs(desired-actual) < 1.5 * 10**(-decimal)``

        That is a looser test than originally documented, but agrees with what the
        actual implementation did up to rounding vagaries. An exception is raised
        at shape mismatch or conflicting values. In contrast to the standard usage
        in numpy, NaNs are compared like numbers, no assertion is raised if both
        objects have NaNs in the same positions.

        Parameters
        ----------
        x : array_like
            The actual object to check.
        y : array_like
            The desired, expected object.
        decimal : int, optional
            Desired precision, default is 6.
        err_msg : str, optional
          The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
            If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        the first assert does not raise an exception

        >>> np.testing.assert_array_almost_equal([1.0,2.333,np.nan],
        ...                                      [1.0,2.333,np.nan])

        >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
        ...                                      [1.0,2.33339,np.nan], decimal=5)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 5 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 3 (33.3%)
        Max absolute difference: 6.e-05
        Max relative difference: 2.57136612e-05
         x: array([1.     , 2.33333,     nan])
         y: array([1.     , 2.33339,     nan])

        >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
        ...                                      [1.0,2.33333, 5], decimal=5)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 5 decimals
        <BLANKLINE>
        x and y nan location mismatch:
         x: array([1.     , 2.33333,     nan])
         y: array([1.     , 2.33333, 5.     ])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import number, float_, result_type, array
        from numpy.core.numerictypes import issubdtype
        from numpy.core.fromnumeric import any as npany

        def compare(x, y):
            try:
                if npany(gisinf(x)) or npany( gisinf(y)):
                    xinfid = gisinf(x)
                    yinfid = gisinf(y)
                    if not (xinfid == yinfid).all():
                        return False
                    # if one item, x and y is +- inf
                    if x.size == y.size == 1:
                        return x == y
                    x = x[~xinfid]
                    y = y[~yinfid]
            except (TypeError, NotImplementedError):
                pass

            # make sure y is an inexact type to avoid abs(MIN_INT); will cause
            # casting of x later.
            dtype = result_type(y, 1.)
            y = np.asanyarray(y, dtype)
            z = abs(x - y)

            if not issubdtype(z.dtype, number):
                z = z.astype(float_)  # handle object arrays

            return z < 1.5 * 10.0**(-decimal)

>       assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
                 header=('Arrays are not almost equal to %d decimals' % decimal),
                 precision=decimal)

__tracebackhide__ = True
array      = <built-in function array>
compare    = <function assert_array_almost_equal.<locals>.compare at 0x10b0745e0>
decimal    = 5
err_msg    = ''
float_     = <class 'numpy.float64'>
issubdtype = <function issubdtype at 0x1034c04a0>
npany      = <function any at 0x103970540>
number     = <class 'numpy.number'>
result_type = <function result_type at 0x103917920>
verbose    = True
x          = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32)
y          = array([[1., 2.],
       [2., 1.]], dtype=float32)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:1097:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (<function assert_array_almost_equal.<locals>.compare at 0x10b0745e0>, array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
kwds = {'err_msg': '', 'header': 'Arrays are not almost equal to 5 decimals', 'precision': 5, 'verbose': True}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (<function assert_array_almost_equal.<locals>.compare at 0x10b0745e0>, array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32), array([[1., 2.],
       [2., 1.]], dtype=float32))
func       = <function assert_array_compare at 0x106656ac0>
kwds       = {'err_msg': '', 'header': 'Arrays are not almost equal to 5 decimals', 'precision': 5, 'verbose': True}
self       = <contextlib._GeneratorContextManager object at 0x106674090>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

comparison = <function assert_array_almost_equal.<locals>.compare at 0x10b0745e0>
x = array([0.57434577, 3.4734485 , 3.4734483 , 0.03471804], dtype=float32), y = array([1., 2., 2., 1.], dtype=float32)
err_msg = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 1.4734485\nMax relative difference: 0.96528196', verbose = True
header = 'Arrays are not almost equal to 5 decimals', precision = 5, equal_nan = True, equal_inf = True

    @np._no_nep50_warning()
    def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                             precision=6, equal_nan=True, equal_inf=True,
                             *, strict=False):
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_

        x = np.asanyarray(x)
        y = np.asanyarray(y)

        # original array for output formatting
        ox, oy = x, y

        def isnumber(x):
            return x.dtype.char in '?bhilqpBHILQPefdgFDG'

        def istime(x):
            return x.dtype.char in "Mm"

        def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
            """Handling nan/inf.

            Combine results of running func on x and y, checking that they are True
            at the same locations.

            """
            __tracebackhide__ = True  # Hide traceback for py.test

            x_id = func(x)
            y_id = func(y)
            # We include work-arounds here to handle three types of slightly
            # pathological ndarray subclasses:
            # (1) all() on `masked` array scalars can return masked arrays, so we
            #     use != True
            # (2) __eq__ on some ndarray subclasses returns Python booleans
            #     instead of element-wise comparisons, so we cast to bool_() and
            #     use isinstance(..., bool) checks
            # (3) subclasses with bare-bones __array_function__ implementations may
            #     not implement np.all(), so favor using the .all() method
            # We are not committed to supporting such subclasses, but it's nice to
            # support them if possible.
            if bool_(x_id == y_id).all() != True:
                msg = build_err_msg([x, y],
                                    err_msg + '\nx and y %s location mismatch:'
                                    % (hasval), verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)
            # If there is a scalar, then here we know the array has the same
            # flag as it everywhere, so we should return the scalar flag.
            if isinstance(x_id, bool) or x_id.ndim == 0:
                return bool_(x_id)
            elif isinstance(y_id, bool) or y_id.ndim == 0:
                return bool_(y_id)
            else:
                return y_id

        try:
            if strict:
                cond = x.shape == y.shape and x.dtype == y.dtype
            else:
                cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
            if not cond:
                if x.shape != y.shape:
                    reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
                else:
                    reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
                msg = build_err_msg([x, y],
                                    err_msg
                                    + reason,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)

            flagged = bool_(False)
            if isnumber(x) and isnumber(y):
                if equal_nan:
                    flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')

                if equal_inf:
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == +inf,
                                                    hasval='+inf')
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == -inf,
                                                    hasval='-inf')

            elif istime(x) and istime(y):
                # If one is datetime64 and the other timedelta64 there is no point
                if equal_nan and x.dtype.type == y.dtype.type:
                    flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")

            if flagged.ndim > 0:
                x, y = x[~flagged], y[~flagged]
                # Only do the comparison if actual values are left
                if x.size == 0:
                    return
            elif flagged:
                # no sense doing comparison if everything is flagged.
                return

            val = comparison(x, y)

            if isinstance(val, bool):
                cond = val
                reduced = array([val])
            else:
                reduced = val.ravel()
                cond = reduced.all()

            # The below comparison is a hack to ensure that fully masked
            # results, for which val.ravel().all() returns np.ma.masked,
            # do not trigger a failure (np.ma.masked != True evaluates as
            # np.ma.masked, which is falsy).
            if cond != True:
                n_mismatch = reduced.size - reduced.sum(dtype=intp)
                n_elements = flagged.size if flagged.ndim != 0 else reduced.size
                percent_mismatch = 100 * n_mismatch / n_elements
                remarks = [
                    'Mismatched elements: {} / {} ({:.3g}%)'.format(
                        n_mismatch, n_elements, percent_mismatch)]

                with errstate(all='ignore'):
                    # ignore errors for non-numeric types
                    with contextlib.suppress(TypeError):
                        error = abs(x - y)
                        if np.issubdtype(x.dtype, np.unsignedinteger):
                            error2 = abs(y - x)
                            np.minimum(error, error2, out=error)
                        max_abs_error = max(error)
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max absolute difference: '
                                            + str(max_abs_error))
                        else:
                            remarks.append('Max absolute difference: '
                                            + array2string(max_abs_error))

                        # note: this definition of relative error matches that one
                        # used by assert_allclose (found in np.isclose)
                        # Filter values where the divisor would be zero
                        nonzero = bool_(y != 0)
                        if all(~nonzero):
                            max_rel_error = array(inf)
                        else:
                            max_rel_error = max(error[nonzero] / abs(y[nonzero]))
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max relative difference: '
                                            + str(max_rel_error))
                        else:
                            remarks.append('Max relative difference: '
                                            + array2string(max_rel_error))

                err_msg += '\n' + '\n'.join(remarks)
                msg = build_err_msg([ox, oy], err_msg,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
>               raise AssertionError(msg)
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 1.4734485
E               Max relative difference: 0.96528196
E                x: array([[0.57435, 3.47345],
E                      [3.47345, 0.03472]], dtype=float32)
E                y: array([[1., 2.],
E                      [2., 1.]], dtype=float32)

__tracebackhide__ = True
all        = <function all at 0x103970720>
array      = <built-in function array>
array2string = <function array2string at 0x10397f560>
bool_      = <class 'numpy.bool_'>
comparison = <function assert_array_almost_equal.<locals>.compare at 0x10b0745e0>
cond       = False
equal_inf  = True
equal_nan  = True
err_msg    = '\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 1.4734485\nMax relative difference: 0.96528196'
error      = array([0.42565423, 1.4734485 , 1.4734483 , 0.96528196], dtype=float32)
errstate   = <class 'numpy.errstate'>
flagged    = array([[False, False],
       [False, False]])
func_assert_same_pos = <function assert_array_compare.<locals>.func_assert_same_pos at 0x10b0747c0>
header     = 'Arrays are not almost equal to 5 decimals'
inf        = inf
isnan      = <ufunc 'isnan'>
isnumber   = <function assert_array_compare.<locals>.isnumber at 0x10b074680>
istime     = <function assert_array_compare.<locals>.istime at 0x10b074720>
max        = <function amax at 0x103970cc0>
max_abs_error = 1.4734485
max_rel_error = 0.96528196
msg        = '\nArrays are not almost equal to 5 decimals\n\nMismatched elements: 4 / 4 (100%)\nMax absolute difference: 1.4734485\...0.57435, 3.47345],\n       [3.47345, 0.03472]], dtype=float32)\n y: array([[1., 2.],\n       [2., 1.]], dtype=float32)'
n_elements = 4
n_mismatch = 4
nonzero    = array([ True,  True,  True,  True])
object_    = <class 'numpy.object_'>
ox         = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32)
oy         = array([[1., 2.],
       [2., 1.]], dtype=float32)
percent_mismatch = 100.0
precision  = 5
reduced    = array([False, False, False, False])
remarks    = ['Mismatched elements: 4 / 4 (100%)', 'Max absolute difference: 1.4734485', 'Max relative difference: 0.96528196']
strict     = False
val        = array([False, False, False, False])
verbose    = True
x          = array([0.57434577, 3.4734485 , 3.4734483 , 0.03471804], dtype=float32)
y          = array([1., 2., 2., 1.], dtype=float32)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:862: AssertionError

During handling of the above exception, another exception occurred:

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
>               case.check(self.do)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...1161e-08j]],\n      dtype=complex64)\n DESIRED: array([[1.+0.j, 2.+3.j],\n       [2.-3.j, 1.+0.j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:350:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <LinalgCase: hcsingle>
do = <bound method PinvHermitianCases.do of <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>>

    def check(self, do):
        """
        Run the function `do` on this test case, expanding arguments
        """
>       do(self.a, self.b, tags=self.tags)

do         = <bound method PinvHermitianCases.do of <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>>
self       = <LinalgCase: hcsingle>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:85:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>
a = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), b = None, tags = frozenset({'hermitian'})

    def do(self, a, b, tags):
        a_ginv = linalg.pinv(a, hermitian=True)
        # `a @ a_ginv == I` does not hold if a is singular
        dot = dot_generalized
>       assert_almost_equal(dot(dot(a, a_ginv), a), a, single_decimal=5, double_decimal=11)

a          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
a_ginv     = array([[-0.26591796-4.3245496e-09j,  0.24816822+4.5332125e-01j],
       [ 0.24816824-4.5332128e-01j, -0.22094898+1.2190652e-09j]],
      dtype=complex64)
b          = None
dot        = <function dot_generalized at 0x106703d80>
self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>
tags       = frozenset({'hermitian'})

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:835:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

a = array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64)
b = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), single_decimal = 5, double_decimal = 11, kw = {}, decimal = 5

    def assert_almost_equal(a, b, single_decimal=6, double_decimal=12, **kw):
        if asarray(a).dtype.type in (single, csingle):
            decimal = single_decimal
        else:
            decimal = double_decimal
>       old_assert_almost_equal(a, b, decimal=decimal, **kw)

a          = array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64)
b          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
decimal    = 5
double_decimal = 11
kw         = {}
single_decimal = 5

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:41:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64), array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64))
kwds = {'decimal': 5}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64), array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64))
func       = <function assert_almost_equal at 0x106656840>
kwds       = {'decimal': 5}
self       = <contextlib._GeneratorContextManager object at 0x106660890>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64)
desired = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), decimal = 5, err_msg = '', verbose = True

    @np._no_nep50_warning()
    def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
        """
        Raises an AssertionError if two items are not equal up to desired
        precision.

        .. note:: It is recommended to use one of `assert_allclose`,
                  `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
                  instead of this function for more consistent floating point
                  comparisons.

        The test verifies that the elements of `actual` and `desired` satisfy.

            ``abs(desired-actual) < float64(1.5 * 10**(-decimal))``

        That is a looser test than originally documented, but agrees with what the
        actual implementation in `assert_array_almost_equal` did up to rounding
        vagaries. An exception is raised at conflicting values. For ndarrays this
        delegates to assert_array_almost_equal

        Parameters
        ----------
        actual : array_like
            The object to check.
        desired : array_like
            The expected object.
        decimal : int, optional
            Desired precision, default is 7.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
          If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_allclose: Compare two array_like objects for equality with desired
                         relative and/or absolute precision.
        assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal

        Examples
        --------
        >>> from numpy.testing import assert_almost_equal
        >>> assert_almost_equal(2.3333333333333, 2.33333334)
        >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 10 decimals
         ACTUAL: 2.3333333333333
         DESIRED: 2.33333334

        >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
        ...                     np.array([1.0,2.33333334]), decimal=9)
        Traceback (most recent call last):
            ...
        AssertionError:
        Arrays are not almost equal to 9 decimals
        <BLANKLINE>
        Mismatched elements: 1 / 2 (50%)
        Max absolute difference: 6.66669964e-09
        Max relative difference: 2.85715698e-09
         x: array([1.         , 2.333333333])
         y: array([1.        , 2.33333334])

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import ndarray
        from numpy.lib import iscomplexobj, real, imag

        # Handle complex numbers: separate into real/imag to handle
        # nan/inf/negative zero correctly
        # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
        try:
            usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
        except ValueError:
            usecomplex = False

        def _build_err_msg():
            header = ('Arrays are not almost equal to %d decimals' % decimal)
            return build_err_msg([actual, desired], err_msg, verbose=verbose,
                                 header=header)

        if usecomplex:
            if iscomplexobj(actual):
                actualr = real(actual)
                actuali = imag(actual)
            else:
                actualr = actual
                actuali = 0
            if iscomplexobj(desired):
                desiredr = real(desired)
                desiredi = imag(desired)
            else:
                desiredr = desired
                desiredi = 0
            try:
                assert_almost_equal(actualr, desiredr, decimal=decimal)
                assert_almost_equal(actuali, desiredi, decimal=decimal)
            except AssertionError:
>               raise AssertionError(_build_err_msg())
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E                ACTUAL: array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
E                      [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
E                     dtype=complex64)
E                DESIRED: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)

__tracebackhide__ = True
_build_err_msg = <function assert_almost_equal.<locals>._build_err_msg at 0x10b074360>
actual     = array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
       [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
      dtype=complex64)
actuali    = array([[ 2.9802322e-08,  4.2373457e+00],
       [-4.2373452e+00, -1.4901161e-08]], dtype=float32)
actualr    = array([[0.57434577, 3.4734485 ],
       [3.4734483 , 0.03471804]], dtype=float32)
decimal    = 5
desired    = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
desiredi   = array([[ 0.,  3.],
       [-3.,  0.]], dtype=float32)
desiredr   = array([[1., 2.],
       [2., 1.]], dtype=float32)
err_msg    = ''
imag       = <function imag at 0x103a900e0>
iscomplexobj = <function iscomplexobj at 0x103a90540>
ndarray    = <class 'numpy.ndarray'>
real       = <function real at 0x103a87ec0>
usecomplex = True
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:584: AssertionError

The above exception was the direct cause of the following exception:

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>

    def test_herm_cases(self):
>       self.check_cases(require={'hermitian'},
                         exclude={'generalized', 'size-0'})

self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:382:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
                case.check(self.do)
            except Exception as e:
                msg = f'In test case: {case!r}\n\n'
                msg += traceback.format_exc()
>               raise AssertionError(msg) from e
E               AssertionError: In test case: <LinalgCase: hcsingle>
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 581, in assert_almost_equal
E                   assert_almost_equal(actualr, desiredr, decimal=decimal)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 588, in assert_almost_equal
E                   return assert_array_almost_equal(actual, desired, decimal, err_msg)
E                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 1097, in assert_array_almost_equal
E                   assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 862, in assert_array_compare
E                   raise AssertionError(msg)
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E
E               Mismatched elements: 4 / 4 (100%)
E               Max absolute difference: 1.4734485
E               Max relative difference: 0.96528196
E                x: array([[0.57435, 3.47345],
E                      [3.47345, 0.03472]], dtype=float32)
E                y: array([[1., 2.],
E                      [2., 1.]], dtype=float32)
E
E               During handling of the above exception, another exception occurred:
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 350, in check_cases
E                   case.check(self.do)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 85, in check
E                   do(self.a, self.b, tags=self.tags)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 835, in do
E                   assert_almost_equal(dot(dot(a, a_ginv), a), a, single_decimal=5, double_decimal=11)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 41, in assert_almost_equal
E                   old_assert_almost_equal(a, b, decimal=decimal, **kw)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 584, in assert_almost_equal
E                   raise AssertionError(_build_err_msg())
E               AssertionError:
E               Arrays are not almost equal to 5 decimals
E                ACTUAL: array([[0.57434577+2.9802322e-08j, 3.4734485 +4.2373457e+00j],
E                      [3.4734483 -4.2373452e+00j, 0.03471804-1.4901161e-08j]],
E                     dtype=complex64)
E                DESIRED: array([[1.+0.j, 2.+3.j],
E                      [2.-3.j, 1.+0.j]], dtype=complex64)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...1161e-08j]],\n      dtype=complex64)\n DESIRED: array([[1.+0.j, 2.+3.j],\n       [2.-3.j, 1.+0.j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestPinvHermitian object at 0x10967c2d0>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:354: AssertionError
________________________________________________________ TestEighCases.test_herm_cases _________________________________________________________

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
>               case.check(self.do)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...y([[ 1.842403+1.842403j, -3.256616-0.953841j],\n       [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:350:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <LinalgCase: hcsingle>, do = <bound method TestEighCases.do of <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>>

    def check(self, do):
        """
        Run the function `do` on this test case, expanding arguments
        """
>       do(self.a, self.b, tags=self.tags)

do         = <bound method TestEighCases.do of <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>>
self       = <LinalgCase: hcsingle>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:85:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>
a = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64), b = None, tags = frozenset({'hermitian'})

    def do(self, a, b, tags):
        # note that eigenvalue arrays returned by eig must be sorted since
        # their order isn't guaranteed.
        ev, evc = linalg.eigh(a)
        evalues, evectors = linalg.eig(a)
        evalues.sort(axis=-1)
        assert_almost_equal(ev, evalues)

>       assert_allclose(dot_generalized(a, evc),
                        np.asarray(ev)[..., None, :] * np.asarray(evc),
                        rtol=get_rtol(ev.dtype))

a          = array([[1.+0.j, 2.+3.j],
       [2.-3.j, 1.+0.j]], dtype=complex64)
b          = None
ev         = array([-2.6055512,  4.6055512], dtype=float32)
evalues    = array([-2.6055512-1.110223e-16j,  4.6055512+1.110223e-16j],
      dtype=complex64)
evc        = array([[-0.70710677-0.70710677j, -0.70710677-0.20710678j],
       [ 0.9805807 -0.19611613j, -0.8082574 +0.31099832j]],
      dtype=complex64)
evectors   = array([[ 0.70710677+0.j       ,  0.70710677+0.j       ],
       [ 0.39223227-0.5883484j, -0.39223227+0.5883484j]], dtype=complex64)
self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>
tags       = frozenset({'hermitian'})

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1152:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 1.8424029+1.842403j , -3.2566166-2.0098825j],
       [-2.554953 +0.5109906j, -2.8437912+2.018105j ]], dtype=complex64)
desired = array([[ 1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64)
rtol = 1e-05, atol = 0, equal_nan = True, err_msg = '', verbose = True

    def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
                        err_msg='', verbose=True):
        """
        Raises an AssertionError if two objects are not equal up to desired
        tolerance.

        Given two array_like objects, check that their shapes and all elements
        are equal (but see the Notes for the special handling of a scalar). An
        exception is raised if the shapes mismatch or any values conflict. In
        contrast to the standard usage in numpy, NaNs are compared like numbers,
        no assertion is raised if both objects have NaNs in the same positions.

        The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
        that ``allclose`` has different default values). It compares the difference
        between `actual` and `desired` to ``atol + rtol * abs(desired)``.

        .. versionadded:: 1.5.0

        Parameters
        ----------
        actual : array_like
            Array obtained.
        desired : array_like
            Array desired.
        rtol : float, optional
            Relative tolerance.
        atol : float, optional
            Absolute tolerance.
        equal_nan : bool, optional.
            If True, NaNs will compare equal.
        err_msg : str, optional
            The error message to be printed in case of failure.
        verbose : bool, optional
            If True, the conflicting values are appended to the error message.

        Raises
        ------
        AssertionError
            If actual and desired are not equal up to specified precision.

        See Also
        --------
        assert_array_almost_equal_nulp, assert_array_max_ulp

        Notes
        -----
        When one of `actual` and `desired` is a scalar and the other is
        array_like, the function checks that each element of the array_like
        object is equal to the scalar.

        Examples
        --------
        >>> x = [1e-5, 1e-3, 1e-1]
        >>> y = np.arccos(np.cos(x))
        >>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)

        """
        __tracebackhide__ = True  # Hide traceback for py.test
        import numpy as np

        def compare(x, y):
            return np.core.numeric.isclose(x, y, rtol=rtol, atol=atol,
                                           equal_nan=equal_nan)

        actual, desired = np.asanyarray(actual), np.asanyarray(desired)
        header = f'Not equal to tolerance rtol={rtol:g}, atol={atol:g}'
>       assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
                             verbose=verbose, header=header, equal_nan=equal_nan)

__tracebackhide__ = True
actual     = array([[ 1.8424029+1.842403j , -3.2566166-2.0098825j],
       [-2.554953 +0.5109906j, -2.8437912+2.018105j ]], dtype=complex64)
atol       = 0
compare    = <function assert_allclose.<locals>.compare at 0x10b0d6520>
desired    = array([[ 1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64)
equal_nan  = True
err_msg    = ''
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
np         = <module 'numpy' from '/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/__init__.py'>
rtol       = 1e-05
verbose    = True

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:1590:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

args = (<function assert_allclose.<locals>.compare at 0x10b0d6520>, array([[ 1.8424029+1.842403j , -3.2566166-2.0098825j],
  ...1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64))
kwds = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}

    @wraps(func)
    def inner(*args, **kwds):
        with self._recreate_cm():
>           return func(*args, **kwds)

args       = (<function assert_allclose.<locals>.compare at 0x10b0d6520>, array([[ 1.8424029+1.842403j , -3.2566166-2.0098825j],
  ...1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64))
func       = <function assert_array_compare at 0x106656ac0>
kwds       = {'equal_nan': True, 'err_msg': '', 'header': 'Not equal to tolerance rtol=1e-05, atol=0', 'verbose': True}
self       = <contextlib._GeneratorContextManager object at 0x106674090>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

comparison = <function assert_allclose.<locals>.compare at 0x10b0d6520>
x = array([ 1.8424029+1.842403j , -3.2566166-2.0098825j,
       -2.554953 +0.5109906j, -2.8437912+2.018105j ], dtype=complex64)
y = array([ 1.8424029+1.8424029j, -3.2566164-0.9538409j,
       -2.5549533+0.5109906j, -3.7224708+1.4323187j], dtype=complex64)
err_msg = '\nMismatched elements: 2 / 4 (50%)\nMax absolute difference: 1.0560415\nMax relative difference: 0.31120184', verbose = True
header = 'Not equal to tolerance rtol=1e-05, atol=0', precision = 6, equal_nan = True, equal_inf = True

    @np._no_nep50_warning()
    def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                             precision=6, equal_nan=True, equal_inf=True,
                             *, strict=False):
        __tracebackhide__ = True  # Hide traceback for py.test
        from numpy.core import array, array2string, isnan, inf, bool_, errstate, all, max, object_

        x = np.asanyarray(x)
        y = np.asanyarray(y)

        # original array for output formatting
        ox, oy = x, y

        def isnumber(x):
            return x.dtype.char in '?bhilqpBHILQPefdgFDG'

        def istime(x):
            return x.dtype.char in "Mm"

        def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
            """Handling nan/inf.

            Combine results of running func on x and y, checking that they are True
            at the same locations.

            """
            __tracebackhide__ = True  # Hide traceback for py.test

            x_id = func(x)
            y_id = func(y)
            # We include work-arounds here to handle three types of slightly
            # pathological ndarray subclasses:
            # (1) all() on `masked` array scalars can return masked arrays, so we
            #     use != True
            # (2) __eq__ on some ndarray subclasses returns Python booleans
            #     instead of element-wise comparisons, so we cast to bool_() and
            #     use isinstance(..., bool) checks
            # (3) subclasses with bare-bones __array_function__ implementations may
            #     not implement np.all(), so favor using the .all() method
            # We are not committed to supporting such subclasses, but it's nice to
            # support them if possible.
            if bool_(x_id == y_id).all() != True:
                msg = build_err_msg([x, y],
                                    err_msg + '\nx and y %s location mismatch:'
                                    % (hasval), verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)
            # If there is a scalar, then here we know the array has the same
            # flag as it everywhere, so we should return the scalar flag.
            if isinstance(x_id, bool) or x_id.ndim == 0:
                return bool_(x_id)
            elif isinstance(y_id, bool) or y_id.ndim == 0:
                return bool_(y_id)
            else:
                return y_id

        try:
            if strict:
                cond = x.shape == y.shape and x.dtype == y.dtype
            else:
                cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
            if not cond:
                if x.shape != y.shape:
                    reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
                else:
                    reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
                msg = build_err_msg([x, y],
                                    err_msg
                                    + reason,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
                raise AssertionError(msg)

            flagged = bool_(False)
            if isnumber(x) and isnumber(y):
                if equal_nan:
                    flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')

                if equal_inf:
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == +inf,
                                                    hasval='+inf')
                    flagged |= func_assert_same_pos(x, y,
                                                    func=lambda xy: xy == -inf,
                                                    hasval='-inf')

            elif istime(x) and istime(y):
                # If one is datetime64 and the other timedelta64 there is no point
                if equal_nan and x.dtype.type == y.dtype.type:
                    flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")

            if flagged.ndim > 0:
                x, y = x[~flagged], y[~flagged]
                # Only do the comparison if actual values are left
                if x.size == 0:
                    return
            elif flagged:
                # no sense doing comparison if everything is flagged.
                return

            val = comparison(x, y)

            if isinstance(val, bool):
                cond = val
                reduced = array([val])
            else:
                reduced = val.ravel()
                cond = reduced.all()

            # The below comparison is a hack to ensure that fully masked
            # results, for which val.ravel().all() returns np.ma.masked,
            # do not trigger a failure (np.ma.masked != True evaluates as
            # np.ma.masked, which is falsy).
            if cond != True:
                n_mismatch = reduced.size - reduced.sum(dtype=intp)
                n_elements = flagged.size if flagged.ndim != 0 else reduced.size
                percent_mismatch = 100 * n_mismatch / n_elements
                remarks = [
                    'Mismatched elements: {} / {} ({:.3g}%)'.format(
                        n_mismatch, n_elements, percent_mismatch)]

                with errstate(all='ignore'):
                    # ignore errors for non-numeric types
                    with contextlib.suppress(TypeError):
                        error = abs(x - y)
                        if np.issubdtype(x.dtype, np.unsignedinteger):
                            error2 = abs(y - x)
                            np.minimum(error, error2, out=error)
                        max_abs_error = max(error)
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max absolute difference: '
                                            + str(max_abs_error))
                        else:
                            remarks.append('Max absolute difference: '
                                            + array2string(max_abs_error))

                        # note: this definition of relative error matches that one
                        # used by assert_allclose (found in np.isclose)
                        # Filter values where the divisor would be zero
                        nonzero = bool_(y != 0)
                        if all(~nonzero):
                            max_rel_error = array(inf)
                        else:
                            max_rel_error = max(error[nonzero] / abs(y[nonzero]))
                        if getattr(error, 'dtype', object_) == object_:
                            remarks.append('Max relative difference: '
                                            + str(max_rel_error))
                        else:
                            remarks.append('Max relative difference: '
                                            + array2string(max_rel_error))

                err_msg += '\n' + '\n'.join(remarks)
                msg = build_err_msg([ox, oy], err_msg,
                                    verbose=verbose, header=header,
                                    names=('x', 'y'), precision=precision)
>               raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 2 / 4 (50%)
E               Max absolute difference: 1.0560415
E               Max relative difference: 0.31120184
E                x: array([[ 1.842403+1.842403j, -3.256617-2.009882j],
E                      [-2.554953+0.510991j, -2.843791+2.018105j]], dtype=complex64)
E                y: array([[ 1.842403+1.842403j, -3.256616-0.953841j],
E                      [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)

__tracebackhide__ = True
all        = <function all at 0x103970720>
array      = <built-in function array>
array2string = <function array2string at 0x10397f560>
bool_      = <class 'numpy.bool_'>
comparison = <function assert_allclose.<locals>.compare at 0x10b0d6520>
cond       = False
equal_inf  = True
equal_nan  = True
err_msg    = '\nMismatched elements: 2 / 4 (50%)\nMax absolute difference: 1.0560415\nMax relative difference: 0.31120184'
error      = array([1.1920929e-07, 1.0560415e+00, 2.3841858e-07, 1.0560414e+00],
      dtype=float32)
errstate   = <class 'numpy.errstate'>
flagged    = array([[False, False],
       [False, False]])
func_assert_same_pos = <function assert_array_compare.<locals>.func_assert_same_pos at 0x10b0d6700>
header     = 'Not equal to tolerance rtol=1e-05, atol=0'
inf        = inf
isnan      = <ufunc 'isnan'>
isnumber   = <function assert_array_compare.<locals>.isnumber at 0x10b0d65c0>
istime     = <function assert_array_compare.<locals>.istime at 0x10b0d67a0>
max        = <function amax at 0x103970cc0>
max_abs_error = 1.0560415
max_rel_error = 0.31120184
msg        = '\nNot equal to tolerance rtol=1e-05, atol=0\n\nMismatched elements: 2 / 4 (50%)\nMax absolute difference: 1.0560415\n...ray([[ 1.842403+1.842403j, -3.256616-0.953841j],\n       [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)'
n_elements = 4
n_mismatch = 2
nonzero    = array([ True,  True,  True,  True])
object_    = <class 'numpy.object_'>
ox         = array([[ 1.8424029+1.842403j , -3.2566166-2.0098825j],
       [-2.554953 +0.5109906j, -2.8437912+2.018105j ]], dtype=complex64)
oy         = array([[ 1.8424029+1.8424029j, -3.2566164-0.9538409j],
       [-2.5549533+0.5109906j, -3.7224708+1.4323187j]], dtype=complex64)
percent_mismatch = 50.0
precision  = 6
reduced    = array([ True, False,  True, False])
remarks    = ['Mismatched elements: 2 / 4 (50%)', 'Max absolute difference: 1.0560415', 'Max relative difference: 0.31120184']
strict     = False
val        = array([ True, False,  True, False])
verbose    = True
x          = array([ 1.8424029+1.842403j , -3.2566166-2.0098825j,
       -2.554953 +0.5109906j, -2.8437912+2.018105j ], dtype=complex64)
y          = array([ 1.8424029+1.8424029j, -3.2566164-0.9538409j,
       -2.5549533+0.5109906j, -3.7224708+1.4323187j], dtype=complex64)

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py:862: AssertionError

The above exception was the direct cause of the following exception:

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>

    def test_herm_cases(self):
>       self.check_cases(require={'hermitian'},
                         exclude={'generalized', 'size-0'})

self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:382:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>, require = {'hermitian'}, exclude = {'generalized', 'size-0'}

    def check_cases(self, require=set(), exclude=set()):
        """
        Run func on each of the cases with all of the tags in require, and none
        of the tags in exclude
        """
        for case in self.TEST_CASES:
            # filter by require and exclude
            if case.tags & require != require:
                continue
            if case.tags & exclude:
                continue

            try:
                case.check(self.do)
            except Exception as e:
                msg = f'In test case: {case!r}\n\n'
                msg += traceback.format_exc()
>               raise AssertionError(msg) from e
E               AssertionError: In test case: <LinalgCase: hcsingle>
E
E               Traceback (most recent call last):
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 350, in check_cases
E                   case.check(self.do)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 85, in check
E                   do(self.a, self.b, tags=self.tags)
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py", line 1152, in do
E                   assert_allclose(dot_generalized(a, evc),
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 1590, in assert_allclose
E                   assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/contextlib.py", line 81, in inner
E                   return func(*args, **kwds)
E                          ^^^^^^^^^^^^^^^^^^^
E                 File "/Users/rgommers/mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/testing/_private/utils.py", line 862, in assert_array_compare
E                   raise AssertionError(msg)
E               AssertionError:
E               Not equal to tolerance rtol=1e-05, atol=0
E
E               Mismatched elements: 2 / 4 (50%)
E               Max absolute difference: 1.0560415
E               Max relative difference: 0.31120184
E                x: array([[ 1.842403+1.842403j, -3.256617-2.009882j],
E                      [-2.554953+0.510991j, -2.843791+2.018105j]], dtype=complex64)
E                y: array([[ 1.842403+1.842403j, -3.256616-0.953841j],
E                      [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)

case       = <LinalgCase: hcsingle>
exclude    = {'generalized', 'size-0'}
msg        = 'In test case: <LinalgCase: hcsingle>\n\nTraceback (most recent call last):\n  File "/Users/rgommers/mambaforge/envs/n...y([[ 1.842403+1.842403j, -3.256616-0.953841j],\n       [-2.554953+0.510991j, -3.722471+1.432319j]], dtype=complex64)\n'
require    = {'hermitian'}
self       = <numpy.linalg.tests.test_linalg.TestEighCases object at 0x1096f6cd0>

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:354: AssertionError
______________________________________________ TestCholesky.test_basic_property[complex64-shape1] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109764d50>, shape = (2, 2), dtype = <class 'numpy.complex64'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[ 6.7107615-9.0146355e-17j, -3.746924 -9.3489879e-01j],
       [-3.746924 +9.3489879e-01j,  7.402024 -6.6018370e-17j]],
      dtype=complex64)
dtype      = <class 'numpy.complex64'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109764d50>
shape      = (2, 2)
t          = [-1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[ 6.7107615-9.0146355e-17j, -3.746924 -9.3489879e-01j],
       [-3.746924 +9.3489879e-01j,  7.402024 -6.6018370e-17j]],
      dtype=complex64),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[ 6.7107615-9.0146355e-17j, -3.746924 -9.3489879e-01j],
       [-3.746924 +9.3489879e-01j,  7.402024 -6.6018370e-17j]],
      dtype=complex64),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[ 6.7107615-9.0146355e-17j, -3.746924 -9.3489879e-01j],
       [-3.746924 +9.3489879e-01j,  7.402024 -6.6018370e-17j]],
      dtype=complex64)
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex64'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b773210>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
______________________________________________ TestCholesky.test_basic_property[complex64-shape2] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109765090>, shape = (3, 3), dtype = <class 'numpy.complex64'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[ 8.210027 +9.7039469e-17j, -3.3015501+1.7754153e+00j,
         3.2819488-6.6174345e+00j],
       [-3.3015501-1...j],
       [ 3.2819488+6.6174345e+00j, -5.207721 -2.8530483e+00j,
        11.97808  -2.0396841e-16j]], dtype=complex64)
dtype      = <class 'numpy.complex64'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109765090>
shape      = (3, 3)
t          = [-1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[ 8.210027 +9.7039469e-17j, -3.3015501+1.7754153e+00j,
         3.2819488-6.6174345e+00j],
       [-3.3015501-...,
       [ 3.2819488+6.6174345e+00j, -5.207721 -2.8530483e+00j,
        11.97808  -2.0396841e-16j]], dtype=complex64),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[ 8.210027 +9.7039469e-17j, -3.3015501+1.7754153e+00j,
         3.2819488-6.6174345e+00j],
       [-3.3015501-...,
       [ 3.2819488+6.6174345e+00j, -5.207721 -2.8530483e+00j,
        11.97808  -2.0396841e-16j]], dtype=complex64),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[ 8.210027 +9.7039469e-17j, -3.3015501+1.7754153e+00j,
         3.2819488-6.6174345e+00j],
       [-3.3015501-1...j],
       [ 3.2819488+6.6174345e+00j, -5.207721 -2.8530483e+00j,
        11.97808  -2.0396841e-16j]], dtype=complex64)
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex64'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b044030>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
______________________________________________ TestCholesky.test_basic_property[complex64-shape3] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x1097653d0>, shape = (50, 50), dtype = <class 'numpy.complex64'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[ 86.08559   +1.8068895e-16j,   3.4421804 +1.5881272e+01j,
         -0.45363563-4.4661412e-01j, ...,   2.640359...  3.5472295 -1.0603434e+00j,
        -15.734409  +2.6528928e+00j,  89.70911   -1.6849805e-16j]],
      dtype=complex64)
dtype      = <class 'numpy.complex64'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x1097653d0>
shape      = (50, 50)
t          = [-1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[ 86.08559   +1.8068895e-16j,   3.4421804 +1.5881272e+01j,
         -0.45363563-4.4661412e-01j, ...,   2.64035...3.5472295 -1.0603434e+00j,
        -15.734409  +2.6528928e+00j,  89.70911   -1.6849805e-16j]],
      dtype=complex64),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[ 86.08559   +1.8068895e-16j,   3.4421804 +1.5881272e+01j,
         -0.45363563-4.4661412e-01j, ...,   2.64035...3.5472295 -1.0603434e+00j,
        -15.734409  +2.6528928e+00j,  89.70911   -1.6849805e-16j]],
      dtype=complex64),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[ 86.08559   +1.8068895e-16j,   3.4421804 +1.5881272e+01j,
         -0.45363563-4.4661412e-01j, ...,   2.640359...  3.5472295 -1.0603434e+00j,
        -15.734409  +2.6528928e+00j,  89.70911   -1.6849805e-16j]],
      dtype=complex64)
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex64'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b7f2730>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
______________________________________________ TestCholesky.test_basic_property[complex64-shape4] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109765710>, shape = (3, 10, 10), dtype = <class 'numpy.complex64'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[[ 2.0737574e+01+3.29707813e-16j, -9.5955276e+00+5.31176758e+00j,
         -3.3324742e+00+3.40434051e+00j, -7.6...+00-3.43903995e+00j,
         -1.0115569e+01-2.07136607e+00j,  2.4076559e+01-1.08485803e-16j]]],
      dtype=complex64)
dtype      = <class 'numpy.complex64'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109765710>
shape      = (3, 10, 10)
t          = [0, -1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[[ 2.0737574e+01+3.29707813e-16j, -9.5955276e+00+5.31176758e+00j,
         -3.3324742e+00+3.40434051e+00j, -7....0-3.43903995e+00j,
         -1.0115569e+01-2.07136607e+00j,  2.4076559e+01-1.08485803e-16j]]],
      dtype=complex64),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[[ 2.0737574e+01+3.29707813e-16j, -9.5955276e+00+5.31176758e+00j,
         -3.3324742e+00+3.40434051e+00j, -7....0-3.43903995e+00j,
         -1.0115569e+01-2.07136607e+00j,  2.4076559e+01-1.08485803e-16j]]],
      dtype=complex64),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[[ 2.0737574e+01+3.29707813e-16j, -9.5955276e+00+5.31176758e+00j,
         -3.3324742e+00+3.40434051e+00j, -7.6...+00-3.43903995e+00j,
         -1.0115569e+01-2.07136607e+00j,  2.4076559e+01-1.08485803e-16j]]],
      dtype=complex64)
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex64'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b7c0b70>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
_____________________________________________ TestCholesky.test_basic_property[complex128-shape1] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109765d90>, shape = (2, 2), dtype = <class 'numpy.complex128'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[ 6.71076172-9.01463546e-17j, -3.74692388-9.34898787e-01j],
       [-3.74692388+9.34898787e-01j,  7.40202389-6.60183692e-17j]])
dtype      = <class 'numpy.complex128'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109765d90>
shape      = (2, 2)
t          = [-1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[ 6.71076172-9.01463546e-17j, -3.74692388-9.34898787e-01j],
       [-3.74692388+9.34898787e-01j,  7.40202389-6.60183692e-17j]]),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[ 6.71076172-9.01463546e-17j, -3.74692388-9.34898787e-01j],
       [-3.74692388+9.34898787e-01j,  7.40202389-6.60183692e-17j]]),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[ 6.71076172-9.01463546e-17j, -3.74692388-9.34898787e-01j],
       [-3.74692388+9.34898787e-01j,  7.40202389-6.60183692e-17j]])
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex128'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b7a4db0>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
_____________________________________________ TestCholesky.test_basic_property[complex128-shape2] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x1097660d0>, shape = (3, 3), dtype = <class 'numpy.complex128'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[ 8.21002685+9.70394725e-17j, -3.30155008+1.77541531e+00j,
         3.28194873-6.61743449e+00j],
       [-3.301...5304839e+00j],
       [ 3.28194873+6.61743449e+00j, -5.20772107-2.85304839e+00j,
        11.97808001-2.03968406e-16j]])
dtype      = <class 'numpy.complex128'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x1097660d0>
shape      = (3, 3)
t          = [-1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[ 8.21002685+9.70394725e-17j, -3.30155008+1.77541531e+00j,
         3.28194873-6.61743449e+00j],
       [-3.30...04839e+00j],
       [ 3.28194873+6.61743449e+00j, -5.20772107-2.85304839e+00j,
        11.97808001-2.03968406e-16j]]),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[ 8.21002685+9.70394725e-17j, -3.30155008+1.77541531e+00j,
         3.28194873-6.61743449e+00j],
       [-3.30...04839e+00j],
       [ 3.28194873+6.61743449e+00j, -5.20772107-2.85304839e+00j,
        11.97808001-2.03968406e-16j]]),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[ 8.21002685+9.70394725e-17j, -3.30155008+1.77541531e+00j,
         3.28194873-6.61743449e+00j],
       [-3.301...5304839e+00j],
       [ 3.28194873+6.61743449e+00j, -5.20772107-2.85304839e+00j,
        11.97808001-2.03968406e-16j]])
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex128'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b7a4930>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
_____________________________________________ TestCholesky.test_basic_property[complex128-shape3] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109766410>, shape = (50, 50), dtype = <class 'numpy.complex128'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[ 86.08558859+1.80688949e-16j,   3.44218047+1.58812724e+01j,
         -0.45363563-4.46614131e-01j, ...,   2.640...34571312e-01j, ...,   3.54722947-1.06034335e+00j,
        -15.73440912+2.65289272e+00j,  89.70910493-1.68498058e-16j]])
dtype      = <class 'numpy.complex128'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109766410>
shape      = (50, 50)
t          = [-1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[ 86.08558859+1.80688949e-16j,   3.44218047+1.58812724e+01j,
         -0.45363563-4.46614131e-01j, ...,   2.64...571312e-01j, ...,   3.54722947-1.06034335e+00j,
        -15.73440912+2.65289272e+00j,  89.70910493-1.68498058e-16j]]),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[ 86.08558859+1.80688949e-16j,   3.44218047+1.58812724e+01j,
         -0.45363563-4.46614131e-01j, ...,   2.64...571312e-01j, ...,   3.54722947-1.06034335e+00j,
        -15.73440912+2.65289272e+00j,  89.70910493-1.68498058e-16j]]),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[ 86.08558859+1.80688949e-16j,   3.44218047+1.58812724e+01j,
         -0.45363563-4.46614131e-01j, ...,   2.640...34571312e-01j, ...,   3.54722947-1.06034335e+00j,
        -15.73440912+2.65289272e+00j,  89.70910493-1.68498058e-16j]])
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex128'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b7a4db0>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
_____________________________________________ TestCholesky.test_basic_property[complex128-shape4] ______________________________________________

self = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109766750>, shape = (3, 10, 10), dtype = <class 'numpy.complex128'>

    @pytest.mark.parametrize(
        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    )
    @pytest.mark.parametrize(
        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
    )
    def test_basic_property(self, shape, dtype):
        # Check A = L L^H
        np.random.seed(1)
        a = np.random.randn(*shape)
        if np.issubdtype(dtype, np.complexfloating):
            a = a + 1j*np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = np.matmul(a.transpose(t).conj(), a)
        a = np.asarray(a, dtype=dtype)

>       c = np.linalg.cholesky(a)

a          = array([[[ 2.07375744e+01+3.29707800e-16j,
         -9.59552753e+00+5.31176763e+00j,
         -3.33247414e+00+3.4043406... 1.89501151e+00-3.43904000e+00j,
         -1.01155689e+01-2.07136618e+00j,
          2.40765597e+01-1.08485801e-16j]]])
dtype      = <class 'numpy.complex128'>
self       = <numpy.linalg.tests.test_linalg.TestCholesky object at 0x109766750>
shape      = (3, 10, 10)
t          = [0, -1, -2]

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/tests/test_linalg.py:1804:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<__array_function__ internals>:200: in cholesky
    ???
        args       = (array([[[ 2.07375744e+01+3.29707800e-16j,
         -9.59552753e+00+5.31176763e+00j,
         -3.33247414e+00+3.404340....89501151e+00-3.43904000e+00j,
         -1.01155689e+01-2.07136618e+00j,
          2.40765597e+01-1.08485801e-16j]]]),)
        dispatcher = <function _unary_dispatcher at 0x103ac2340>
        implementation = <function cholesky at 0x103ac28e0>
        kwargs     = {}
        public_api = <function cholesky at 0x103ac2980>
        relevant_args = (array([[[ 2.07375744e+01+3.29707800e-16j,
         -9.59552753e+00+5.31176763e+00j,
         -3.33247414e+00+3.404340....89501151e+00-3.43904000e+00j,
         -1.01155689e+01-2.07136618e+00j,
          2.40765597e+01-1.08485801e-16j]]]),)
../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:756: in cholesky
    r = gufunc(a, signature=signature, extobj=extobj)
        a          = array([[[ 2.07375744e+01+3.29707800e-16j,
         -9.59552753e+00+5.31176763e+00j,
         -3.33247414e+00+3.4043406... 1.89501151e+00-3.43904000e+00j,
         -1.01155689e+01-2.07136618e+00j,
          2.40765597e+01-1.08485801e-16j]]])
        extobj     = [8192, 1536, <function _raise_linalgerror_nonposdef at 0x103ac1260>]
        gufunc     = <ufunc 'cholesky_lo'>
        result_t   = <class 'numpy.complex128'>
        signature  = 'D->D'
        t          = <class 'numpy.complex128'>
        wrap       = <built-in method __array_prepare__ of numpy.ndarray object at 0x10b7a44b0>
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

err = 'invalid value', flag = 8

    def _raise_linalgerror_nonposdef(err, flag):
>       raise LinAlgError("Matrix is not positive definite")
E       numpy.linalg.LinAlgError: Matrix is not positive definite

err        = 'invalid value'
flag       = 8

../../mambaforge/envs/numpyp-arm64-issue/lib/python3.11/site-packages/numpy/linalg/linalg.py:92: LinAlgError
=========================================================== short test summary info ============================================================
FAILED tests/test_linalg.py::TestSVDHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestPinvHermitian::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestEighCases::test_herm_cases - AssertionError: In test case: <LinalgCase: hcsingle>
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape1] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape2] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape3] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex64-shape4] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape1] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape2] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape3] - numpy.linalg.LinAlgError: Matrix is not positive definite
FAILED tests/test_linalg.py::TestCholesky::test_basic_property[complex128-shape4] - numpy.linalg.LinAlgError: Matrix is not positive definite
11 failed, 375 passed, 2 skipped, 27 deselected, 2 xfailed in 1.93s

With openblas, all tests pass.

[jcmgray]

That's a little odd. Either way, openblas is the default so a simple mamba create -n tmp-env numpy=1.24.1 will use openblas.

Yes likely a separate issue, but thought I'd note that at least on my Mac the default install (i.e, this exact command) is the netlib blas variant, not openblas. When I use openblas I get an error that is essentially libcblas.3.dylib' (no such file).. perhaps I am missing some dep that makes conda/mamba avoid openblas.

[rgommers]

Hmm, no idea why. That's a significant performance penalty, so I'd consider getting netlib by default a bug. The openblas packages for both x86-64 and arm64 at https://anaconda.org/conda-forge/openblas are up to date, so I can't explain what is happening there. Maybe someone more familiar with the BLAS selection mechanism can.

[h-vetinari]

Seems like I need to get the blas testing series up to speed for 1.24.

Yes likely a separate issue, but thought I'd note that at least on my Mac the default install (i.e, this exact command) is the netlib blas variant, not openblas. When I use openblas I get an error that is essentially libcblas.3.dylib' (no such file).. perhaps I am missing some dep that makes conda/mamba avoid openblas.

openblas should be the default also on osx, and in any case it should definitely work. However, you're mixing channels (default and conda-forge), which is a very likely cause for these problems. Could you please try

conda config --add channels conda-forge
conda config --set channel_priority strict

and then either a new environment, or using conda update --all?

[jcmgray]

openblas should be the default also on osx, and in any case it should definitely work. However, you're mixing channels (default and conda-forge), which is a very likely cause for these problems. Could you please try

Ah sorry yes you are right, thanks for the suggestion.

[rh996]

I am using a Mac mini M1 and recently found this issue. It works fine with "libblas=*=*openblas" and "libblas=*=*netlib". However, the eigh issue appears when I update Numpy using "libblas=*=*accelerate". Probably this is because they didn't update the libblas 3.9.0-16_osxarm64_accelerate in conda-forge? @jcmgray is your problem solved? Where can I ask for updating the libblas 3.9.0-16_osxarm64_accelerate package since complex eigenvector problems are significant in physics?

[cosmic-latte]

numpy/numpy#24640

[cosmic-latte]

Experienced the same problem on numpy 1.26.0 with accelerate blas.