tmp
/
pip-install-ghxuqwgs
/numpy_78e94bf2b6094bf9a1f3d92042f9bf46
/numpy
/lib
/tests
/test_twodim_base.py
| """Test functions for matrix module | |
| """ | |
| from __future__ import division, absolute_import, print_function | |
| from numpy.testing import ( | |
| TestCase, run_module_suite, assert_equal, assert_array_equal, | |
| assert_array_max_ulp, assert_array_almost_equal, assert_raises, rand, | |
| ) | |
| from numpy import ( | |
| arange, rot90, add, fliplr, flipud, zeros, ones, eye, array, diag, | |
| histogram2d, tri, mask_indices, triu_indices, triu_indices_from, | |
| tril_indices, tril_indices_from, vander, | |
| ) | |
| import numpy as np | |
| from numpy.compat import asbytes_nested | |
| def get_mat(n): | |
| data = arange(n) | |
| data = add.outer(data, data) | |
| return data | |
| class TestEye(TestCase): | |
| def test_basic(self): | |
| assert_equal(eye(4), | |
| array([[1, 0, 0, 0], | |
| [0, 1, 0, 0], | |
| [0, 0, 1, 0], | |
| [0, 0, 0, 1]])) | |
| assert_equal(eye(4, dtype='f'), | |
| array([[1, 0, 0, 0], | |
| [0, 1, 0, 0], | |
| [0, 0, 1, 0], | |
| [0, 0, 0, 1]], 'f')) | |
| assert_equal(eye(3) == 1, | |
| eye(3, dtype=bool)) | |
| def test_diag(self): | |
| assert_equal(eye(4, k=1), | |
| array([[0, 1, 0, 0], | |
| [0, 0, 1, 0], | |
| [0, 0, 0, 1], | |
| [0, 0, 0, 0]])) | |
| assert_equal(eye(4, k=-1), | |
| array([[0, 0, 0, 0], | |
| [1, 0, 0, 0], | |
| [0, 1, 0, 0], | |
| [0, 0, 1, 0]])) | |
| def test_2d(self): | |
| assert_equal(eye(4, 3), | |
| array([[1, 0, 0], | |
| [0, 1, 0], | |
| [0, 0, 1], | |
| [0, 0, 0]])) | |
| assert_equal(eye(3, 4), | |
| array([[1, 0, 0, 0], | |
| [0, 1, 0, 0], | |
| [0, 0, 1, 0]])) | |
| def test_diag2d(self): | |
| assert_equal(eye(3, 4, k=2), | |
| array([[0, 0, 1, 0], | |
| [0, 0, 0, 1], | |
| [0, 0, 0, 0]])) | |
| assert_equal(eye(4, 3, k=-2), | |
| array([[0, 0, 0], | |
| [0, 0, 0], | |
| [1, 0, 0], | |
| [0, 1, 0]])) | |
| def test_eye_bounds(self): | |
| assert_equal(eye(2, 2, 1), [[0, 1], [0, 0]]) | |
| assert_equal(eye(2, 2, -1), [[0, 0], [1, 0]]) | |
| assert_equal(eye(2, 2, 2), [[0, 0], [0, 0]]) | |
| assert_equal(eye(2, 2, -2), [[0, 0], [0, 0]]) | |
| assert_equal(eye(3, 2, 2), [[0, 0], [0, 0], [0, 0]]) | |
| assert_equal(eye(3, 2, 1), [[0, 1], [0, 0], [0, 0]]) | |
| assert_equal(eye(3, 2, -1), [[0, 0], [1, 0], [0, 1]]) | |
| assert_equal(eye(3, 2, -2), [[0, 0], [0, 0], [1, 0]]) | |
| assert_equal(eye(3, 2, -3), [[0, 0], [0, 0], [0, 0]]) | |
| def test_strings(self): | |
| assert_equal(eye(2, 2, dtype='S3'), | |
| asbytes_nested([['1', ''], ['', '1']])) | |
| def test_bool(self): | |
| assert_equal(eye(2, 2, dtype=bool), [[True, False], [False, True]]) | |
| class TestDiag(TestCase): | |
| def test_vector(self): | |
| vals = (100 * arange(5)).astype('l') | |
| b = zeros((5, 5)) | |
| for k in range(5): | |
| b[k, k] = vals[k] | |
| assert_equal(diag(vals), b) | |
| b = zeros((7, 7)) | |
| c = b.copy() | |
| for k in range(5): | |
| b[k, k + 2] = vals[k] | |
| c[k + 2, k] = vals[k] | |
| assert_equal(diag(vals, k=2), b) | |
| assert_equal(diag(vals, k=-2), c) | |
| def test_matrix(self, vals=None): | |
| if vals is None: | |
| vals = (100 * get_mat(5) + 1).astype('l') | |
| b = zeros((5,)) | |
| for k in range(5): | |
| b[k] = vals[k, k] | |
| assert_equal(diag(vals), b) | |
| b = b * 0 | |
| for k in range(3): | |
| b[k] = vals[k, k + 2] | |
| assert_equal(diag(vals, 2), b[:3]) | |
| for k in range(3): | |
| b[k] = vals[k + 2, k] | |
| assert_equal(diag(vals, -2), b[:3]) | |
| def test_fortran_order(self): | |
| vals = array((100 * get_mat(5) + 1), order='F', dtype='l') | |
| self.test_matrix(vals) | |
| def test_diag_bounds(self): | |
| A = [[1, 2], [3, 4], [5, 6]] | |
| assert_equal(diag(A, k=2), []) | |
| assert_equal(diag(A, k=1), [2]) | |
| assert_equal(diag(A, k=0), [1, 4]) | |
| assert_equal(diag(A, k=-1), [3, 6]) | |
| assert_equal(diag(A, k=-2), [5]) | |
| assert_equal(diag(A, k=-3), []) | |
| def test_failure(self): | |
| self.assertRaises(ValueError, diag, [[[1]]]) | |
| class TestFliplr(TestCase): | |
| def test_basic(self): | |
| self.assertRaises(ValueError, fliplr, ones(4)) | |
| a = get_mat(4) | |
| b = a[:, ::-1] | |
| assert_equal(fliplr(a), b) | |
| a = [[0, 1, 2], | |
| [3, 4, 5]] | |
| b = [[2, 1, 0], | |
| [5, 4, 3]] | |
| assert_equal(fliplr(a), b) | |
| class TestFlipud(TestCase): | |
| def test_basic(self): | |
| a = get_mat(4) | |
| b = a[::-1, :] | |
| assert_equal(flipud(a), b) | |
| a = [[0, 1, 2], | |
| [3, 4, 5]] | |
| b = [[3, 4, 5], | |
| [0, 1, 2]] | |
| assert_equal(flipud(a), b) | |
| class TestRot90(TestCase): | |
| def test_basic(self): | |
| self.assertRaises(ValueError, rot90, ones(4)) | |
| a = [[0, 1, 2], | |
| [3, 4, 5]] | |
| b1 = [[2, 5], | |
| [1, 4], | |
| [0, 3]] | |
| b2 = [[5, 4, 3], | |
| [2, 1, 0]] | |
| b3 = [[3, 0], | |
| [4, 1], | |
| [5, 2]] | |
| b4 = [[0, 1, 2], | |
| [3, 4, 5]] | |
| for k in range(-3, 13, 4): | |
| assert_equal(rot90(a, k=k), b1) | |
| for k in range(-2, 13, 4): | |
| assert_equal(rot90(a, k=k), b2) | |
| for k in range(-1, 13, 4): | |
| assert_equal(rot90(a, k=k), b3) | |
| for k in range(0, 13, 4): | |
| assert_equal(rot90(a, k=k), b4) | |
| def test_axes(self): | |
| a = ones((50, 40, 3)) | |
| assert_equal(rot90(a).shape, (40, 50, 3)) | |
| class TestHistogram2d(TestCase): | |
| def test_simple(self): | |
| x = array( | |
| [0.41702200, 0.72032449, 1.1437481e-4, 0.302332573, 0.146755891]) | |
| y = array( | |
| [0.09233859, 0.18626021, 0.34556073, 0.39676747, 0.53881673]) | |
| xedges = np.linspace(0, 1, 10) | |
| yedges = np.linspace(0, 1, 10) | |
| H = histogram2d(x, y, (xedges, yedges))[0] | |
| answer = array( | |
| [[0, 0, 0, 1, 0, 0, 0, 0, 0], | |
| [0, 0, 0, 0, 0, 0, 1, 0, 0], | |
| [0, 0, 0, 0, 0, 0, 0, 0, 0], | |
| [1, 0, 1, 0, 0, 0, 0, 0, 0], | |
| [0, 1, 0, 0, 0, 0, 0, 0, 0], | |
| [0, 0, 0, 0, 0, 0, 0, 0, 0], | |
| [0, 0, 0, 0, 0, 0, 0, 0, 0], | |
| [0, 0, 0, 0, 0, 0, 0, 0, 0], | |
| [0, 0, 0, 0, 0, 0, 0, 0, 0]]) | |
| assert_array_equal(H.T, answer) | |
| H = histogram2d(x, y, xedges)[0] | |
| assert_array_equal(H.T, answer) | |
| H, xedges, yedges = histogram2d(list(range(10)), list(range(10))) | |
| assert_array_equal(H, eye(10, 10)) | |
| assert_array_equal(xedges, np.linspace(0, 9, 11)) | |
| assert_array_equal(yedges, np.linspace(0, 9, 11)) | |
| def test_asym(self): | |
| x = array([1, 1, 2, 3, 4, 4, 4, 5]) | |
| y = array([1, 3, 2, 0, 1, 2, 3, 4]) | |
| H, xed, yed = histogram2d( | |
| x, y, (6, 5), range=[[0, 6], [0, 5]], normed=True) | |
| answer = array( | |
| [[0., 0, 0, 0, 0], | |
| [0, 1, 0, 1, 0], | |
| [0, 0, 1, 0, 0], | |
| [1, 0, 0, 0, 0], | |
| [0, 1, 1, 1, 0], | |
| [0, 0, 0, 0, 1]]) | |
| assert_array_almost_equal(H, answer/8., 3) | |
| assert_array_equal(xed, np.linspace(0, 6, 7)) | |
| assert_array_equal(yed, np.linspace(0, 5, 6)) | |
| def test_norm(self): | |
| x = array([1, 2, 3, 1, 2, 3, 1, 2, 3]) | |
| y = array([1, 1, 1, 2, 2, 2, 3, 3, 3]) | |
| H, xed, yed = histogram2d( | |
| x, y, [[1, 2, 3, 5], [1, 2, 3, 5]], normed=True) | |
| answer = array([[1, 1, .5], | |
| [1, 1, .5], | |
| [.5, .5, .25]])/9. | |
| assert_array_almost_equal(H, answer, 3) | |
| def test_all_outliers(self): | |
| r = rand(100) + 1. + 1e6 # histogramdd rounds by decimal=6 | |
| H, xed, yed = histogram2d(r, r, (4, 5), range=([0, 1], [0, 1])) | |
| assert_array_equal(H, 0) | |
| def test_empty(self): | |
| a, edge1, edge2 = histogram2d([], [], bins=([0, 1], [0, 1])) | |
| assert_array_max_ulp(a, array([[0.]])) | |
| a, edge1, edge2 = histogram2d([], [], bins=4) | |
| assert_array_max_ulp(a, np.zeros((4, 4))) | |
| class TestTri(TestCase): | |
| def test_dtype(self): | |
| out = array([[1, 0, 0], | |
| [1, 1, 0], | |
| [1, 1, 1]]) | |
| assert_array_equal(tri(3), out) | |
| assert_array_equal(tri(3, dtype=bool), out.astype(bool)) | |
| def test_tril_triu_ndim2(): | |
| for dtype in np.typecodes['AllFloat'] + np.typecodes['AllInteger']: | |
| a = np.ones((2, 2), dtype=dtype) | |
| b = np.tril(a) | |
| c = np.triu(a) | |
| yield assert_array_equal, b, [[1, 0], [1, 1]] | |
| yield assert_array_equal, c, b.T | |
| # should return the same dtype as the original array | |
| yield assert_equal, b.dtype, a.dtype | |
| yield assert_equal, c.dtype, a.dtype | |
| def test_tril_triu_ndim3(): | |
| for dtype in np.typecodes['AllFloat'] + np.typecodes['AllInteger']: | |
| a = np.array([ | |
| [[1, 1], [1, 1]], | |
| [[1, 1], [1, 0]], | |
| [[1, 1], [0, 0]], | |
| ], dtype=dtype) | |
| a_tril_desired = np.array([ | |
| [[1, 0], [1, 1]], | |
| [[1, 0], [1, 0]], | |
| [[1, 0], [0, 0]], | |
| ], dtype=dtype) | |
| a_triu_desired = np.array([ | |
| [[1, 1], [0, 1]], | |
| [[1, 1], [0, 0]], | |
| [[1, 1], [0, 0]], | |
| ], dtype=dtype) | |
| a_triu_observed = np.triu(a) | |
| a_tril_observed = np.tril(a) | |
| yield assert_array_equal, a_triu_observed, a_triu_desired | |
| yield assert_array_equal, a_tril_observed, a_tril_desired | |
| yield assert_equal, a_triu_observed.dtype, a.dtype | |
| yield assert_equal, a_tril_observed.dtype, a.dtype | |
| def test_tril_triu_with_inf(): | |
| # Issue 4859 | |
| arr = np.array([[1, 1, np.inf], | |
| [1, 1, 1], | |
| [np.inf, 1, 1]]) | |
| out_tril = np.array([[1, 0, 0], | |
| [1, 1, 0], | |
| [np.inf, 1, 1]]) | |
| out_triu = out_tril.T | |
| assert_array_equal(np.triu(arr), out_triu) | |
| assert_array_equal(np.tril(arr), out_tril) | |
| def test_tril_triu_dtype(): | |
| # Issue 4916 | |
| # tril and triu should return the same dtype as input | |
| for c in np.typecodes['All']: | |
| if c == 'V': | |
| continue | |
| arr = np.zeros((3, 3), dtype=c) | |
| assert_equal(np.triu(arr).dtype, arr.dtype) | |
| assert_equal(np.tril(arr).dtype, arr.dtype) | |
| # check special cases | |
| arr = np.array([['2001-01-01T12:00', '2002-02-03T13:56'], | |
| ['2004-01-01T12:00', '2003-01-03T13:45']], | |
| dtype='datetime64') | |
| assert_equal(np.triu(arr).dtype, arr.dtype) | |
| assert_equal(np.tril(arr).dtype, arr.dtype) | |
| arr = np.zeros((3,3), dtype='f4,f4') | |
| assert_equal(np.triu(arr).dtype, arr.dtype) | |
| assert_equal(np.tril(arr).dtype, arr.dtype) | |
| def test_mask_indices(): | |
| # simple test without offset | |
| iu = mask_indices(3, np.triu) | |
| a = np.arange(9).reshape(3, 3) | |
| yield (assert_array_equal, a[iu], array([0, 1, 2, 4, 5, 8])) | |
| # Now with an offset | |
| iu1 = mask_indices(3, np.triu, 1) | |
| yield (assert_array_equal, a[iu1], array([1, 2, 5])) | |
| def test_tril_indices(): | |
| # indices without and with offset | |
| il1 = tril_indices(4) | |
| il2 = tril_indices(4, k=2) | |
| il3 = tril_indices(4, m=5) | |
| il4 = tril_indices(4, k=2, m=5) | |
| a = np.array([[1, 2, 3, 4], | |
| [5, 6, 7, 8], | |
| [9, 10, 11, 12], | |
| [13, 14, 15, 16]]) | |
| b = np.arange(1, 21).reshape(4, 5) | |
| # indexing: | |
| yield (assert_array_equal, a[il1], | |
| array([1, 5, 6, 9, 10, 11, 13, 14, 15, 16])) | |
| yield (assert_array_equal, b[il3], | |
| array([1, 6, 7, 11, 12, 13, 16, 17, 18, 19])) | |
| # And for assigning values: | |
| a[il1] = -1 | |
| yield (assert_array_equal, a, | |
| array([[-1, 2, 3, 4], | |
| [-1, -1, 7, 8], | |
| [-1, -1, -1, 12], | |
| [-1, -1, -1, -1]])) | |
| b[il3] = -1 | |
| yield (assert_array_equal, b, | |
| array([[-1, 2, 3, 4, 5], | |
| [-1, -1, 8, 9, 10], | |
| [-1, -1, -1, 14, 15], | |
| [-1, -1, -1, -1, 20]])) | |
| # These cover almost the whole array (two diagonals right of the main one): | |
| a[il2] = -10 | |
| yield (assert_array_equal, a, | |
| array([[-10, -10, -10, 4], | |
| [-10, -10, -10, -10], | |
| [-10, -10, -10, -10], | |
| [-10, -10, -10, -10]])) | |
| b[il4] = -10 | |
| yield (assert_array_equal, b, | |
| array([[-10, -10, -10, 4, 5], | |
| [-10, -10, -10, -10, 10], | |
| [-10, -10, -10, -10, -10], | |
| [-10, -10, -10, -10, -10]])) | |
| class TestTriuIndices(object): | |
| def test_triu_indices(self): | |
| iu1 = triu_indices(4) | |
| iu2 = triu_indices(4, k=2) | |
| iu3 = triu_indices(4, m=5) | |
| iu4 = triu_indices(4, k=2, m=5) | |
| a = np.array([[1, 2, 3, 4], | |
| [5, 6, 7, 8], | |
| [9, 10, 11, 12], | |
| [13, 14, 15, 16]]) | |
| b = np.arange(1, 21).reshape(4, 5) | |
| # Both for indexing: | |
| yield (assert_array_equal, a[iu1], | |
| array([1, 2, 3, 4, 6, 7, 8, 11, 12, 16])) | |
| yield (assert_array_equal, b[iu3], | |
| array([1, 2, 3, 4, 5, 7, 8, 9, 10, 13, 14, 15, 19, 20])) | |
| # And for assigning values: | |
| a[iu1] = -1 | |
| yield (assert_array_equal, a, | |
| array([[-1, -1, -1, -1], | |
| [5, -1, -1, -1], | |
| [9, 10, -1, -1], | |
| [13, 14, 15, -1]])) | |
| b[iu3] = -1 | |
| yield (assert_array_equal, b, | |
| array([[-1, -1, -1, -1, -1], | |
| [6, -1, -1, -1, -1], | |
| [11, 12, -1, -1, -1], | |
| [16, 17, 18, -1, -1]])) | |
| # These cover almost the whole array (two diagonals right of the | |
| # main one): | |
| a[iu2] = -10 | |
| yield (assert_array_equal, a, | |
| array([[-1, -1, -10, -10], | |
| [5, -1, -1, -10], | |
| [9, 10, -1, -1], | |
| [13, 14, 15, -1]])) | |
| b[iu4] = -10 | |
| yield (assert_array_equal, b, | |
| array([[-1, -1, -10, -10, -10], | |
| [6, -1, -1, -10, -10], | |
| [11, 12, -1, -1, -10], | |
| [16, 17, 18, -1, -1]])) | |
| class TestTrilIndicesFrom(object): | |
| def test_exceptions(self): | |
| assert_raises(ValueError, tril_indices_from, np.ones((2,))) | |
| assert_raises(ValueError, tril_indices_from, np.ones((2, 2, 2))) | |
| # assert_raises(ValueError, tril_indices_from, np.ones((2, 3))) | |
| class TestTriuIndicesFrom(object): | |
| def test_exceptions(self): | |
| assert_raises(ValueError, triu_indices_from, np.ones((2,))) | |
| assert_raises(ValueError, triu_indices_from, np.ones((2, 2, 2))) | |
| # assert_raises(ValueError, triu_indices_from, np.ones((2, 3))) | |
| class TestVander(object): | |
| def test_basic(self): | |
| c = np.array([0, 1, -2, 3]) | |
| v = vander(c) | |
| powers = np.array([[0, 0, 0, 0, 1], | |
| [1, 1, 1, 1, 1], | |
| [16, -8, 4, -2, 1], | |
| [81, 27, 9, 3, 1]]) | |
| # Check default value of N: | |
| yield (assert_array_equal, v, powers[:, 1:]) | |
| # Check a range of N values, including 0 and 5 (greater than default) | |
| m = powers.shape[1] | |
| for n in range(6): | |
| v = vander(c, N=n) | |
| yield (assert_array_equal, v, powers[:, m-n:m]) | |
| def test_dtypes(self): | |
| c = array([11, -12, 13], dtype=np.int8) | |
| v = vander(c) | |
| expected = np.array([[121, 11, 1], | |
| [144, -12, 1], | |
| [169, 13, 1]]) | |
| yield (assert_array_equal, v, expected) | |
| c = array([1.0+1j, 1.0-1j]) | |
| v = vander(c, N=3) | |
| expected = np.array([[2j, 1+1j, 1], | |
| [-2j, 1-1j, 1]]) | |
| # The data is floating point, but the values are small integers, | |
| # so assert_array_equal *should* be safe here (rather than, say, | |
| # assert_array_almost_equal). | |
| yield (assert_array_equal, v, expected) | |
| if __name__ == "__main__": | |
| run_module_suite() | |