Spaces:
Sleeping
Sleeping
| import numpy as np | |
| from numpy.core._rational_tests import rational | |
| from numpy.testing import ( | |
| assert_equal, assert_array_equal, assert_raises, assert_, | |
| assert_raises_regex, assert_warns, | |
| ) | |
| from numpy.lib.stride_tricks import ( | |
| as_strided, broadcast_arrays, _broadcast_shape, broadcast_to, | |
| broadcast_shapes, sliding_window_view, | |
| ) | |
| import pytest | |
| def assert_shapes_correct(input_shapes, expected_shape): | |
| # Broadcast a list of arrays with the given input shapes and check the | |
| # common output shape. | |
| inarrays = [np.zeros(s) for s in input_shapes] | |
| outarrays = broadcast_arrays(*inarrays) | |
| outshapes = [a.shape for a in outarrays] | |
| expected = [expected_shape] * len(inarrays) | |
| assert_equal(outshapes, expected) | |
| def assert_incompatible_shapes_raise(input_shapes): | |
| # Broadcast a list of arrays with the given (incompatible) input shapes | |
| # and check that they raise a ValueError. | |
| inarrays = [np.zeros(s) for s in input_shapes] | |
| assert_raises(ValueError, broadcast_arrays, *inarrays) | |
| def assert_same_as_ufunc(shape0, shape1, transposed=False, flipped=False): | |
| # Broadcast two shapes against each other and check that the data layout | |
| # is the same as if a ufunc did the broadcasting. | |
| x0 = np.zeros(shape0, dtype=int) | |
| # Note that multiply.reduce's identity element is 1.0, so when shape1==(), | |
| # this gives the desired n==1. | |
| n = int(np.multiply.reduce(shape1)) | |
| x1 = np.arange(n).reshape(shape1) | |
| if transposed: | |
| x0 = x0.T | |
| x1 = x1.T | |
| if flipped: | |
| x0 = x0[::-1] | |
| x1 = x1[::-1] | |
| # Use the add ufunc to do the broadcasting. Since we're adding 0s to x1, the | |
| # result should be exactly the same as the broadcasted view of x1. | |
| y = x0 + x1 | |
| b0, b1 = broadcast_arrays(x0, x1) | |
| assert_array_equal(y, b1) | |
| def test_same(): | |
| x = np.arange(10) | |
| y = np.arange(10) | |
| bx, by = broadcast_arrays(x, y) | |
| assert_array_equal(x, bx) | |
| assert_array_equal(y, by) | |
| def test_broadcast_kwargs(): | |
| # ensure that a TypeError is appropriately raised when | |
| # np.broadcast_arrays() is called with any keyword | |
| # argument other than 'subok' | |
| x = np.arange(10) | |
| y = np.arange(10) | |
| with assert_raises_regex(TypeError, 'got an unexpected keyword'): | |
| broadcast_arrays(x, y, dtype='float64') | |
| def test_one_off(): | |
| x = np.array([[1, 2, 3]]) | |
| y = np.array([[1], [2], [3]]) | |
| bx, by = broadcast_arrays(x, y) | |
| bx0 = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) | |
| by0 = bx0.T | |
| assert_array_equal(bx0, bx) | |
| assert_array_equal(by0, by) | |
| def test_same_input_shapes(): | |
| # Check that the final shape is just the input shape. | |
| data = [ | |
| (), | |
| (1,), | |
| (3,), | |
| (0, 1), | |
| (0, 3), | |
| (1, 0), | |
| (3, 0), | |
| (1, 3), | |
| (3, 1), | |
| (3, 3), | |
| ] | |
| for shape in data: | |
| input_shapes = [shape] | |
| # Single input. | |
| assert_shapes_correct(input_shapes, shape) | |
| # Double input. | |
| input_shapes2 = [shape, shape] | |
| assert_shapes_correct(input_shapes2, shape) | |
| # Triple input. | |
| input_shapes3 = [shape, shape, shape] | |
| assert_shapes_correct(input_shapes3, shape) | |
| def test_two_compatible_by_ones_input_shapes(): | |
| # Check that two different input shapes of the same length, but some have | |
| # ones, broadcast to the correct shape. | |
| data = [ | |
| [[(1,), (3,)], (3,)], | |
| [[(1, 3), (3, 3)], (3, 3)], | |
| [[(3, 1), (3, 3)], (3, 3)], | |
| [[(1, 3), (3, 1)], (3, 3)], | |
| [[(1, 1), (3, 3)], (3, 3)], | |
| [[(1, 1), (1, 3)], (1, 3)], | |
| [[(1, 1), (3, 1)], (3, 1)], | |
| [[(1, 0), (0, 0)], (0, 0)], | |
| [[(0, 1), (0, 0)], (0, 0)], | |
| [[(1, 0), (0, 1)], (0, 0)], | |
| [[(1, 1), (0, 0)], (0, 0)], | |
| [[(1, 1), (1, 0)], (1, 0)], | |
| [[(1, 1), (0, 1)], (0, 1)], | |
| ] | |
| for input_shapes, expected_shape in data: | |
| assert_shapes_correct(input_shapes, expected_shape) | |
| # Reverse the input shapes since broadcasting should be symmetric. | |
| assert_shapes_correct(input_shapes[::-1], expected_shape) | |
| def test_two_compatible_by_prepending_ones_input_shapes(): | |
| # Check that two different input shapes (of different lengths) broadcast | |
| # to the correct shape. | |
| data = [ | |
| [[(), (3,)], (3,)], | |
| [[(3,), (3, 3)], (3, 3)], | |
| [[(3,), (3, 1)], (3, 3)], | |
| [[(1,), (3, 3)], (3, 3)], | |
| [[(), (3, 3)], (3, 3)], | |
| [[(1, 1), (3,)], (1, 3)], | |
| [[(1,), (3, 1)], (3, 1)], | |
| [[(1,), (1, 3)], (1, 3)], | |
| [[(), (1, 3)], (1, 3)], | |
| [[(), (3, 1)], (3, 1)], | |
| [[(), (0,)], (0,)], | |
| [[(0,), (0, 0)], (0, 0)], | |
| [[(0,), (0, 1)], (0, 0)], | |
| [[(1,), (0, 0)], (0, 0)], | |
| [[(), (0, 0)], (0, 0)], | |
| [[(1, 1), (0,)], (1, 0)], | |
| [[(1,), (0, 1)], (0, 1)], | |
| [[(1,), (1, 0)], (1, 0)], | |
| [[(), (1, 0)], (1, 0)], | |
| [[(), (0, 1)], (0, 1)], | |
| ] | |
| for input_shapes, expected_shape in data: | |
| assert_shapes_correct(input_shapes, expected_shape) | |
| # Reverse the input shapes since broadcasting should be symmetric. | |
| assert_shapes_correct(input_shapes[::-1], expected_shape) | |
| def test_incompatible_shapes_raise_valueerror(): | |
| # Check that a ValueError is raised for incompatible shapes. | |
| data = [ | |
| [(3,), (4,)], | |
| [(2, 3), (2,)], | |
| [(3,), (3,), (4,)], | |
| [(1, 3, 4), (2, 3, 3)], | |
| ] | |
| for input_shapes in data: | |
| assert_incompatible_shapes_raise(input_shapes) | |
| # Reverse the input shapes since broadcasting should be symmetric. | |
| assert_incompatible_shapes_raise(input_shapes[::-1]) | |
| def test_same_as_ufunc(): | |
| # Check that the data layout is the same as if a ufunc did the operation. | |
| data = [ | |
| [[(1,), (3,)], (3,)], | |
| [[(1, 3), (3, 3)], (3, 3)], | |
| [[(3, 1), (3, 3)], (3, 3)], | |
| [[(1, 3), (3, 1)], (3, 3)], | |
| [[(1, 1), (3, 3)], (3, 3)], | |
| [[(1, 1), (1, 3)], (1, 3)], | |
| [[(1, 1), (3, 1)], (3, 1)], | |
| [[(1, 0), (0, 0)], (0, 0)], | |
| [[(0, 1), (0, 0)], (0, 0)], | |
| [[(1, 0), (0, 1)], (0, 0)], | |
| [[(1, 1), (0, 0)], (0, 0)], | |
| [[(1, 1), (1, 0)], (1, 0)], | |
| [[(1, 1), (0, 1)], (0, 1)], | |
| [[(), (3,)], (3,)], | |
| [[(3,), (3, 3)], (3, 3)], | |
| [[(3,), (3, 1)], (3, 3)], | |
| [[(1,), (3, 3)], (3, 3)], | |
| [[(), (3, 3)], (3, 3)], | |
| [[(1, 1), (3,)], (1, 3)], | |
| [[(1,), (3, 1)], (3, 1)], | |
| [[(1,), (1, 3)], (1, 3)], | |
| [[(), (1, 3)], (1, 3)], | |
| [[(), (3, 1)], (3, 1)], | |
| [[(), (0,)], (0,)], | |
| [[(0,), (0, 0)], (0, 0)], | |
| [[(0,), (0, 1)], (0, 0)], | |
| [[(1,), (0, 0)], (0, 0)], | |
| [[(), (0, 0)], (0, 0)], | |
| [[(1, 1), (0,)], (1, 0)], | |
| [[(1,), (0, 1)], (0, 1)], | |
| [[(1,), (1, 0)], (1, 0)], | |
| [[(), (1, 0)], (1, 0)], | |
| [[(), (0, 1)], (0, 1)], | |
| ] | |
| for input_shapes, expected_shape in data: | |
| assert_same_as_ufunc(input_shapes[0], input_shapes[1], | |
| "Shapes: %s %s" % (input_shapes[0], input_shapes[1])) | |
| # Reverse the input shapes since broadcasting should be symmetric. | |
| assert_same_as_ufunc(input_shapes[1], input_shapes[0]) | |
| # Try them transposed, too. | |
| assert_same_as_ufunc(input_shapes[0], input_shapes[1], True) | |
| # ... and flipped for non-rank-0 inputs in order to test negative | |
| # strides. | |
| if () not in input_shapes: | |
| assert_same_as_ufunc(input_shapes[0], input_shapes[1], False, True) | |
| assert_same_as_ufunc(input_shapes[0], input_shapes[1], True, True) | |
| def test_broadcast_to_succeeds(): | |
| data = [ | |
| [np.array(0), (0,), np.array(0)], | |
| [np.array(0), (1,), np.zeros(1)], | |
| [np.array(0), (3,), np.zeros(3)], | |
| [np.ones(1), (1,), np.ones(1)], | |
| [np.ones(1), (2,), np.ones(2)], | |
| [np.ones(1), (1, 2, 3), np.ones((1, 2, 3))], | |
| [np.arange(3), (3,), np.arange(3)], | |
| [np.arange(3), (1, 3), np.arange(3).reshape(1, -1)], | |
| [np.arange(3), (2, 3), np.array([[0, 1, 2], [0, 1, 2]])], | |
| # test if shape is not a tuple | |
| [np.ones(0), 0, np.ones(0)], | |
| [np.ones(1), 1, np.ones(1)], | |
| [np.ones(1), 2, np.ones(2)], | |
| # these cases with size 0 are strange, but they reproduce the behavior | |
| # of broadcasting with ufuncs (see test_same_as_ufunc above) | |
| [np.ones(1), (0,), np.ones(0)], | |
| [np.ones((1, 2)), (0, 2), np.ones((0, 2))], | |
| [np.ones((2, 1)), (2, 0), np.ones((2, 0))], | |
| ] | |
| for input_array, shape, expected in data: | |
| actual = broadcast_to(input_array, shape) | |
| assert_array_equal(expected, actual) | |
| def test_broadcast_to_raises(): | |
| data = [ | |
| [(0,), ()], | |
| [(1,), ()], | |
| [(3,), ()], | |
| [(3,), (1,)], | |
| [(3,), (2,)], | |
| [(3,), (4,)], | |
| [(1, 2), (2, 1)], | |
| [(1, 1), (1,)], | |
| [(1,), -1], | |
| [(1,), (-1,)], | |
| [(1, 2), (-1, 2)], | |
| ] | |
| for orig_shape, target_shape in data: | |
| arr = np.zeros(orig_shape) | |
| assert_raises(ValueError, lambda: broadcast_to(arr, target_shape)) | |
| def test_broadcast_shape(): | |
| # tests internal _broadcast_shape | |
| # _broadcast_shape is already exercised indirectly by broadcast_arrays | |
| # _broadcast_shape is also exercised by the public broadcast_shapes function | |
| assert_equal(_broadcast_shape(), ()) | |
| assert_equal(_broadcast_shape([1, 2]), (2,)) | |
| assert_equal(_broadcast_shape(np.ones((1, 1))), (1, 1)) | |
| assert_equal(_broadcast_shape(np.ones((1, 1)), np.ones((3, 4))), (3, 4)) | |
| assert_equal(_broadcast_shape(*([np.ones((1, 2))] * 32)), (1, 2)) | |
| assert_equal(_broadcast_shape(*([np.ones((1, 2))] * 100)), (1, 2)) | |
| # regression tests for gh-5862 | |
| assert_equal(_broadcast_shape(*([np.ones(2)] * 32 + [1])), (2,)) | |
| bad_args = [np.ones(2)] * 32 + [np.ones(3)] * 32 | |
| assert_raises(ValueError, lambda: _broadcast_shape(*bad_args)) | |
| def test_broadcast_shapes_succeeds(): | |
| # tests public broadcast_shapes | |
| data = [ | |
| [[], ()], | |
| [[()], ()], | |
| [[(7,)], (7,)], | |
| [[(1, 2), (2,)], (1, 2)], | |
| [[(1, 1)], (1, 1)], | |
| [[(1, 1), (3, 4)], (3, 4)], | |
| [[(6, 7), (5, 6, 1), (7,), (5, 1, 7)], (5, 6, 7)], | |
| [[(5, 6, 1)], (5, 6, 1)], | |
| [[(1, 3), (3, 1)], (3, 3)], | |
| [[(1, 0), (0, 0)], (0, 0)], | |
| [[(0, 1), (0, 0)], (0, 0)], | |
| [[(1, 0), (0, 1)], (0, 0)], | |
| [[(1, 1), (0, 0)], (0, 0)], | |
| [[(1, 1), (1, 0)], (1, 0)], | |
| [[(1, 1), (0, 1)], (0, 1)], | |
| [[(), (0,)], (0,)], | |
| [[(0,), (0, 0)], (0, 0)], | |
| [[(0,), (0, 1)], (0, 0)], | |
| [[(1,), (0, 0)], (0, 0)], | |
| [[(), (0, 0)], (0, 0)], | |
| [[(1, 1), (0,)], (1, 0)], | |
| [[(1,), (0, 1)], (0, 1)], | |
| [[(1,), (1, 0)], (1, 0)], | |
| [[(), (1, 0)], (1, 0)], | |
| [[(), (0, 1)], (0, 1)], | |
| [[(1,), (3,)], (3,)], | |
| [[2, (3, 2)], (3, 2)], | |
| ] | |
| for input_shapes, target_shape in data: | |
| assert_equal(broadcast_shapes(*input_shapes), target_shape) | |
| assert_equal(broadcast_shapes(*([(1, 2)] * 32)), (1, 2)) | |
| assert_equal(broadcast_shapes(*([(1, 2)] * 100)), (1, 2)) | |
| # regression tests for gh-5862 | |
| assert_equal(broadcast_shapes(*([(2,)] * 32)), (2,)) | |
| def test_broadcast_shapes_raises(): | |
| # tests public broadcast_shapes | |
| data = [ | |
| [(3,), (4,)], | |
| [(2, 3), (2,)], | |
| [(3,), (3,), (4,)], | |
| [(1, 3, 4), (2, 3, 3)], | |
| [(1, 2), (3,1), (3,2), (10, 5)], | |
| [2, (2, 3)], | |
| ] | |
| for input_shapes in data: | |
| assert_raises(ValueError, lambda: broadcast_shapes(*input_shapes)) | |
| bad_args = [(2,)] * 32 + [(3,)] * 32 | |
| assert_raises(ValueError, lambda: broadcast_shapes(*bad_args)) | |
| def test_as_strided(): | |
| a = np.array([None]) | |
| a_view = as_strided(a) | |
| expected = np.array([None]) | |
| assert_array_equal(a_view, np.array([None])) | |
| a = np.array([1, 2, 3, 4]) | |
| a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,)) | |
| expected = np.array([1, 3]) | |
| assert_array_equal(a_view, expected) | |
| a = np.array([1, 2, 3, 4]) | |
| a_view = as_strided(a, shape=(3, 4), strides=(0, 1 * a.itemsize)) | |
| expected = np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]) | |
| assert_array_equal(a_view, expected) | |
| # Regression test for gh-5081 | |
| dt = np.dtype([('num', 'i4'), ('obj', 'O')]) | |
| a = np.empty((4,), dtype=dt) | |
| a['num'] = np.arange(1, 5) | |
| a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize)) | |
| expected_num = [[1, 2, 3, 4]] * 3 | |
| expected_obj = [[None]*4]*3 | |
| assert_equal(a_view.dtype, dt) | |
| assert_array_equal(expected_num, a_view['num']) | |
| assert_array_equal(expected_obj, a_view['obj']) | |
| # Make sure that void types without fields are kept unchanged | |
| a = np.empty((4,), dtype='V4') | |
| a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize)) | |
| assert_equal(a.dtype, a_view.dtype) | |
| # Make sure that the only type that could fail is properly handled | |
| dt = np.dtype({'names': [''], 'formats': ['V4']}) | |
| a = np.empty((4,), dtype=dt) | |
| a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize)) | |
| assert_equal(a.dtype, a_view.dtype) | |
| # Custom dtypes should not be lost (gh-9161) | |
| r = [rational(i) for i in range(4)] | |
| a = np.array(r, dtype=rational) | |
| a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize)) | |
| assert_equal(a.dtype, a_view.dtype) | |
| assert_array_equal([r] * 3, a_view) | |
| class TestSlidingWindowView: | |
| def test_1d(self): | |
| arr = np.arange(5) | |
| arr_view = sliding_window_view(arr, 2) | |
| expected = np.array([[0, 1], | |
| [1, 2], | |
| [2, 3], | |
| [3, 4]]) | |
| assert_array_equal(arr_view, expected) | |
| def test_2d(self): | |
| i, j = np.ogrid[:3, :4] | |
| arr = 10*i + j | |
| shape = (2, 2) | |
| arr_view = sliding_window_view(arr, shape) | |
| expected = np.array([[[[0, 1], [10, 11]], | |
| [[1, 2], [11, 12]], | |
| [[2, 3], [12, 13]]], | |
| [[[10, 11], [20, 21]], | |
| [[11, 12], [21, 22]], | |
| [[12, 13], [22, 23]]]]) | |
| assert_array_equal(arr_view, expected) | |
| def test_2d_with_axis(self): | |
| i, j = np.ogrid[:3, :4] | |
| arr = 10*i + j | |
| arr_view = sliding_window_view(arr, 3, 0) | |
| expected = np.array([[[0, 10, 20], | |
| [1, 11, 21], | |
| [2, 12, 22], | |
| [3, 13, 23]]]) | |
| assert_array_equal(arr_view, expected) | |
| def test_2d_repeated_axis(self): | |
| i, j = np.ogrid[:3, :4] | |
| arr = 10*i + j | |
| arr_view = sliding_window_view(arr, (2, 3), (1, 1)) | |
| expected = np.array([[[[0, 1, 2], | |
| [1, 2, 3]]], | |
| [[[10, 11, 12], | |
| [11, 12, 13]]], | |
| [[[20, 21, 22], | |
| [21, 22, 23]]]]) | |
| assert_array_equal(arr_view, expected) | |
| def test_2d_without_axis(self): | |
| i, j = np.ogrid[:4, :4] | |
| arr = 10*i + j | |
| shape = (2, 3) | |
| arr_view = sliding_window_view(arr, shape) | |
| expected = np.array([[[[0, 1, 2], [10, 11, 12]], | |
| [[1, 2, 3], [11, 12, 13]]], | |
| [[[10, 11, 12], [20, 21, 22]], | |
| [[11, 12, 13], [21, 22, 23]]], | |
| [[[20, 21, 22], [30, 31, 32]], | |
| [[21, 22, 23], [31, 32, 33]]]]) | |
| assert_array_equal(arr_view, expected) | |
| def test_errors(self): | |
| i, j = np.ogrid[:4, :4] | |
| arr = 10*i + j | |
| with pytest.raises(ValueError, match='cannot contain negative values'): | |
| sliding_window_view(arr, (-1, 3)) | |
| with pytest.raises( | |
| ValueError, | |
| match='must provide window_shape for all dimensions of `x`'): | |
| sliding_window_view(arr, (1,)) | |
| with pytest.raises( | |
| ValueError, | |
| match='Must provide matching length window_shape and axis'): | |
| sliding_window_view(arr, (1, 3, 4), axis=(0, 1)) | |
| with pytest.raises( | |
| ValueError, | |
| match='window shape cannot be larger than input array'): | |
| sliding_window_view(arr, (5, 5)) | |
| def test_writeable(self): | |
| arr = np.arange(5) | |
| view = sliding_window_view(arr, 2, writeable=False) | |
| assert_(not view.flags.writeable) | |
| with pytest.raises( | |
| ValueError, | |
| match='assignment destination is read-only'): | |
| view[0, 0] = 3 | |
| view = sliding_window_view(arr, 2, writeable=True) | |
| assert_(view.flags.writeable) | |
| view[0, 1] = 3 | |
| assert_array_equal(arr, np.array([0, 3, 2, 3, 4])) | |
| def test_subok(self): | |
| class MyArray(np.ndarray): | |
| pass | |
| arr = np.arange(5).view(MyArray) | |
| assert_(not isinstance(sliding_window_view(arr, 2, | |
| subok=False), | |
| MyArray)) | |
| assert_(isinstance(sliding_window_view(arr, 2, subok=True), MyArray)) | |
| # Default behavior | |
| assert_(not isinstance(sliding_window_view(arr, 2), MyArray)) | |
| def as_strided_writeable(): | |
| arr = np.ones(10) | |
| view = as_strided(arr, writeable=False) | |
| assert_(not view.flags.writeable) | |
| # Check that writeable also is fine: | |
| view = as_strided(arr, writeable=True) | |
| assert_(view.flags.writeable) | |
| view[...] = 3 | |
| assert_array_equal(arr, np.full_like(arr, 3)) | |
| # Test that things do not break down for readonly: | |
| arr.flags.writeable = False | |
| view = as_strided(arr, writeable=False) | |
| view = as_strided(arr, writeable=True) | |
| assert_(not view.flags.writeable) | |
| class VerySimpleSubClass(np.ndarray): | |
| def __new__(cls, *args, **kwargs): | |
| return np.array(*args, subok=True, **kwargs).view(cls) | |
| class SimpleSubClass(VerySimpleSubClass): | |
| def __new__(cls, *args, **kwargs): | |
| self = np.array(*args, subok=True, **kwargs).view(cls) | |
| self.info = 'simple' | |
| return self | |
| def __array_finalize__(self, obj): | |
| self.info = getattr(obj, 'info', '') + ' finalized' | |
| def test_subclasses(): | |
| # test that subclass is preserved only if subok=True | |
| a = VerySimpleSubClass([1, 2, 3, 4]) | |
| assert_(type(a) is VerySimpleSubClass) | |
| a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,)) | |
| assert_(type(a_view) is np.ndarray) | |
| a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,), subok=True) | |
| assert_(type(a_view) is VerySimpleSubClass) | |
| # test that if a subclass has __array_finalize__, it is used | |
| a = SimpleSubClass([1, 2, 3, 4]) | |
| a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,), subok=True) | |
| assert_(type(a_view) is SimpleSubClass) | |
| assert_(a_view.info == 'simple finalized') | |
| # similar tests for broadcast_arrays | |
| b = np.arange(len(a)).reshape(-1, 1) | |
| a_view, b_view = broadcast_arrays(a, b) | |
| assert_(type(a_view) is np.ndarray) | |
| assert_(type(b_view) is np.ndarray) | |
| assert_(a_view.shape == b_view.shape) | |
| a_view, b_view = broadcast_arrays(a, b, subok=True) | |
| assert_(type(a_view) is SimpleSubClass) | |
| assert_(a_view.info == 'simple finalized') | |
| assert_(type(b_view) is np.ndarray) | |
| assert_(a_view.shape == b_view.shape) | |
| # and for broadcast_to | |
| shape = (2, 4) | |
| a_view = broadcast_to(a, shape) | |
| assert_(type(a_view) is np.ndarray) | |
| assert_(a_view.shape == shape) | |
| a_view = broadcast_to(a, shape, subok=True) | |
| assert_(type(a_view) is SimpleSubClass) | |
| assert_(a_view.info == 'simple finalized') | |
| assert_(a_view.shape == shape) | |
| def test_writeable(): | |
| # broadcast_to should return a readonly array | |
| original = np.array([1, 2, 3]) | |
| result = broadcast_to(original, (2, 3)) | |
| assert_equal(result.flags.writeable, False) | |
| assert_raises(ValueError, result.__setitem__, slice(None), 0) | |
| # but the result of broadcast_arrays needs to be writeable, to | |
| # preserve backwards compatibility | |
| for is_broadcast, results in [(False, broadcast_arrays(original,)), | |
| (True, broadcast_arrays(0, original))]: | |
| for result in results: | |
| # This will change to False in a future version | |
| if is_broadcast: | |
| with assert_warns(FutureWarning): | |
| assert_equal(result.flags.writeable, True) | |
| with assert_warns(DeprecationWarning): | |
| result[:] = 0 | |
| # Warning not emitted, writing to the array resets it | |
| assert_equal(result.flags.writeable, True) | |
| else: | |
| # No warning: | |
| assert_equal(result.flags.writeable, True) | |
| for results in [broadcast_arrays(original), | |
| broadcast_arrays(0, original)]: | |
| for result in results: | |
| # resets the warn_on_write DeprecationWarning | |
| result.flags.writeable = True | |
| # check: no warning emitted | |
| assert_equal(result.flags.writeable, True) | |
| result[:] = 0 | |
| # keep readonly input readonly | |
| original.flags.writeable = False | |
| _, result = broadcast_arrays(0, original) | |
| assert_equal(result.flags.writeable, False) | |
| # regression test for GH6491 | |
| shape = (2,) | |
| strides = [0] | |
| tricky_array = as_strided(np.array(0), shape, strides) | |
| other = np.zeros((1,)) | |
| first, second = broadcast_arrays(tricky_array, other) | |
| assert_(first.shape == second.shape) | |
| def test_writeable_memoryview(): | |
| # The result of broadcast_arrays exports as a non-writeable memoryview | |
| # because otherwise there is no good way to opt in to the new behaviour | |
| # (i.e. you would need to set writeable to False explicitly). | |
| # See gh-13929. | |
| original = np.array([1, 2, 3]) | |
| for is_broadcast, results in [(False, broadcast_arrays(original,)), | |
| (True, broadcast_arrays(0, original))]: | |
| for result in results: | |
| # This will change to False in a future version | |
| if is_broadcast: | |
| # memoryview(result, writable=True) will give warning but cannot | |
| # be tested using the python API. | |
| assert memoryview(result).readonly | |
| else: | |
| assert not memoryview(result).readonly | |
| def test_reference_types(): | |
| input_array = np.array('a', dtype=object) | |
| expected = np.array(['a'] * 3, dtype=object) | |
| actual = broadcast_to(input_array, (3,)) | |
| assert_array_equal(expected, actual) | |
| actual, _ = broadcast_arrays(input_array, np.ones(3)) | |
| assert_array_equal(expected, actual) | |