# Python numpy.array_equiv() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 2

```def test_tri_sym_convert():
from brainiak.utils.utils import from_tri_2_sym, from_sym_2_tri
import numpy as np

sym = np.random.rand(3, 3)
tri = from_sym_2_tri(sym)
assert tri.shape[0] == 6,\
"from_sym_2_tri returned wrong result!"
sym1 = from_tri_2_sym(tri, 3)
assert sym1.shape[0] == sym1.shape[1],\
"from_tri_2_sym returned wrong shape!"
tri1 = from_sym_2_tri(sym1)
assert np.array_equiv(tri, tri1),\
"from_sym_2_tri returned wrong result!" ```

Example 3

```def test_times_1():
cntk_op = C.times([1, 2, 3], [[4], [5], [6]])
cntk_ret = cntk_op.eval()

ng_op, _ = CNTKImporter().import_model(cntk_op)
ng_ret = ng.transformers.make_transformer().computation(ng_op)()

assert np.array_equiv(cntk_ret, ng_ret) ```

Example 4

```def test_times_2():
cntk_op = C.times([[1, 2], [3, 4]], [[5, 6], [7, 8]])
cntk_ret = cntk_op.eval()

ng_op, _ = CNTKImporter().import_model(cntk_op)
ng_ret = ng.transformers.make_transformer().computation(ng_op)()

assert np.array_equiv(cntk_ret, ng_ret) ```

Example 5

```def test_times_3():
cntk_op = C.times([1, 2, 3], [[4, 5], [6, 7], [8, 9]])
cntk_ret = cntk_op.eval()

ng_op, _ = CNTKImporter().import_model(cntk_op)
ng_ret = ng.transformers.make_transformer().computation(ng_op)()

assert np.array_equiv(cntk_ret, ng_ret) ```

Example 6

```def test_times_4():
cntk_op = C.times([[1, 2, 3], [4, 5, 6]], [[7], [8], [9]])
cntk_ret = cntk_op.eval()

ng_op, _ = CNTKImporter().import_model(cntk_op)
ng_ret = ng.transformers.make_transformer().computation(ng_op)()

assert np.array_equiv(cntk_ret, ng_ret) ```

Example 7

```def test_times_5():
cntk_op = C.times([[1, 2, 3], [4, 5, 6]], [[7, 8], [9, 10], [11, 12]])
cntk_ret = cntk_op.eval()

ng_op, _ = CNTKImporter().import_model(cntk_op)
ng_ret = ng.transformers.make_transformer().computation(ng_op)()

assert np.array_equiv(cntk_ret, ng_ret) ```

Example 8

```def _process_sample_weight(self, interactions, sample_weight):

if sample_weight is not None:

if self.loss == 'warp-kos':
raise NotImplementedError('k-OS loss with sample weights '
'not implemented.')

if not isinstance(sample_weight, sp.coo_matrix):
raise ValueError('Sample_weight must be a COO matrix.')

if sample_weight.shape != interactions.shape:
raise ValueError('Sample weight and interactions '
'matrices must be the same shape')

if not (np.array_equal(interactions.row,
sample_weight.row) and
np.array_equal(interactions.col,
sample_weight.col)):
raise ValueError('Sample weight and interaction matrix '
'entries must be in the same order')

if sample_weight.data.dtype != CYTHON_DTYPE:
sample_weight_data = sample_weight.data.astype(CYTHON_DTYPE)
else:
sample_weight_data = sample_weight.data
else:
if np.array_equiv(interactions.data, 1.0):
# Re-use interactions data if they are all
# ones
sample_weight_data = interactions.data
else:
# Otherwise allocate a new array of ones
sample_weight_data = np.ones_like(interactions.data,
dtype=CYTHON_DTYPE)

return sample_weight_data ```

Example 9

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 10

```def test_init(self):
kf = KeyFrame(np.zeros((100, 100)), np.ones((2, 100)))
self.assertTrue(np.array_equiv(kf.image, np.zeros((100, 100))))
self.assertTrue(np.array_equiv(kf.features, np.ones((2, 100)))) ```

Example 11

```def test_serializzation(small_model):
with io.BytesIO() as fileobj:
pickle.dump(small_model, fileobj)
fileobj.seek(0)
assert all(str(loaded.wv.vocab[w]) == str(small_model.wv.vocab[w]) for w in small_model.wv.vocab)
assert all(str(loaded.lvocab[w]) == str(small_model.lvocab[w]) for w in small_model.lvocab)
assert numpy.array_equiv(loaded.wv.syn0, small_model.wv.syn0) ```

Example 12

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 13

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 14

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 15

```def equality(self):
equal = numpy.array_equiv(self.image_i, self.image_j)
self.assertTrue(equal) ```

Example 16

```def equality(self):
equal = numpy.array_equiv(self.image_i, self.image_j)
self.assertTrue(equal) ```

Example 17

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 18

```def array_equal(a1, a2):
"""
True if two arrays have the same shape and elements, False otherwise.

Parameters
----------
a1, a2 : array_like
Input arrays.

Returns
-------
b : bool
Returns True if the arrays are equal.

--------
allclose: Returns True if two arrays are element-wise equal within a
tolerance.
array_equiv: Returns True if input arrays are shape consistent and all
elements equal.

Examples
--------
>>> np.array_equal([1, 2], [1, 2])
True
>>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
True
>>> np.array_equal([1, 2], [1, 2, 3])
False
>>> np.array_equal([1, 2], [1, 4])
False

"""
try:
a1, a2 = asarray(a1), asarray(a2)
except:
return False
if a1.shape != a2.shape:
return False
return bool(asarray(a1 == a2).all()) ```

Example 19

```def arr_equiv():
ar1 = np.array([[1, 2], [3, 4]])
ar2 = np.array([[1, 2]])
ar3 = np.array([[1, 2], [1, 2]])
ar4 = np.array([1, 2])
print np.array_equiv(ar1, ar2)
# False
print np.array_equiv(ar1, ar4)
# False
print np.array_equiv(ar2, ar3)
# True ```

Example 20

```def test_array_equiv(self):
res = np.array_equiv(np.array([1, 2]), np.array([1, 2]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([3, 4]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([1, 3]))
assert_(not res)
assert_(type(res) is bool)

res = np.array_equiv(np.array([1, 1]), np.array([1]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]]))
assert_(res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([2]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]]))
assert_(not res)
assert_(type(res) is bool)
res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
assert_(not res)
assert_(type(res) is bool) ```

Example 21

```def preprocess(self, **kwargs):
"""Construct kernel distance arrays."""
new_times = np.array(kwargs.get('all_times', []), dtype=float)
self._codeltatime = kwargs.get(self.key('codeltatime'), -1)
self._codeltalambda = kwargs.get(self.key('codeltalambda'), -1)
if np.array_equiv(new_times, self._times) and self._preprocessed:
return
self._times = new_times
self._all_band_indices = kwargs.get('all_band_indices', [])
self._are_bands = np.array(self._all_band_indices) >= 0
self._freqs = kwargs.get('all_frequencies', [])
self._u_freqs = kwargs.get('all_u_frequencies', [])
self._waves = np.array([
self._average_wavelengths[bi] if bi >= 0 else
C_CGS / self._freqs[i] / ANG_CGS for i, bi in
enumerate(self._all_band_indices)])
self._observed = np.array(kwargs.get('observed', []), dtype=bool)
self._n_obs = len(self._observed)

self._o_times = self._times[self._observed]
self._o_waves = self._waves[self._observed]

if self._type == 'full':
self._times_1 = self._times
self._times_2 = self._times
self._waves_1 = self._waves
self._waves_2 = self._waves
elif self._type == 'oa':
self._times_1 = self._o_times
self._times_2 = self._times
self._waves_1 = self._o_waves
self._waves_2 = self._waves
elif self._type == 'ao':
self._times_1 = self._times
self._times_2 = self._o_times
self._waves_1 = self._waves
self._waves_2 = self._o_waves
else:
self._times_1 = self._o_times
self._times_2 = self._o_times
self._waves_1 = self._o_waves
self._waves_2 = self._o_waves

# Time deltas (radial distance) for covariance matrix.
if self._codeltatime >= 0:
self._dt2mat = self._times_1[:, None] - self._times_2[None, :]
self._dt2mat **= 2
self._dt2mat *= -0.5

# Wavelength deltas (radial distance) for covariance matrix.
if self._codeltalambda >= 0:
self._dl2mat = self._waves_1[:, None] - self._waves_2[None, :]
self._dl2mat **= 2
self._dl2mat *= -0.5

self._preprocessed = True ```

Example 22

```def array_equiv(a1, a2):
"""
Returns True if input arrays are shape consistent and all elements equal.

Shape consistent means they are either the same shape, or one input array
can be broadcasted to create the same shape as the other one.

Parameters
----------
a1, a2 : array_like
Input arrays.

Returns
-------
out : bool
True if equivalent, False otherwise.

Examples
--------
>>> np.array_equiv([1, 2], [1, 2])
True
>>> np.array_equiv([1, 2], [1, 3])
False

Showing the shape equivalence:

>>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
True
>>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
False

>>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
False

"""
try:
a1, a2 = asarray(a1), asarray(a2)
except:
return False
try:
except:
return False

return bool(asarray(a1 == a2).all()) ```

Example 23

```def parse_array(self, ar):
"""
Consolidate an array to something smaller and remains
broadcastable to the original dimensions. ndim remains the same.

todo:
- if squeezable in multiple dimensions, squeeze in all dimensions.
it currently does this, but the entire most_squeezable_dim can be
left out.
:param ar: array to be parsed
:return: consolidated array
"""
assert isinstance(ar, np.ndarray)

output = np.unique(ar)

if output.size == 1:
return 0, output.item()

elif output.size == 0:
return -1, output

else:
items_per_squeezed_dim = ar.ndim * [0]

for dim in range(ar.ndim):
output, index = uniquend(ar, axis=dim, return_index=True)

if len(index) == 1:
items_per_squeezed_dim[dim] = output.size

else:
items_per_squeezed_dim[dim] = ar.size

most_squeezable_dim = items_per_squeezed_dim.index(
min(items_per_squeezed_dim))

if ar.size == items_per_squeezed_dim[most_squeezable_dim]:
return -1, ar

else:
# can be squeezable in multiple dimensions
# therefore call self
cur = uniquend(ar, axis=most_squeezable_dim)

# test if broadcastable shape, same elements values
assert np.array_equiv(ar, cur)

return 1, self.parse_array(cur)[1] ```