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) C = tensor.dmatrix() z = numpy.zeros((2,2)) data_of_a = data_of(A) data_of_b = data_of(B) f = pfunc([C], [], updates=[(A,B),(B,A)]) f(z) # 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_nodes_at_link(): """Test nodes_at_link shares data with tail and head.""" assert_array_equal(rmg.nodes_at_link[:, 0], rmg.node_at_link_tail) assert_array_equal(rmg.nodes_at_link[:, 1], rmg.node_at_link_head) assert_true(np.may_share_memory(rmg.nodes_at_link, rmg.node_at_link_tail)) assert_true(np.may_share_memory(rmg.nodes_at_link, rmg.node_at_link_head))
def test_transpose(self): s0_transpose = self.s0.transpose() s0_diff = s0_transpose.differentials['s'] assert s0_transpose.shape == (7, 6) assert s0_diff.shape == s0_transpose.shape assert np.all(s0_transpose.lon == self.s0.lon.transpose()) assert np.all(s0_diff.d_lon == self.diff.d_lon.transpose()) assert np.may_share_memory(s0_transpose.distance, self.s0.distance) assert np.may_share_memory(s0_diff.d_lon, self.diff.d_lon) s1_transpose = self.s1.transpose() s1_diff = s1_transpose.differentials['s'] assert s1_transpose.shape == (7, 6) assert s1_diff.shape == s1_transpose.shape assert np.all(s1_transpose.lat == self.s1.lat.transpose()) assert np.all(s1_diff.d_lon == self.diff.d_lon.transpose()) assert np.may_share_memory(s1_transpose.lat, self.s1.lat) assert np.may_share_memory(s1_diff.d_lon, self.diff.d_lon) # Only one check on T, since it just calls transpose anyway. # Doing it on the CartesianRepresentation just for variety's sake. c0_T = self.c0.T assert c0_T.shape == (7, 6) assert np.all(c0_T.x == self.c0.x.T) assert np.may_share_memory(c0_T.y, self.c0.y)
def check_may_share_memory_easy_fuzz(get_max_work, same_steps, min_count): # Check that overlap problems with common strides are solved with # little work. x = np.zeros([17,34,71,97], dtype=np.int16) feasible = 0 infeasible = 0 pair_iter = iter_random_view_pairs(x, same_steps) while min(feasible, infeasible) < min_count: a, b = next(pair_iter) bounds_overlap = np.may_share_memory(a, b) may_share_answer = np.may_share_memory(a, b) easy_answer = np.may_share_memory(a, b, max_work=get_max_work(a, b)) exact_answer = np.may_share_memory(a, b, max_work=MAY_SHARE_EXACT) if easy_answer != exact_answer: # assert_equal is slow... assert_equal(easy_answer, exact_answer) if may_share_answer != bounds_overlap: assert_equal(may_share_answer, bounds_overlap) if bounds_overlap: if exact_answer: feasible += 1 else: infeasible += 1
def test_non_ndarray_inputs(): # Regression check for gh-5604 class MyArray(object): def __init__(self, data): self.data = data @property def __array_interface__(self): return self.data.__array_interface__ class MyArray2(object): def __init__(self, data): self.data = data def __array__(self): return self.data for cls in [MyArray, MyArray2]: x = np.arange(5) assert_(np.may_share_memory(cls(x[::2]), x[1::2])) assert_(not np.shares_memory(cls(x[::2]), x[1::2])) assert_(np.shares_memory(cls(x[1::3]), x[::2])) assert_(np.may_share_memory(cls(x[1::3]), x[::2]))
def test_dot_mm_partial(self, its=50): for it in range(its): size = random.choice([0, 1, randint(0, 10), randint(0, 100)]) a_bm = gen_BandMat(size) b_bm = gen_BandMat(size) l = random.choice([0, 1, randint(0, 10)]) u = random.choice([0, 1, randint(0, 10)]) diag = None if rand_bool() else randn(size) diag_value = np.ones((size,)) if diag is None else diag a_full = a_bm.full() b_full = b_bm.full() c_bm = bm.dot_mm_partial(l, u, a_bm, b_bm, diag=diag) c_full = fl.band_ec( l, u, np.dot(np.dot(a_full, np.diag(diag_value)), b_full) ) assert c_bm.l == l assert c_bm.u == u assert c_bm.size == size assert_allclose(c_bm.full(), c_full) assert not np.may_share_memory(c_bm.data, a_bm.data) assert not np.may_share_memory(c_bm.data, b_bm.data) if diag is not None: assert not np.may_share_memory(c_bm.data, diag)
def test_BandMat_sub(self, its=100): for it in range(its): size = random.choice([0, 1, randint(0, 10), randint(0, 100)]) a_bm = gen_BandMat(size) b_bm = gen_BandMat(size) a_full = a_bm.full() b_full = b_bm.full() c_bm = a_bm - b_bm c_full = a_full - b_full assert_allclose(c_bm.full(), c_full) assert not np.may_share_memory(c_bm.data, a_bm.data) assert not np.may_share_memory(c_bm.data, b_bm.data) c_bm = a_bm - 0 c_full = a_full - 0 assert_allclose(c_bm.full(), c_full) assert not np.may_share_memory(c_bm.data, a_bm.data) c_bm = 0 - a_bm c_full = 0 - a_full assert_allclose(c_bm.full(), c_full) assert not np.may_share_memory(c_bm.data, a_bm.data) with self.assertRaises(TypeError): a_bm - 1.0 with self.assertRaises(TypeError): 1.0 - a_bm
def test_no_copy(): c1 = SkyCoord(np.arange(10.) * u.hourangle, np.arange(20., 30.) * u.deg) c2 = SkyCoord(c1, copy=False) # Note: c1.ra and c2.ra will *not* share memory, as these are recalculated # to be in "preferred" units. See discussion in #4883. assert np.may_share_memory(c1.data.lon, c2.data.lon) c3 = SkyCoord(c1, copy=True) assert not np.may_share_memory(c1.data.lon, c3.data.lon)
def test_nodes_at_link(): """Test nodes_at_link shares data with tail and head.""" rmg = RasterModelGrid((4, 5), spacing=1.) assert_array_equal(rmg.nodes_at_link[:, 0], rmg.node_at_link_tail) assert_array_equal(rmg.nodes_at_link[:, 1], rmg.node_at_link_head) assert np.may_share_memory(rmg.nodes_at_link, rmg.node_at_link_tail) assert np.may_share_memory(rmg.nodes_at_link, rmg.node_at_link_head)
def test__solve_triangular_banded(self, its=100): for it in range(its): size = random.choice([0, 1, randint(0, 10), randint(0, 100)]) b = randn(size) chol_bm = gen_chol_factor_BandMat(size, transposed=False) chol_data = chol_bm.data depth = chol_bm.l + chol_bm.u lower = (chol_bm.u == 0) if size > 0 and rand_bool() and rand_bool(): badFrame = randint(size) chol_data[0 if lower else depth, badFrame] = 0.0 else: badFrame = None transposed = rand_bool() overwrite_b = rand_bool() chol_full = chol_bm.full() b_arg = b.copy() if badFrame is not None: msg = ( 'singular matrix: resolution failed at diagonal %d' % badFrame ) msgRe = '^' + re.escape(msg) + '$' with self.assertRaisesRegexp(la.LinAlgError, msgRe): bla._solve_triangular_banded( chol_data, b_arg, transposed=transposed, lower=lower, overwrite_b=overwrite_b ) with self.assertRaisesRegexp(la.LinAlgError, msgRe): sla.solve_triangular( chol_full, b, trans=transposed, lower=lower ) else: x = bla._solve_triangular_banded( chol_data, b_arg, transposed=transposed, lower=lower, overwrite_b=overwrite_b ) if transposed: assert_allclose(bm.dot_mv(chol_bm.T, x), b) else: assert_allclose(bm.dot_mv(chol_bm, x), b) if size == 0: x_good = np.zeros((size,)) else: x_good = sla.solve_triangular( chol_full, b, trans=transposed, lower=lower ) assert_allclose(x, x_good) assert not np.may_share_memory(x, chol_data) if size > 0: self.assertEquals( np.may_share_memory(x, b_arg), overwrite_b ) if not overwrite_b: assert np.all(b_arg == b)
def test_game_function(players, strategies): game = gamegen.role_symmetric_game(players, strategies) # Test copy game2 = rsgame.Game(game) assert not np.may_share_memory(game.profiles, game2.profiles) assert not np.may_share_memory(game.payoffs, game2.payoffs) assert np.all(game.profiles == game2.profiles) assert np.all(game.payoffs == game2.payoffs) game3 = rsgame.Game(rsgame.BaseGame(game)) assert game3.is_empty() mask = game.profiles > 0 # Check that min payoffs are actually minimum min_payoffs = game.role_repeat(game.min_payoffs()) assert np.all((game.payoffs >= min_payoffs)[mask]), \ "not all payoffs less than min payoffs" max_payoffs = game.role_repeat(game.max_payoffs()) assert np.all((game.payoffs <= max_payoffs)[mask]), \ "not all payoffs greater than max payoffs" # Test profile methods for prof in game.profiles: game.get_payoffs(prof) # Works assert prof in game, "profile from game not in game" # Test expected payoff mix = game.random_mixtures()[0] dev1 = game.deviation_payoffs(mix) dev2, dev_jac = game.deviation_payoffs(mix, jacobian=True) assert not np.isnan(dev1).any() assert not np.isnan(dev_jac).any() assert np.allclose(dev1, dev2) pay1 = game.get_expected_payoffs(mix) pay2 = game.get_expected_payoffs(mix, deviations=dev1) pay3, jac1 = game.get_expected_payoffs(mix, jacobian=True) pay4, jac2 = game.get_expected_payoffs( mix, deviations=(dev1, dev_jac), jacobian=True) assert not np.isnan(pay1).any() assert (np.allclose(pay1, pay2) and np.allclose(pay1, pay3) and np.allclose(pay1, pay4)) assert not np.isnan(jac1).any() assert np.allclose(jac1, jac2) # Max social welfare welfare, profile = game.get_max_social_welfare() assert not np.isnan(welfare) assert profile is not None for welfare, profile in zip(*game.get_max_social_welfare(True)): assert not np.isnan(welfare) assert profile is not None # Test that various methods can be called assert repr(game) is not None
def check_may_share_memory_easy_fuzz(get_max_work, same_steps, min_count): # Check that overlap problems with common strides are solved with # little work. x = np.zeros([17,34,71,97], dtype=np.int16) rng = np.random.RandomState(1234) def random_slice(n, step): start = rng.randint(0, n+1, dtype=np.intp) stop = rng.randint(start, n+1, dtype=np.intp) if rng.randint(0, 2, dtype=np.intp) == 0: stop, start = start, stop step *= -1 return slice(start, stop, step) feasible = 0 infeasible = 0 while min(feasible, infeasible) < min_count: steps = tuple(rng.randint(1, 11, dtype=np.intp) if rng.randint(0, 5, dtype=np.intp) == 0 else 1 for j in range(x.ndim)) if same_steps: steps2 = steps else: steps2 = tuple(rng.randint(1, 11, dtype=np.intp) if rng.randint(0, 5, dtype=np.intp) == 0 else 1 for j in range(x.ndim)) t1 = np.arange(x.ndim) rng.shuffle(t1) t2 = np.arange(x.ndim) rng.shuffle(t2) s1 = tuple(random_slice(p, s) for p, s in zip(x.shape, steps)) s2 = tuple(random_slice(p, s) for p, s in zip(x.shape, steps2)) a = x[s1].transpose(t1) b = x[s2].transpose(t2) bounds_overlap = np.may_share_memory(a, b) may_share_answer = np.may_share_memory(a, b) easy_answer = np.may_share_memory(a, b, max_work=get_max_work(a, b)) exact_answer = np.may_share_memory(a, b, max_work=MAY_SHARE_EXACT) if easy_answer != exact_answer: # assert_equal is slow... assert_equal(easy_answer, exact_answer, err_msg=repr((s1, s2))) if may_share_answer != bounds_overlap: assert_equal(may_share_answer, bounds_overlap, err_msg=repr((s1, s2))) if bounds_overlap: if exact_answer: feasible += 1 else: infeasible += 1
def assertTableEqual(self, a, b, copy=None): assert a.colnames == b.colnames nptest.assert_array_equal(a.as_array(), b.as_array()) assert a.meta == b.meta for col, col2 in zip(a.columns.values(), b.columns.values()): if copy: assert not may_share_memory(col, col2) elif copy is False: assert may_share_memory(col, col2)
def test_nodes_at_link(): """Test nodes_at_link shares data with tail and head.""" grid = HexModelGrid(3, 2) assert_array_equal(grid.nodes_at_link[:, 0], grid.node_at_link_tail) assert_array_equal(grid.nodes_at_link[:, 1], grid.node_at_link_head) assert np.may_share_memory(grid.nodes_at_link, grid.node_at_link_tail) assert np.may_share_memory(grid.nodes_at_link, grid.node_at_link_head)
def test_diagonal(self): s0_diagonal = self.s0.diagonal() s0_diff = s0_diagonal.differentials['s'] assert s0_diagonal.shape == (6,) assert s0_diff.shape == s0_diagonal.shape assert np.all(s0_diagonal.lat == self.s0.lat.diagonal()) assert np.all(s0_diff.d_lon == self.diff.d_lon.diagonal()) assert np.may_share_memory(s0_diagonal.lat, self.s0.lat) assert np.may_share_memory(s0_diff.d_lon, self.diff.d_lon)
def test_swapaxes(self): s1_swapaxes = self.s1.swapaxes(0, 1) s1_diff = s1_swapaxes.differentials['s'] assert s1_swapaxes.shape == (7, 6) assert s1_diff.shape == s1_swapaxes.shape assert np.all(s1_swapaxes.lat == self.s1.lat.swapaxes(0, 1)) assert np.all(s1_diff.d_lon == self.diff.d_lon.swapaxes(0, 1)) assert np.may_share_memory(s1_swapaxes.lat, self.s1.lat) assert np.may_share_memory(s1_diff.d_lon, self.diff.d_lon)
def _assert_copies(t, t2, deep=True): assert t.colnames == t2.colnames np.testing.assert_array_equal(t._data, t2._data) assert t.meta == t2.meta if deep: assert not np.may_share_memory(t._data, t2._data) else: assert np.may_share_memory(t._data, t2._data)
def test_shared_constructor_copies(self): # shared constructor makes copy # (rule #2) orig_a = numpy.zeros((2,2)) A = self.shared(orig_a) assert not numpy.may_share_memory(orig_a, data_of(A)) # rule #2 reading back from theano-managed memory assert not numpy.may_share_memory(A.get_value(borrow=False), data_of(A))
def trim_and_avgerage(self, other): """It is assumed that at least two full MLSes are used and sent through the system we want to measure. By using m repeated sequences of MLSes we can throw away the first full sequence. This first part might be delayed because of latency and will contain the startup response of the system which we aren't interested in. We then have n=m-1 sequences. Remember that MLS is a repeated sequence and it doesn't matter that we have for example latency of for example one third of a sequence. This will show up as phase shift which can be compensated for. We now calculate the average of the n sequences. This gives us even more noise resistance. Returns a numpy array of length L. """ # data is [[A_1], # [A_2], # [A_3], # [B_1], # [B_2], # [B_3], # [C_1], # [C_2], # [C_3]] # throw away first full sequence trimmed = other[self.L:] self._logger.debug("May share memory: %s" %np.may_share_memory(other, trimmed)) #print(repr(trimmed)) # data is [[B_1], # [B_2], # [B_3], # [C_1], # [C_2], # [C_3]] repeats = len(trimmed)//self.L self._logger.debug("repeats (first discared): %i" %repeats) # reshape so we can average reshaped = trimmed.reshape((repeats, self.L)) # data is [[B_1, B_2, B_3], # [C_1, C_2, C_3]] self._logger.debug("May share memory: %s" %np.may_share_memory(other, reshaped)) #print(repr(reshaped)) # the averaging finally creates a new array that has it's own data average = np.average(reshaped, axis=0) average = np.expand_dims(average, axis=1) # up the rank to 2 # data is [[X_1], # [X_2], # [X_3]] return average
def test_copy(self): mlp0 = MultilayerPerceptron() mlp1 = mlp0.copy() assert mlp0.params == mlp1.params check_mlp_same_est(mlp0, mlp1) for l0, l1 in zip(mlp0.layers, mlp1.layers): assert not np.may_share_memory(l0.weights, l1.weights) assert not np.may_share_memory(l0.activations, l1.activations) assert l0.bias == l1.bias
def _assert_copies(t, t2, deep=True): assert t.colnames == t2.colnames np.testing.assert_array_equal(t.as_array(), t2.as_array()) assert t.meta == t2.meta for col, col2 in zip(t.columns.values(), t2.columns.values()): if deep: assert not np.may_share_memory(col, col2) else: assert np.may_share_memory(col, col2)
def test_flatten(self): s0_flatten = self.s0.flatten() assert s0_flatten.shape == (self.s0.size,) assert np.all(s0_flatten.lon == self.s0.lon.flatten()) # Flatten always copies. assert not np.may_share_memory(s0_flatten.distance, self.s0.distance) s1_flatten = self.s1.flatten() assert s1_flatten.shape == (self.s1.size,) assert np.all(s1_flatten.lon == self.s1.lon.flatten()) assert not np.may_share_memory(s1_flatten.lat, self.s1.lat)
def test_copy(self): s0_copy = self.s0.copy() s0_copy_diff = s0_copy.differentials['s'] assert s0_copy.shape == self.s0.shape assert np.all(s0_copy.lon == self.s0.lon) assert np.all(s0_copy.lat == self.s0.lat) # Check copy was made of internal data. assert not np.may_share_memory(s0_copy.distance, self.s0.distance) assert not np.may_share_memory(s0_copy_diff.d_lon, self.diff.d_lon)
def test_broadcast_to(self): s0_broadcast = self.s0._apply(np_broadcast_to, (3, 6, 7), subok=True) assert type(s0_broadcast) is type(self.s0) assert s0_broadcast.shape == (3, 6, 7) assert np.all(s0_broadcast.lon == self.s0.lon) assert np.all(s0_broadcast.lat == self.s0.lat) assert np.all(s0_broadcast.distance == self.s0.distance) assert np.may_share_memory(s0_broadcast.lon, self.s0.lon) assert np.may_share_memory(s0_broadcast.lat, self.s0.lat) assert np.may_share_memory(s0_broadcast.distance, self.s0.distance) s1_broadcast = self.s1._apply(np_broadcast_to, shape=(3, 6, 7), subok=True) assert s1_broadcast.shape == (3, 6, 7) assert np.all(s1_broadcast.lat == self.s1.lat) assert np.all(s1_broadcast.lon == self.s1.lon) assert np.all(s1_broadcast.distance == self.s1.distance) assert s1_broadcast.distance.shape == (3, 6, 7) assert np.may_share_memory(s1_broadcast.lat, self.s1.lat) assert np.may_share_memory(s1_broadcast.lon, self.s1.lon) assert np.may_share_memory(s1_broadcast.distance, self.s1.distance) # A final test that "may_share_memory" equals "does_share_memory" # Do this on a copy, to keep self.s0 unchanged. sc = self.s0.copy() assert not np.may_share_memory(sc.lon, self.s0.lon) assert not np.may_share_memory(sc.lat, self.s0.lat) sc_broadcast = sc._apply(np_broadcast_to, (3, 6, 7), subok=True) assert np.may_share_memory(sc_broadcast.lon, sc.lon) # Can only write to copy, not to broadcast version. sc.lon[0, 0] = 22. * u.hourangle assert np.all(sc_broadcast.lon[:, 0, 0] == 22. * u.hourangle)
def test_build_spec_table_not_copy(self): """build_spec_table should not copy tables if not neccessary""" xs = np.arange(3) # float32 table will force a copy because Orange X is float64 X = np.ones([4, 3], dtype=np.float32) data = build_spec_table(xs, X) self.assertFalse(np.may_share_memory(data.X, X)) # float64 will not force a copy X = np.ones([4, 3], dtype=np.float64) data = build_spec_table(xs, X) self.assertTrue(np.may_share_memory(data.X, X))
def test_ravel(self): s0_ravel = self.s0.ravel() assert s0_ravel.shape == (self.s0.size,) assert np.all(s0_ravel.lon == self.s0.lon.ravel()) assert np.may_share_memory(s0_ravel.lon, self.s0.lon) assert np.may_share_memory(s0_ravel.lat, self.s0.lat) assert np.may_share_memory(s0_ravel.distance, self.s0.distance) # Since s1 was broadcast, ravel needs to make a copy. s1_ravel = self.s1.ravel() assert s1_ravel.shape == (self.s1.size,) assert np.all(s1_ravel.lon == self.s1.lon.ravel()) assert not np.may_share_memory(s1_ravel.lat, self.s1.lat)
def test_copy_crop(): arr = np.arange(45).reshape(9, 5) out0 = crop(arr, 1, copy=True) assert out0.flags.c_contiguous out0[0, 0] = 100 assert not np.any(arr == 100) assert not np.may_share_memory(arr, out0) out1 = crop(arr, 1) out1[0, 0] = 100 assert arr[1, 1] == 100 assert np.may_share_memory(arr, out1)
def test_dot_mv(self, its=100): for it in range(its): size = random.choice([0, 1, randint(0, 10), randint(0, 100)]) a_bm = gen_BandMat(size) b = randn(size) a_full = a_bm.full() c = bm.dot_mv(a_bm, b) c_good = np.dot(a_full, b) assert_allclose(c, c_good) assert not np.may_share_memory(c, a_bm.data) assert not np.may_share_memory(c, b)
def test_getitem_general(self): """Test slicing on different types of fields.""" ibounds = [True, False] ivalue = [True, False] ilevel = [True, False] itemporal = [True, False] irealization = [True, False] for ib, iv, il, it, ir in itertools.product(ibounds, ivalue, ilevel, itemporal, irealization): field = self.get_field(with_bounds=ib, with_value=iv, with_level=il, with_temporal=it, with_realization=ir) if il: self.assertEqual(field.shape[2], 2) else: self.assertEqual(field.shape[2], 1) # # try a bad slice with self.assertRaises(IndexError): field[0] # # now good slices # # if data is loaded prior to slicing then memory is shared field.spatial.geom.point.value field_slc = field[:, :, :, :, :] self.assertTrue(np.may_share_memory(field.spatial.grid.value, field_slc.spatial.grid.value)) self.assertTrue(np.may_share_memory(field.spatial.geom.point.value, field_slc.spatial.geom.point.value)) field_value = field.variables['tmax']._value field_slc_value = field_slc.variables['tmax']._value try: self.assertNumpyAll(field_value, field_slc_value) except AttributeError: # with no attached value to the field, the private value will be nones if iv is None: self.assertIsNone(field_value) self.assertIsNone(field_slc_value) if iv == True: self.assertTrue(np.may_share_memory(field_value, field_slc_value)) else: self.assertEqual(field_slc_value, None) field_slc = field[0, 0, 0, 0, 0] self.assertEqual(field_slc.shape, (1, 1, 1, 1, 1)) if iv: self.assertEqual(field_slc.variables['tmax'].value.shape, (1, 1, 1, 1, 1)) self.assertNumpyAll(field_slc.variables['tmax'].value, np.ma.array(field.variables['tmax'].value[0, 0, 0, 0, 0]).reshape(1, 1, 1, 1, 1)) else: self.assertEqual(field_slc.variables['tmax']._value, None) self.assertEqual(field_slc.variables['tmax']._value, field.variables['tmax']._value)
def test_BandMat_various_divs(self, its=100): for it in range(its): size = random.choice([0, 1, randint(0, 10), randint(0, 100)]) mult = randn() a_bm = gen_BandMat(size) a_full = a_bm.full() b_bm = a_bm // mult b_full = a_full // mult assert b_bm.l == a_bm.l assert b_bm.u == a_bm.u assert_allclose(b_bm.full(), b_full) assert not np.may_share_memory(b_bm.data, a_bm.data) b_bm = a_bm / mult b_full = a_full / mult assert b_bm.l == a_bm.l assert b_bm.u == a_bm.u assert_allclose(b_bm.full(), b_full) assert not np.may_share_memory(b_bm.data, a_bm.data) b_bm = a_bm.__floordiv__(mult) b_full = a_full.__floordiv__(mult) assert b_bm.l == a_bm.l assert b_bm.u == a_bm.u assert_allclose(b_bm.full(), b_full) assert not np.may_share_memory(b_bm.data, a_bm.data) # __div__ does not exist in python3 if sys.version_info[0] < 3: b_bm = a_bm.__div__(mult) b_full = a_full.__div__(mult) assert b_bm.l == a_bm.l assert b_bm.u == a_bm.u assert_allclose(b_bm.full(), b_full) assert not np.may_share_memory(b_bm.data, a_bm.data) b_bm = a_bm.__truediv__(mult) b_full = a_full.__truediv__(mult) assert b_bm.l == a_bm.l assert b_bm.u == a_bm.u assert_allclose(b_bm.full(), b_full) assert not np.may_share_memory(b_bm.data, a_bm.data) with self.assertRaises(TypeError): a_bm // a_bm with self.assertRaises(TypeError): a_bm / a_bm with self.assertRaises(TypeError): 1.0 // a_bm with self.assertRaises(TypeError): 1.0 / a_bm
def test_diagonal(self): s0_diagonal = self.s0.diagonal() assert s0_diagonal.shape == (6, ) assert np.all(s0_diagonal.data.lat == self.s0.data.lat.diagonal()) assert np.may_share_memory(s0_diagonal.data.lat, self.s0.data.lat)
def test_reshape(self): s0_reshape = self.s0.reshape(2, 3, 7) assert s0_reshape.shape == (2, 3, 7) assert np.all(s0_reshape.data.lon == self.s0.data.lon.reshape(2, 3, 7)) assert np.all(s0_reshape.data.lat == self.s0.data.lat.reshape(2, 3, 7)) assert np.may_share_memory(s0_reshape.data.lon, self.s0.data.lon) assert np.may_share_memory(s0_reshape.data.lat, self.s0.data.lat) s1_reshape = self.s1.reshape(3, 2, 7) assert s1_reshape.shape == (3, 2, 7) assert np.all(s1_reshape.data.lat == self.s1.data.lat.reshape(3, 2, 7)) assert np.may_share_memory(s1_reshape.data.lat, self.s1.data.lat) assert np.all(s1_reshape.obstime == self.s1.obstime.reshape(3, 2, 7)) assert np.may_share_memory(s1_reshape.obstime.jd1, self.s1.obstime.jd1) assert np.all(s1_reshape.location == self.s1.location.reshape(3, 2, 7)) assert np.may_share_memory(s1_reshape.location, self.s1.location) assert np.all( s1_reshape.temperature == self.s1.temperature.reshape(3, 2, 7)) assert np.may_share_memory(s1_reshape.temperature, self.s1.temperature) assert s1_reshape.pressure == self.s1.pressure # For reshape(3, 14), copying is necessary for lon, lat, location, time s1_reshape2 = self.s1.reshape(3, 14) assert s1_reshape2.shape == (3, 14) assert np.all(s1_reshape2.data.lon == self.s1.data.lon.reshape(3, 14)) assert not np.may_share_memory(s1_reshape2.data.lon, self.s1.data.lon) assert np.all(s1_reshape2.obstime == self.s1.obstime.reshape(3, 14)) assert not np.may_share_memory(s1_reshape2.obstime.jd1, self.s1.obstime.jd1) assert np.all(s1_reshape2.location == self.s1.location.reshape(3, 14)) assert not np.may_share_memory(s1_reshape2.location, self.s1.location) assert np.all( s1_reshape2.temperature == self.s1.temperature.reshape(3, 14)) assert np.may_share_memory(s1_reshape2.temperature, self.s1.temperature) assert s1_reshape2.pressure == self.s1.pressure s2_reshape = self.s2.reshape(3, 2, 7) assert s2_reshape.shape == (3, 2, 7) assert np.all(s2_reshape.data.lon == self.s2.data.lon.reshape(3, 2, 7)) assert np.may_share_memory(s2_reshape.data.lat, self.s2.data.lat) assert np.all(s2_reshape.obstime == self.s2.obstime.reshape(3, 2, 7)) assert np.may_share_memory(s2_reshape.obstime.jd1, self.s2.obstime.jd1) assert np.all( s2_reshape.obsgeoloc.xyz == self.s2.obsgeoloc.reshape(3, 2, 7).xyz) assert np.may_share_memory(s2_reshape.obsgeoloc.x, self.s2.obsgeoloc.x) s3_reshape = self.s3.reshape(3, 2, 7) assert s3_reshape.shape == (3, 2, 7) assert np.all(s3_reshape.obstime == self.s3.obstime.reshape(3, 2, 7)) assert np.may_share_memory(s3_reshape.obstime.jd1, self.s3.obstime.jd1) assert np.all( s3_reshape.obsgeoloc.xyz == self.s3.obsgeoloc.reshape(3, 2, 7).xyz) assert np.may_share_memory(s3_reshape.obsgeoloc.x, self.s3.obsgeoloc.x) sc_reshape = self.sc.reshape(3, 2, 7) assert sc_reshape.shape == (3, 2, 7) assert np.all(sc_reshape.data.lon == self.sc.data.lon.reshape(3, 2, 7)) assert np.may_share_memory(sc_reshape.data.lat, self.sc.data.lat) assert np.all(sc_reshape.obstime == self.sc.obstime.reshape(3, 2, 7)) assert np.may_share_memory(sc_reshape.obstime.jd1, self.sc.obstime.jd1) assert np.all( sc_reshape.obsgeoloc.xyz == self.sc.obsgeoloc.reshape(3, 2, 7).xyz) assert np.may_share_memory(sc_reshape.obsgeoloc.x, self.sc.obsgeoloc.x) # For reshape(3, 14), the arrays all need to be copied. sc_reshape2 = self.sc.reshape(3, 14) assert sc_reshape2.shape == (3, 14) assert np.all(sc_reshape2.data.lon == self.sc.data.lon.reshape(3, 14)) assert not np.may_share_memory(sc_reshape2.data.lat, self.sc.data.lat) assert np.all(sc_reshape2.obstime == self.sc.obstime.reshape(3, 14)) assert not np.may_share_memory(sc_reshape2.obstime.jd1, self.sc.obstime.jd1) assert np.all( sc_reshape2.obsgeoloc.xyz == self.sc.obsgeoloc.reshape(3, 14).xyz) assert not np.may_share_memory(sc_reshape2.obsgeoloc.x, self.sc.obsgeoloc.x)
def test_squeeze(self): s0_squeeze = self.s0.reshape(3, 1, 2, 1, 7).squeeze() assert s0_squeeze.shape == (3, 2, 7) assert np.all(s0_squeeze.data.lat == self.s0.data.lat.reshape(3, 2, 7)) assert np.may_share_memory(s0_squeeze.data.lat, self.s0.data.lat)
def test_broadcast_to(self): s1_broadcast = np.broadcast_to(self.s1, (20, 6, 7)) assert s1_broadcast.shape == (20, 6, 7) assert np.all(s1_broadcast.data.lon == self.s1.data.lon[np.newaxis]) assert np.may_share_memory(s1_broadcast.data.lat, self.s1.data.lat)
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_potential_output_aliasing_induced_by_updates(self): A = self.shared(np.zeros((2, 2))) B = self.shared(np.zeros((2, 2))) C = np.zeros((2, 2)) D = tensor.dmatrix() DD = D + 5 f = pfunc([D], [], updates=[(A, D), (B, D)]) f(C) assert not np.may_share_memory(data_of(A), data_of(B)) f = pfunc([D], [], updates=[(A, D[:]), (B, D)]) f(C) assert not np.may_share_memory(data_of(A), data_of(B)) f = pfunc([D], [], updates=[(A, (D + 5)), (B, D[:])]) f(C) assert not np.may_share_memory(data_of(A), data_of(B)) f = pfunc([D], [], updates=[(A, (D + 5)), (B, D)]) f(C) assert not np.may_share_memory(data_of(A), data_of(B)) f = pfunc([D], DD, updates=[(A, DD[:1]), (B, DD)]) R = f(C) assert not np.may_share_memory(data_of(A), data_of(B)) assert not np.may_share_memory(R, data_of(B)) assert not np.may_share_memory(R, data_of(A)) f = pfunc([D], DD, updates=[(A, DD[:1]), (B, (DD[:1] * 2))]) R = f(C) assert not np.may_share_memory(data_of(A), data_of(B)) assert not np.may_share_memory(R, data_of(B)) assert not np.may_share_memory(R, data_of(A)) f = pfunc([D], (DD * 4), updates=[(A, (DD[:1] * 3)), (B, (DD[:1] * 2))]) R = f(C) assert not np.may_share_memory(data_of(A), data_of(B)) assert not np.may_share_memory(R, data_of(B)) assert not np.may_share_memory(R, data_of(A)) f = pfunc([D], (DD * 4), updates=[(A, (DD[:1] * 3)), (B, (DD[:1] * 3))]) R = f(C) assert not np.may_share_memory(data_of(A), data_of(B)) assert not np.may_share_memory(R, data_of(B)) assert not np.may_share_memory(R, data_of(A))
def test_check_array_memmap(copy): X = np.ones((4, 4)) with TempMemmap(X, mmap_mode='r') as X_memmap: X_checked = check_array(X_memmap, copy=copy) assert np.may_share_memory(X_memmap, X_checked) == (not copy) assert X_checked.flags['WRITEABLE'] == copy
def test_ravel(self): s0_ravel = self.s0.ravel() assert s0_ravel.shape == (self.s0.size, ) assert np.all(s0_ravel.data.lon == self.s0.data.lon.ravel()) assert np.may_share_memory(s0_ravel.data.lon, self.s0.data.lon) assert np.may_share_memory(s0_ravel.data.lat, self.s0.data.lat) # Since s1 lon, lat were broadcast, ravel needs to make a copy. s1_ravel = self.s1.ravel() assert s1_ravel.shape == (self.s1.size, ) assert np.all(s1_ravel.data.lon == self.s1.data.lon.ravel()) assert not np.may_share_memory(s1_ravel.data.lat, self.s1.data.lat) assert np.all(s1_ravel.obstime == self.s1.obstime.ravel()) assert not np.may_share_memory(s1_ravel.obstime.jd1, self.s1.obstime.jd1) assert np.all(s1_ravel.location == self.s1.location.ravel()) assert not np.may_share_memory(s1_ravel.location, self.s1.location) assert np.all(s1_ravel.temperature == self.s1.temperature.ravel()) assert np.may_share_memory(s1_ravel.temperature, self.s1.temperature) assert s1_ravel.pressure == self.s1.pressure s2_ravel = self.s2.ravel() assert s2_ravel.shape == (self.s2.size, ) assert np.all(s2_ravel.data.lon == self.s2.data.lon.ravel()) assert not np.may_share_memory(s2_ravel.data.lat, self.s2.data.lat) assert np.all(s2_ravel.obstime == self.s2.obstime.ravel()) assert not np.may_share_memory(s2_ravel.obstime.jd1, self.s2.obstime.jd1) # CartesianRepresentation do not allow direct comparisons, as this is # too tricky to get right in the face of rounding issues. Here, though, # it cannot be an issue, so we compare the xyz quantities. assert np.all(s2_ravel.obsgeoloc.xyz == self.s2.obsgeoloc.ravel().xyz) assert not np.may_share_memory(s2_ravel.obsgeoloc.x, self.s2.obsgeoloc.x) s3_ravel = self.s3.ravel() assert s3_ravel.shape == (42, ) # cannot use .size on frame w/o data. assert np.all(s3_ravel.obstime == self.s3.obstime.ravel()) assert not np.may_share_memory(s3_ravel.obstime.jd1, self.s3.obstime.jd1) assert np.all(s3_ravel.obsgeoloc.xyz == self.s3.obsgeoloc.ravel().xyz) assert not np.may_share_memory(s3_ravel.obsgeoloc.x, self.s3.obsgeoloc.x) sc_ravel = self.sc.ravel() assert sc_ravel.shape == (self.sc.size, ) assert np.all(sc_ravel.data.lon == self.sc.data.lon.ravel()) assert not np.may_share_memory(sc_ravel.data.lat, self.sc.data.lat) assert np.all(sc_ravel.obstime == self.sc.obstime.ravel()) assert not np.may_share_memory(sc_ravel.obstime.jd1, self.sc.obstime.jd1) assert np.all(sc_ravel.obsgeoloc.xyz == self.sc.obsgeoloc.ravel().xyz) assert not np.may_share_memory(sc_ravel.obsgeoloc.x, self.sc.obsgeoloc.x)
def test_getitem0101(self): # We on purpose take a slice with only one element, as for the # general tests it doesn't matter, but it allows us to check # for a few cases that shapes correctly become scalar if we # index our size-1 array down to a scalar. See gh-10113. item = (slice(0, 1), slice(0, 1)) s0_0101 = self.s0[item] assert s0_0101.shape == (1, 1) assert_array_equal(s0_0101.data.lon, self.s0.data.lon[item]) assert np.may_share_memory(s0_0101.data.lon, self.s0.data.lon) assert np.may_share_memory(s0_0101.data.lat, self.s0.data.lat) s0_0101_00 = s0_0101[0, 0] assert s0_0101_00.shape == () assert s0_0101_00.data.lon.shape == () assert_array_equal(s0_0101_00.data.lon, self.s0.data.lon[0, 0]) s1_0101 = self.s1[item] assert s1_0101.shape == (1, 1) assert_array_equal(s1_0101.data.lon, self.s1.data.lon[item]) assert np.may_share_memory(s1_0101.data.lat, self.s1.data.lat) assert np.all(s1_0101.obstime == self.s1.obstime[item]) assert np.may_share_memory(s1_0101.obstime.jd1, self.s1.obstime.jd1) assert_array_equal(s1_0101.location, self.s1.location[0, 0]) assert np.may_share_memory(s1_0101.location, self.s1.location) assert_array_equal(s1_0101.temperature, self.s1.temperature[item]) assert np.may_share_memory(s1_0101.temperature, self.s1.temperature) # scalar should just be transferred. assert s1_0101.pressure is self.s1.pressure s1_0101_00 = s1_0101[0, 0] assert s1_0101_00.shape == () assert s1_0101_00.obstime.shape == () assert s1_0101_00.obstime == self.s1.obstime[0, 0] s2_0101 = self.s2[item] assert s2_0101.shape == (1, 1) assert np.all(s2_0101.data.lon == self.s2.data.lon[item]) assert np.may_share_memory(s2_0101.data.lat, self.s2.data.lat) assert np.all(s2_0101.obstime == self.s2.obstime[item]) assert np.may_share_memory(s2_0101.obstime.jd1, self.s2.obstime.jd1) assert_array_equal(s2_0101.obsgeoloc.xyz, self.s2.obsgeoloc[item].xyz) s3_0101 = self.s3[item] assert s3_0101.shape == (1, 1) assert s3_0101.obstime.shape == (1, 1) assert np.all(s3_0101.obstime == self.s3.obstime[item]) assert np.may_share_memory(s3_0101.obstime.jd1, self.s3.obstime.jd1) assert_array_equal(s3_0101.obsgeoloc.xyz, self.s3.obsgeoloc[item].xyz) sc_0101 = self.sc[item] assert sc_0101.shape == (1, 1) assert_array_equal(sc_0101.data.lon, self.sc.data.lon[item]) assert np.may_share_memory(sc_0101.data.lat, self.sc.data.lat) assert np.all(sc_0101.obstime == self.sc.obstime[item]) assert np.may_share_memory(sc_0101.obstime.jd1, self.sc.obstime.jd1) assert_array_equal(sc_0101.obsgeoloc.xyz, self.sc.obsgeoloc[item].xyz)
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 may_share_memory(a, b): # This is a method of TensorType, so both a and b should be ndarrays if isinstance(a, numpy.ndarray) and isinstance(b, numpy.ndarray): return numpy.may_share_memory(a, b) else: return False