我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.may_share_memory()。
def check_may_share_memory_exact(a, b): got = np.may_share_memory(a, b, max_work=MAY_SHARE_EXACT) assert_equal(np.may_share_memory(a, b), np.may_share_memory(a, b, max_work=MAY_SHARE_BOUNDS)) a.fill(0) b.fill(0) a.fill(1) exact = b.any() err_msg = "" if got != exact: err_msg = " " + "\n ".join([ "base_a - base_b = %r" % (a.__array_interface__['data'][0] - b.__array_interface__['data'][0],), "shape_a = %r" % (a.shape,), "shape_b = %r" % (b.shape,), "strides_a = %r" % (a.strides,), "strides_b = %r" % (b.strides,), "size_a = %r" % (a.size,), "size_b = %r" % (b.size,) ]) assert_equal(got, exact, err_msg=err_msg)
def test_creation_maskcreation(self): # Tests how masks are initialized at the creation of Maskedarrays. data = arange(24, dtype=float) data[[3, 6, 15]] = masked dma_1 = MaskedArray(data) assert_equal(dma_1.mask, data.mask) dma_2 = MaskedArray(dma_1) assert_equal(dma_2.mask, dma_1.mask) dma_3 = MaskedArray(dma_1, mask=[1, 0, 0, 0] * 6) fail_if_equal(dma_3.mask, dma_1.mask) x = array([1, 2, 3], mask=True) assert_equal(x._mask, [True, True, True]) x = array([1, 2, 3], mask=False) assert_equal(x._mask, [False, False, False]) y = array([1, 2, 3], mask=x._mask, copy=False) assert_(np.may_share_memory(x.mask, y.mask)) y = array([1, 2, 3], mask=x._mask, copy=True) assert_(not np.may_share_memory(x.mask, y.mask))
def test_empty(self): # Tests empty/like datatype = [('a', int), ('b', float), ('c', '|S8')] a = masked_array([(1, 1.1, '1.1'), (2, 2.2, '2.2'), (3, 3.3, '3.3')], dtype=datatype) assert_equal(len(a.fill_value.item()), len(datatype)) b = empty_like(a) assert_equal(b.shape, a.shape) assert_equal(b.fill_value, a.fill_value) b = empty(len(a), dtype=datatype) assert_equal(b.shape, a.shape) assert_equal(b.fill_value, a.fill_value) # check empty_like mask handling a = masked_array([1, 2, 3], mask=[False, True, False]) b = empty_like(a) assert_(not np.may_share_memory(a.mask, b.mask)) b = a.view(masked_array) assert_(np.may_share_memory(a.mask, b.mask))
def may_share_memory(a, b): # This is Fred suggestion for a quick and dirty way of checking # aliasing .. this can potentially be further refined (ticket #374) if _is_sparse(a) and _is_sparse(b): return (SparseType.may_share_memory(a, b.data) or SparseType.may_share_memory(a, b.indices) or SparseType.may_share_memory(a, b.indptr)) if _is_sparse(b) and isinstance(a, numpy.ndarray): a, b = b, a if _is_sparse(a) and isinstance(b, numpy.ndarray): if (numpy.may_share_memory(a.data, b) or numpy.may_share_memory(a.indices, b) or numpy.may_share_memory(a.indptr, b)): # currently we can't share memory with a.shape as it is a tuple return True return False
def test_no_aliasing_2(self): # B and A take one another's values # no copying is necessary since each one is updated. orig_a = numpy.zeros((2, 2)) + .5 orig_b = numpy.zeros((2, 2)) - .5 A = self.shared(orig_a) B = self.shared(orig_b) data_of_a = data_of(A) data_of_b = data_of(B) f = pfunc([], [], updates=[(A, B), (B, A)]) f() # correctness assert numpy.all(data_of(A) == -.5) assert numpy.all(data_of(B) == +.5) # shared vars may not be aliased assert not numpy.may_share_memory(data_of(A), data_of(B)) # theano should have been smart enough to not make copies assert numpy.may_share_memory(data_of(A), data_of_b) assert numpy.may_share_memory(data_of(B), data_of_a)
def test_memory_aliasing_updates(self): x = theano.shared(numpy.array(1)) y = theano.shared(numpy.array(1)) out, updates = theano.scan( lambda: OrderedDict([(x, x + 1), (y, x)]), outputs_info=[], non_sequences=[], sequences=[], n_steps=10) f = theano.function([], [], updates=updates) f() assert not numpy.may_share_memory(x.container.storage[0], y.container.storage[0]) assert x.get_value() != y.get_value()
def test_astype_copy_memory(): a_int32 = np.ones(3, np.int32) # Check that dtype conversion works b_float32 = astype(a_int32, dtype=np.float32, copy=False) assert_equal(b_float32.dtype, np.float32) # Changing dtype forces a copy even if copy=False assert_false(np.may_share_memory(b_float32, a_int32)) # Check that copy can be skipped if requested dtype match c_int32 = astype(a_int32, dtype=np.int32, copy=False) assert_true(c_int32 is a_int32) # Check that copy can be forced, and is the case by default: d_int32 = astype(a_int32, dtype=np.int32, copy=True) assert_false(np.may_share_memory(d_int32, a_int32)) e_int32 = astype(a_int32, dtype=np.int32) assert_false(np.may_share_memory(e_int32, a_int32))
def test_scalar_array_bool(self): # Numpy bools can be used as boolean index (python ones as of yet not) a = np.array(1) assert_equal(a[np.bool_(True)], a[np.array(True)]) assert_equal(a[np.bool_(False)], a[np.array(False)]) # After deprecating bools as integers: #a = np.array([0,1,2]) #assert_equal(a[True, :], a[None, :]) #assert_equal(a[:, True], a[:, None]) # #assert_(not np.may_share_memory(a, a[True, :]))
def _compare_index_result(self, arr, index, mimic_get, no_copy): """Compare mimicked result to indexing result. """ arr = arr.copy() indexed_arr = arr[index] assert_array_equal(indexed_arr, mimic_get) # Check if we got a view, unless its a 0-sized or 0-d array. # (then its not a view, and that does not matter) if indexed_arr.size != 0 and indexed_arr.ndim != 0: assert_(np.may_share_memory(indexed_arr, arr) == no_copy) # Check reference count of the original array if no_copy: # refcount increases by one: assert_equal(sys.getrefcount(arr), 3) else: assert_equal(sys.getrefcount(arr), 2) # Test non-broadcast setitem: b = arr.copy() b[index] = mimic_get + 1000 if b.size == 0: return # nothing to compare here... if no_copy and indexed_arr.ndim != 0: # change indexed_arr in-place to manipulate original: indexed_arr += 1000 assert_array_equal(arr, b) return # Use the fact that the array is originally an arange: arr.flat[indexed_arr.ravel()] += 1000 assert_array_equal(arr, b)
def __array_finalize__(self, obj): if hasattr(obj, '_mmap') and np.may_share_memory(self, obj): self._mmap = obj._mmap self.filename = obj.filename self.offset = obj.offset self.mode = obj.mode else: self._mmap = None self.filename = None self.offset = None self.mode = None
def test_basic(self): d = np.ones((50, 60)) d2 = np.ones((30, 60, 6)) self.assertTrue(np.may_share_memory(d, d)) self.assertTrue(np.may_share_memory(d, d[::-1])) self.assertTrue(np.may_share_memory(d, d[::2])) self.assertTrue(np.may_share_memory(d, d[1:, ::-1])) self.assertFalse(np.may_share_memory(d[::-1], d2)) self.assertFalse(np.may_share_memory(d[::2], d2)) self.assertFalse(np.may_share_memory(d[1:, ::-1], d2)) self.assertTrue(np.may_share_memory(d2[1:, ::-1], d2)) # Utility
def test_array_memory_sharing(self): assert_(np.may_share_memory(self.a, self.a.ravel())) assert_(not np.may_share_memory(self.a, self.a.flatten()))
def test_unit_scaling(self): a = np.random.rand(1) self.assertRaises(ValueError, segment.unit_scaling, a, 2) size = (3, 2) a = np.random.rand(*size) rst = segment.unit_scaling(a, 2) self.assertEqual(size, rst.shape) b = np.random.rand(size[1]) self.assertRaises(ValueError, segment.unit_scaling, a, 2, b) b = np.random.rand(size[0]) rst = segment.unit_scaling(a, 2, b) self.assertTrue(np.may_share_memory(a, rst)) rst = segment.unit_scaling(a, 2, b, True) self.assertFalse(np.may_share_memory(a, rst))
def get_full_sequence(self, repeats=1): """Get the full MLS sequence as audio samples, repeated n times. When extracting the impulse response we need to throw away the first MLS sequence. Hence we need to repeat the signal at least once, i.e repeat=2. More repetitions will mean longer signal but better signal to noise ratio since we will average away any noise. """ chunkgen = self.generator_samples(chunk=self.L) full_sequence = chunkgen.next() reps_sequence = np.tile(full_sequence.T, repeats).T self._logger.debug("May share memory: %s" %np.may_share_memory(full_sequence, reps_sequence)) return reps_sequence
def test_reindex(self): identity = self.series.reindex(self.series.index) # __array_interface__ is not defined for older numpies # and on some pythons try: self.assertTrue(np.may_share_memory(self.series.index, identity.index)) except (AttributeError): pass self.assertTrue(identity.index.is_(self.series.index)) self.assertTrue(identity.index.identical(self.series.index)) subIndex = self.series.index[10:20] subSeries = self.series.reindex(subIndex) for idx, val in compat.iteritems(subSeries): self.assertEqual(val, self.series[idx]) subIndex2 = self.ts.index[10:20] subTS = self.ts.reindex(subIndex2) for idx, val in compat.iteritems(subTS): self.assertEqual(val, self.ts[idx]) stuffSeries = self.ts.reindex(subIndex) self.assertTrue(np.isnan(stuffSeries).all()) # This is extremely important for the Cython code to not screw up nonContigIndex = self.ts.index[::2] subNonContig = self.ts.reindex(nonContigIndex) for idx, val in compat.iteritems(subNonContig): self.assertEqual(val, self.ts[idx]) # return a copy the same index here result = self.ts.reindex() self.assertFalse((result is self.ts))
def test_matrix_memory_sharing(self): assert_(np.may_share_memory(self.m, self.m.ravel())) assert_(not np.may_share_memory(self.m, self.m.flatten()))
def test_scalar_array_bool(self): # NumPy bools can be used as boolean index (python ones as of yet not) a = np.array(1) assert_equal(a[np.bool_(True)], a[np.array(True)]) assert_equal(a[np.bool_(False)], a[np.array(False)]) # After deprecating bools as integers: #a = np.array([0,1,2]) #assert_equal(a[True, :], a[None, :]) #assert_equal(a[:, True], a[:, None]) # #assert_(not np.may_share_memory(a, a[True, :]))
