def assert_array_greater(x, y, err_msg='', verbose=True):
assert_array_compare(operator.__gt__,
x,
y,
err_msg=err_msg,
verbose=verbose,
header='Arrays are not greater-ordered')
def assert_allclose(actual, desired, rtol=1e-7, atol=0,
err_msg='', verbose=True):
from numpy.testing.utils import assert_array_compare
def compare(x, y):
return np.allclose(x, y, rtol=rtol, atol=atol)
actual, desired = np.asanyarray(actual), np.asanyarray(desired)
header = 'Not equal to tolerance rtol=%g, atol=%g' % (rtol, atol)
assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
verbose=verbose, header=header)
def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
from numpy.core import around, number, float_
from numpy.lib import issubdtype
from numpy.testing.utils import assert_array_compare
def compare(x, y):
z = abs(x-y)
if not issubdtype(z.dtype, number):
z = z.astype(float_) # handle object arrays
return around(z, decimal) <= 10.0**(-decimal)
assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
header='Arrays are not almost equal')
def assert_array_less_equal(x, y, err_msg="", verbose=True):
"""Assert array x <= y. Based on numpy.testing.assert_array_less."""
assert_array_compare(
operator.le,
x,
y,
err_msg=err_msg,
verbose=verbose,
header="Arrays are not less-ordered",
equal_inf=False,
)
def assert_array_compare(comparison,
x,
y,
err_msg='',
verbose=True,
header='',
fill_value=True):
"""Asserts that a comparison relation between two masked arrays is satisfied
elementwise."""
# Fill the data first
# xf = filled(x)
# yf = filled(y)
# Allocate a common mask and refill
m = mask_or(getmask(x), getmask(y))
x = masked_array(x, copy=False, mask=m, keep_mask=False, subok=False)
y = masked_array(y, copy=False, mask=m, keep_mask=False, subok=False)
if ((x is masked) and not (y is masked)) or \
((y is masked) and not (x is masked)):
msg = build_err_msg([x, y],
err_msg=err_msg,
verbose=verbose,
header=header,
names=('x', 'y'))
raise ValueError(msg)
# OK, now run the basic tests on filled versions
return utils.assert_array_compare(comparison,
x.filled(fill_value),
y.filled(fill_value),
err_msg=err_msg,
verbose=verbose,
header=header)
def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
from numpy.core import around, number, float_
from numpy.lib import issubdtype
from numpy.testing.utils import assert_array_compare
def compare(x, y):
z = abs(x - y)
if not issubdtype(z.dtype, number):
z = z.astype(float_) # handle object arrays
return around(z, decimal) <= 10.0**(-decimal)
assert_array_compare(compare,
x,
y,
err_msg=err_msg,
verbose=verbose,
header='Arrays are not almost equal')
def assert_allclose(actual,
desired,
rtol=1e-7,
atol=0,
err_msg='',
verbose=True):
from numpy.testing.utils import assert_array_compare
def compare(x, y):
return np.allclose(x, y, rtol=rtol, atol=atol)
actual, desired = np.asanyarray(actual), np.asanyarray(desired)
header = 'Not equal to tolerance rtol=%g, atol=%g' % (rtol, atol)
assert_array_compare(compare,
actual,
desired,
err_msg=str(err_msg),
verbose=verbose,
header=header)
def assert_array_not_equal(x, y, err_msg='', verbose=True):
"""
Raises an AssertionError if two array_like objects are equal.
Given two array_like objects, check that the shape is equal and all
elements of these objects are not equal. 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 (ToDo: Check 2 NaNs).
The usual caution for verifying equality with floating point numbers is
advised.
Parameters
----------
x : array_like
The actual object to check.
y : array_like
The desired, 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.
Raises
------
AssertionError
If actual and desired objects are equal.
See Also
--------
assert_array_equal
"""
assert_array_compare(operator.__ne__,
x,
y,
err_msg=err_msg,
verbose=verbose,
header='Arrays are equal')
def assert_array_compare(comparison, x, y, err_msg="", verbose=True, header="", fill_value=True):
"""Asserts that a comparison relation between two masked arrays is satisfied
elementwise."""
# Fill the data first
# xf = filled(x)
# yf = filled(y)
# Allocate a common mask and refill
m = mask_or(getmask(x), getmask(y))
x = masked_array(x, copy=False, mask=m, keep_mask=False, subok=False)
y = masked_array(y, copy=False, mask=m, keep_mask=False, subok=False)
if ((x is masked) and not (y is masked)) or ((y is masked) and not (x is masked)):
msg = build_err_msg([x, y], err_msg=err_msg, verbose=verbose, header=header, names=("x", "y"))
raise ValueError(msg)
# OK, now run the basic tests on filled versions
return utils.assert_array_compare(
comparison, x.filled(fill_value), y.filled(fill_value), err_msg=err_msg, verbose=verbose, header=header
)
def test_IO(self):
""" Tests basic coupling"""
# first on the zeros initialized clements mesh
input_values = normalize_vec(npr.random((self.N, 1)))
self.mesh_c_z.input_couple(input_values)
output_values = self.mesh_c_z.output_values
# because the matrix was initialized with zeros, output should be identical to input
np.testing.assert_array_almost_equal(input_values, output_values)
# same goes for the partial values within MZI
for partial_value in self.mesh_c_z.partial_values:
np.testing.assert_array_almost_equal(input_values, partial_value)
# then on the random initialized clements mesh
input_values = npr.random((self.N, ))
self.mesh_c_r.input_couple(input_values)
output_values = self.mesh_c_r.output_values
# should not be equal for random initialization
assert_array_compare(operator.__ne__, input_values, output_values)
# same goes for the partial values within MZI
for partial_value in self.mesh_c_r.partial_values:
assert_array_compare(operator.__ne__, input_values, output_values)
# finally on the random initialized triangular mesh
input_values = normalize_vec(npr.random((self.N, 1)))
self.mesh_t.input_couple(input_values)
output_values = self.mesh_t.output_values
# should not be equal for random initialization
assert_array_compare(operator.__ne__, input_values, output_values)
# same goes for the partial values within MZI
for partial_value in self.mesh_t.partial_values:
assert_array_compare(operator.__ne__, input_values, output_values)
