"""

Utility function to facilitate testing.

"""

import concurrent.futures

import contextlib

import gc

import importlib.metadata

import operator

import os

import pathlib

import platform

import pprint

import re

import shutil

import sys

import sysconfig

import threading

import warnings

from functools import partial, wraps

from io import StringIO

from tempfile import mkdtemp, mkstemp

from unittest.case import SkipTest

from warnings import WarningMessage

import numpy as np

import numpy.linalg._umath_linalg

from numpy import isfinite, isnan

from numpy._core import arange, array, array_repr, empty, float32, intp, isnat, ndarray

__all__ = [

'assert_equal', 'assert_almost_equal', 'assert_approx_equal',

'assert_array_equal', 'assert_array_less', 'assert_string_equal',

'assert_array_almost_equal', 'assert_raises', 'build_err_msg',

'decorate_methods', 'jiffies', 'memusage', 'print_assert_equal',

'rundocs', 'runstring', 'verbose', 'measure',

'assert_', 'assert_array_almost_equal_nulp', 'assert_raises_regex',

'assert_array_max_ulp', 'assert_warns', 'assert_no_warnings',

'assert_allclose', 'IgnoreException', 'clear_and_catch_warnings',

'SkipTest', 'KnownFailureException', 'temppath', 'tempdir', 'IS_PYPY',

'HAS_REFCOUNT', "IS_WASM", 'suppress_warnings', 'assert_array_compare',

'assert_no_gc_cycles', 'break_cycles', 'HAS_LAPACK64', 'IS_PYSTON',

'IS_MUSL', 'check_support_sve', 'NOGIL_BUILD',

'IS_EDITABLE', 'IS_INSTALLED', 'NUMPY_ROOT', 'run_threaded', 'IS_64BIT',

'BLAS_SUPPORTS_FPE',

]

class KnownFailureException(Exception):

'''Raise this exception to mark a test as a known failing test.'''

pass

KnownFailureTest = KnownFailureException # backwards compat

verbose = 0

NUMPY_ROOT = pathlib.Path(np.__file__).parent

try:

np_dist = importlib.metadata.distribution('numpy')

except importlib.metadata.PackageNotFoundError:

IS_INSTALLED = IS_EDITABLE = False

else:

IS_INSTALLED = True

try:

if sys.version_info >= (3, 13):

IS_EDITABLE = np_dist.origin.dir_info.editable

else:

# Backport importlib.metadata.Distribution.origin

import json # noqa: E401

import types

origin = json.loads(

np_dist.read_text('direct_url.json') or '{}',

object_hook=lambda data: types.SimpleNamespace(**data),

)

IS_EDITABLE = origin.dir_info.editable

except AttributeError:

IS_EDITABLE = False

# spin installs numpy directly via meson, instead of using meson-python, and

# runs the module by setting PYTHONPATH. This is problematic because the

# resulting installation lacks the Python metadata (.dist-info), and numpy

# might already be installed on the environment, causing us to find its

# metadata, even though we are not actually loading that package.

# Work around this issue by checking if the numpy root matches.

if not IS_EDITABLE and np_dist.locate_file('numpy') != NUMPY_ROOT:

IS_INSTALLED = False

IS_WASM = platform.machine() in ["wasm32", "wasm64"]

IS_PYPY = sys.implementation.name == 'pypy'

IS_PYSTON = hasattr(sys, "pyston_version_info")

HAS_REFCOUNT = getattr(sys, 'getrefcount', None) is not None and not IS_PYSTON

BLAS_SUPPORTS_FPE = np._core._multiarray_umath._blas_supports_fpe(None)

HAS_LAPACK64 = numpy.linalg._umath_linalg._ilp64

IS_MUSL = False

# alternate way is

# from packaging.tags import sys_tags

# _tags = list(sys_tags())

# if 'musllinux' in _tags[0].platform:

_v = sysconfig.get_config_var('HOST_GNU_TYPE') or ''

if 'musl' in _v:

IS_MUSL = True

NOGIL_BUILD = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))

IS_64BIT = np.dtype(np.intp).itemsize == 8

def assert_(val, msg=''):

"""

Assert that works in release mode.

Accepts callable msg to allow deferring evaluation until failure.

The Python built-in ``assert`` does not work when executing code in

optimized mode (the ``-O`` flag) - no byte-code is generated for it.

For documentation on usage, refer to the Python documentation.

"""

__tracebackhide__ = True # Hide traceback for py.test

if not val:

try:

smsg = msg()

except TypeError:

smsg = msg

raise AssertionError(smsg)

if os.name == 'nt':

# Code "stolen" from enthought/debug/memusage.py

def GetPerformanceAttributes(object, counter, instance=None,

inum=-1, format=None, machine=None):

# NOTE: Many counters require 2 samples to give accurate results,

# including "% Processor Time" (as by definition, at any instant, a

# thread's CPU usage is either 0 or 100). To read counters like this,

# you should copy this function, but keep the counter open, and call

# CollectQueryData() each time you need to know.

# See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp

# (dead link)

# My older explanation for this was that the "AddCounter" process

# forced the CPU to 100%, but the above makes more sense :)

import win32pdh

if format is None:

format = win32pdh.PDH_FMT_LONG

path = win32pdh.MakeCounterPath((machine, object, instance, None,

inum, counter))

hq = win32pdh.OpenQuery()

try:

hc = win32pdh.AddCounter(hq, path)

try:

win32pdh.CollectQueryData(hq)

type, val = win32pdh.GetFormattedCounterValue(hc, format)

return val

finally:

win32pdh.RemoveCounter(hc)

finally:

win32pdh.CloseQuery(hq)

def memusage(processName="python", instance=0):

# from win32pdhutil, part of the win32all package

import win32pdh

return GetPerformanceAttributes("Process", "Virtual Bytes",

processName, instance,

win32pdh.PDH_FMT_LONG, None)

elif sys.platform[:5] == 'linux':

def memusage(_proc_pid_stat=None):

"""

Return virtual memory size in bytes of the running python.

"""

_proc_pid_stat = _proc_pid_stat or f'/proc/{os.getpid()}/stat'

try:

with open(_proc_pid_stat) as f:

l = f.readline().split(' ')

return int(l[22])

except Exception:

return

else:

def memusage():

"""

Return memory usage of running python. [Not implemented]

"""

raise NotImplementedError

if sys.platform[:5] == 'linux':

def jiffies(_proc_pid_stat=None, _load_time=None):

"""

Return number of jiffies elapsed.

Return number of jiffies (1/100ths of a second) that this

process has been scheduled in user mode. See man 5 proc.

"""

_proc_pid_stat = _proc_pid_stat or f'/proc/{os.getpid()}/stat'

_load_time = _load_time or []

import time

if not _load_time:

_load_time.append(time.time())

try:

with open(_proc_pid_stat) as f:

l = f.readline().split(' ')

return int(l[13])

except Exception:

return int(100 * (time.time() - _load_time[0]))

else:

# os.getpid is not in all platforms available.

# Using time is safe but inaccurate, especially when process

# was suspended or sleeping.

def jiffies(_load_time=[]):

"""

Return number of jiffies elapsed.

Return number of jiffies (1/100ths of a second) that this

process has been scheduled in user mode. See man 5 proc.

"""

import time

if not _load_time:

_load_time.append(time.time())

return int(100 * (time.time() - _load_time[0]))

def build_err_msg(arrays, err_msg, header='Items are not equal:',

verbose=True, names=('ACTUAL', 'DESIRED'), precision=8):

msg = ['\n' + header]

err_msg = str(err_msg)

if err_msg:

if err_msg.find('\n') == -1 and len(err_msg) < 79 - len(header):

msg = [msg[0] + ' ' + err_msg]

else:

msg.append(err_msg)

if verbose:

for i, a in enumerate(arrays):

if isinstance(a, ndarray):

# precision argument is only needed if the objects are ndarrays

r_func = partial(array_repr, precision=precision)

else:

r_func = repr

try:

r = r_func(a)

except Exception as exc:

r = f'[repr failed for <{type(a).__name__}>: {exc}]'

if r.count('\n') > 3:

r = '\n'.join(r.splitlines()[:3])

r += '...'

msg.append(f' {names[i]}: {r}')

return '\n'.join(msg)

def assert_equal(actual, desired, err_msg='', verbose=True, *, strict=False):

"""

Raises an AssertionError if two objects are not equal.

Given two objects (scalars, lists, tuples, dictionaries or numpy arrays),

check that all elements of these objects are equal. An exception is raised

at the first conflicting values.

This function handles NaN comparisons as if NaN was a "normal" number.

That is, AssertionError is not raised if both objects have NaNs in the same

positions. This is in contrast to the IEEE standard on NaNs, which says

that NaN compared to anything must return False.

Parameters

----------

actual : array_like

The object to check.

desired : array_like

The expected object.

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.

strict : bool, optional

If True and either of the `actual` and `desired` arguments is an array,

raise an ``AssertionError`` when either the shape or the data type of

the arguments does not match. If neither argument is an array, this

parameter has no effect.

.. versionadded:: 2.0.0

Raises

------

AssertionError

If actual and desired are not equal.

See Also

--------

assert_allclose

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 is equal to the scalar.

Note that empty arrays are therefore considered equal to scalars.

This behaviour can be disabled by setting ``strict==True``.

Examples

--------

>>> np.testing.assert_equal([4, 5], [4, 6])

Traceback (most recent call last):

...

AssertionError:

Items are not equal:

item=1

ACTUAL: 5

DESIRED: 6

The following comparison does not raise an exception. There are NaNs

in the inputs, but they are in the same positions.

>>> np.testing.assert_equal(np.array([1.0, 2.0, np.nan]), [1, 2, np.nan])

As mentioned in the Notes section, `assert_equal` has special

handling for scalars when one of the arguments is an array.

Here, the test checks that each value in `x` is 3:

>>> x = np.full((2, 5), fill_value=3)

>>> np.testing.assert_equal(x, 3)

Use `strict` to raise an AssertionError when comparing a scalar with an

array of a different shape:

>>> np.testing.assert_equal(x, 3, strict=True)

Traceback (most recent call last):

...

AssertionError:

Arrays are not equal

<BLANKLINE>

(shapes (2, 5), () mismatch)

ACTUAL: array([[3, 3, 3, 3, 3],

[3, 3, 3, 3, 3]])

DESIRED: array(3)

The `strict` parameter also ensures that the array data types match:

>>> x = np.array([2, 2, 2])

>>> y = np.array([2., 2., 2.], dtype=np.float32)

>>> np.testing.assert_equal(x, y, strict=True)

Traceback (most recent call last):

...

AssertionError:

Arrays are not equal

<BLANKLINE>

(dtypes int64, float32 mismatch)

ACTUAL: array([2, 2, 2])

DESIRED: array([2., 2., 2.], dtype=float32)

"""

__tracebackhide__ = True # Hide traceback for py.test

if isinstance(desired, dict):

if not isinstance(actual, dict):

raise AssertionError(repr(type(actual)))

assert_equal(len(actual), len(desired), err_msg, verbose)

for k in desired:

if k not in actual:

raise AssertionError(repr(k))

assert_equal(actual[k], desired[k], f'key={k!r}\n{err_msg}',

verbose)

return

if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):

assert_equal(len(actual), len(desired), err_msg, verbose)

for k in range(len(desired)):

assert_equal(actual[k], desired[k], f'item={k!r}\n{err_msg}',

verbose)

return

from numpy import imag, iscomplexobj, real

from numpy._core import isscalar, ndarray, signbit

if isinstance(actual, ndarray) or isinstance(desired, ndarray):

return assert_array_equal(actual, desired, err_msg, verbose,

strict=strict)

msg = build_err_msg([actual, desired], err_msg, verbose=verbose)

# 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, TypeError):

usecomplex = False

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_equal(actualr, desiredr)

assert_equal(actuali, desiredi)

except AssertionError:

raise AssertionError(msg)

# isscalar test to check cases such as [np.nan] != np.nan

if isscalar(desired) != isscalar(actual):

raise AssertionError(msg)

try:

isdesnat = isnat(desired)

isactnat = isnat(actual)

dtypes_match = (np.asarray(desired).dtype.type ==

np.asarray(actual).dtype.type)

if isdesnat and isactnat:

# If both are NaT (and have the same dtype -- datetime or

# timedelta) they are considered equal.

if dtypes_match:

return

else:

raise AssertionError(msg)

except (TypeError, ValueError, NotImplementedError):

pass

# Inf/nan/negative zero handling

try:

isdesnan = isnan(desired)

isactnan = isnan(actual)

if isdesnan and isactnan:

return # both nan, so equal

# handle signed zero specially for floats

array_actual = np.asarray(actual)

array_desired = np.asarray(desired)

if (array_actual.dtype.char in 'Mm' or

array_desired.dtype.char in 'Mm'):

# version 1.18

# until this version, isnan failed for datetime64 and timedelta64.

# Now it succeeds but comparison to scalar with a different type

# emits a DeprecationWarning.

# Avoid that by skipping the next check

raise NotImplementedError('cannot compare to a scalar '

'with a different type')

if desired == 0 and actual == 0:

if not signbit(desired) == signbit(actual):

raise AssertionError(msg)

except (TypeError, ValueError, NotImplementedError):

pass

try:

# Explicitly use __eq__ for comparison, gh-2552

if not (desired == actual):

raise AssertionError(msg)

except (DeprecationWarning, FutureWarning) as e:

# this handles the case when the two types are not even comparable

if 'elementwise == comparison' in e.args[0]:

raise AssertionError(msg)

else:

raise

def print_assert_equal(test_string, actual, desired):

"""

Test if two objects are equal, and print an error message if test fails.

The test is performed with ``actual == desired``.

Parameters

----------

test_string : str

The message supplied to AssertionError.

actual : object

The object to test for equality against `desired`.

desired : object

The expected result.

Examples

--------

>>> np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 1])

>>> np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 2])

Traceback (most recent call last):

...

AssertionError: Test XYZ of func xyz failed

ACTUAL:

[0, 1]

DESIRED:

[0, 2]

"""

__tracebackhide__ = True # Hide traceback for py.test

import pprint

if not (actual == desired):

msg = StringIO()

msg.write(test_string)

msg.write(' failed\nACTUAL: \n')

pprint.pprint(actual, msg)

msg.write('DESIRED: \n')

pprint.pprint(desired, msg)

raise AssertionError(msg.getvalue())

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%)

Mismatch at index:

[1]: 2.3333333333333 (ACTUAL), 2.33333334 (DESIRED)

Max absolute difference among violations: 6.66669964e-09

Max relative difference among violations: 2.85715698e-09

ACTUAL: array([1. , 2.333333333])

DESIRED: array([1. , 2.33333334])

"""

__tracebackhide__ = True # Hide traceback for py.test

from numpy import imag, iscomplexobj, real

from numpy._core import ndarray

# 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)

try:

# If one of desired/actual is not finite, handle it specially here:

# check that both are nan if any is a nan, and test for equality

# otherwise

if not (isfinite(desired) and isfinite(actual)):

if isnan(desired) or isnan(actual):

if not (isnan(desired) and isnan(actual)):

raise AssertionError(_build_err_msg())

elif not desired == actual:

raise AssertionError(_build_err_msg())

return

except (NotImplementedError, TypeError):

pass

if abs(desired - actual) >= np.float64(1.5 * 10.0**(-decimal)):

raise AssertionError(_build_err_msg())

def assert_approx_equal(actual, desired, significant=7, err_msg='',

verbose=True):

"""

Raises an AssertionError if two items are not equal up to significant

digits.

.. 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.

Given two numbers, check that they are approximately equal.

Approximately equal is defined as the number of significant digits

that agree.

Parameters

----------

actual : scalar

The object to check.

desired : scalar

The expected object.

significant : 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

--------

>>> np.testing.assert_approx_equal(0.12345677777777e-20, 0.1234567e-20)

>>> np.testing.assert_approx_equal(0.12345670e-20, 0.12345671e-20,

... significant=8)

>>> np.testing.assert_approx_equal(0.12345670e-20, 0.12345672e-20,

... significant=8)

Traceback (most recent call last):

...

AssertionError:

Items are not equal to 8 significant digits:

ACTUAL: 1.234567e-21

DESIRED: 1.2345672e-21

the evaluated condition that raises the exception is

>>> abs(0.12345670e-20/1e-21 - 0.12345672e-20/1e-21) >= 10**-(8-1)

True

"""

__tracebackhide__ = True # Hide traceback for py.test

import numpy as np

(actual, desired) = map(float, (actual, desired))

if desired == actual:

return

# Normalized the numbers to be in range (-10.0,10.0)

# scale = float(pow(10,math.floor(math.log10(0.5*(abs(desired)+abs(actual))))))

with np.errstate(invalid='ignore'):

scale = 0.5 * (np.abs(desired) + np.abs(actual))

scale = np.power(10, np.floor(np.log10(scale)))

try:

sc_desired = desired / scale

except ZeroDivisionError:

sc_desired = 0.0

try:

sc_actual = actual / scale

except ZeroDivisionError:

sc_actual = 0.0

msg = build_err_msg(

[actual, desired], err_msg,

header='Items are not equal to %d significant digits:' % significant,

verbose=verbose)

try:

# If one of desired/actual is not finite, handle it specially here:

# check that both are nan if any is a nan, and test for equality

# otherwise

if not (isfinite(desired) and isfinite(actual)):

if isnan(desired) or isnan(actual):

if not (isnan(desired) and isnan(actual)):

raise AssertionError(msg)

elif not desired == actual:

raise AssertionError(msg)

return

except (TypeError, NotImplementedError):

pass

if np.abs(sc_desired - sc_actual) >= np.power(10., -(significant - 1)):

raise AssertionError(msg)

def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',

precision=6, equal_nan=True, equal_inf=True,

*, strict=False, names=('ACTUAL', 'DESIRED')):

__tracebackhide__ = True # Hide traceback for py.test

from numpy._core import all, array2string, errstate, inf, isnan, 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 isvstring(x):

return x.dtype.char == "T"

def robust_any_difference(x, y):

# We include work-arounds here to handle three types of slightly

# pathological ndarray subclasses:

# (1) all() on fully masked arrays returns np.ma.masked, so we use != True

# (np.ma.masked != True evaluates as np.ma.masked, which is falsy).

# (2) __eq__ on some ndarray subclasses returns Python booleans

# instead of element-wise comparisons, so we cast to np.bool() in

# that case (or in case __eq__ returns some other value with no

# all() method).

# (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 cases (2) and (3), but it's nice to

# support them if possible.

result = x == y

if not hasattr(result, "all") or not callable(result.all):

result = np.bool(result)

return result.all() != True

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)

if robust_any_difference(x_id, y_id):

msg = build_err_msg(

[x, y],

err_msg + '\n%s location mismatch:'

% (hasval), verbose=verbose, header=header,

names=names,

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.

# np.ma.masked is also handled and converted to np.False_ (even if the other

# array has nans/infs etc.; that's OK given the handling later of fully-masked

# results).

if isinstance(x_id, bool) or x_id.ndim == 0:

return np.bool(x_id)

elif isinstance(y_id, bool) or y_id.ndim == 0:

return np.bool(y_id)

else:

return y_id

def assert_same_inf_values(x, y, infs_mask):

"""

Verify all inf values match in the two arrays

"""

__tracebackhide__ = True # Hide traceback for py.test

if not infs_mask.any():

return

if x.ndim > 0 and y.ndim > 0:

x = x[infs_mask]

y = y[infs_mask]

else:

assert infs_mask.all()

if robust_any_difference(x, y):

msg = build_err_msg(

[x, y],

err_msg + '\ninf values mismatch:',

verbose=verbose, header=header,

names=names,

precision=precision)

raise AssertionError(msg)

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=names,

precision=precision)

raise AssertionError(msg)

flagged = np.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:

# If equal_nan=True, skip comparing nans below for equality if they are

# also infs (e.g. inf+nanj) since that would always fail.

isinf_func = lambda xy: np.logical_and(np.isinf(xy), np.invert(flagged))

infs_mask = func_assert_same_pos(

x, y,

func=isinf_func,

hasval='inf')

assert_same_inf_values(x, y, infs_mask)

flagged |= infs_mask

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")

elif isvstring(x) and isvstring(y):

dt = x.dtype

if equal_nan and dt == y.dtype and hasattr(dt, 'na_object'):

is_nan = (isinstance(dt.na_object, float) and

np.isnan(dt.na_object))

bool_errors = 0

try:

bool(dt.na_object)

except TypeError:

bool_errors = 1

if is_nan or bool_errors:

# nan-like NA object

flagged = func_assert_same_pos(

x, y, func=isnan, hasval=x.dtype.na_object)

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)

invalids = np.logical_not(val)

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 = [f'Mismatched elements: {n_mismatch} / {n_elements} '

f'({percent_mismatch:.3g}%)']

if invalids.ndim != 0:

if flagged.ndim > 0:

positions = np.argwhere(np.asarray(~flagged))[invalids]

else:

positions = np.argwhere(np.asarray(invalids))

s = "\n".join(

[

f" {p.tolist()}: {ox if ox.ndim == 0 else ox[tuple(p)]} "

f"({names[0]}), {oy if oy.ndim == 0 else oy[tuple(p)]} "

f"({names[1]})"

for p in positions[:5]

]

)

if len(positions) == 1:

remarks.append(

f"Mismatch at index:\n{s}"

)

elif len(positions) <= 5:

remarks.append(

f"Mismatch at indices:\n{s}"

)

else:

remarks.append(

f"First 5 mismatches are at indices:\n{s}"

)

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)

reduced_error = error[invalids]

max_abs_error = max(reduced_error)

if getattr(error, 'dtype', object_) == object_:

remarks.append(

'Max absolute difference among violations: '

+ str(max_abs_error))

else:

remarks.append(

'Max absolute difference among violations: '

+ 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 = np.bool(y != 0)

nonzero_and_invalid = np.logical_and(invalids, nonzero)

if all(~nonzero_and_invalid):

max_rel_error = array(inf)

else:

nonzero_invalid_error = error[nonzero_and_invalid]

broadcasted_y = np.broadcast_to(y, error.shape)

nonzero_invalid_y = broadcasted_y[nonzero_and_invalid]

max_rel_error = max(nonzero_invalid_error

/ abs(nonzero_invalid_y))

if getattr(error, 'dtype', object_) == object_:

remarks.append(

'Max relative difference among violations: '

+ str(max_rel_error))

else:

remarks.append(

'Max relative difference among violations: '

+ array2string(max_rel_error))

err_msg = str(err_msg)

err_msg += '\n' + '\n'.join(remarks)

msg = build_err_msg([ox, oy], err_msg,

verbose=verbose, header=header,

names=names,

precision=precision)

raise AssertionError(msg)

except ValueError:

import traceback

efmt = traceback.format_exc()

header = f'error during assertion:\n\n{efmt}\n\n{header}'

msg = build_err_msg([x, y], err_msg, verbose=verbose, header=header,

names=names, precision=precision)

raise ValueError(msg)

def assert_array_equal(actual, desired, err_msg='', verbose=True, *,

strict=False):

"""

Raises an AssertionError if two array_like objects are not equal.

Given two array_like objects, check that the shape is equal and all

elements of these objects are equal (but see the Notes for the special