def test_vector(self): """test vectorized LU decomposition""" a = np.ascontiguousarray(np.random.randn(10, 75, 50)) p, l, u = gulinalg.lu(a) res = np.stack([np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector(self): """test vectorized LU decomposition""" a = np.ascontiguousarray(np.random.randn(10, 75, 50)) p, l, u = gulinalg.lu(a) res = np.stack( [np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector_size_one_matrix(self): """Corner case of decomposing size 1 matrix""" a = np.ascontiguousarray(np.random.randn(10, 1, 1)) p, l, u = gulinalg.lu(a) res = np.stack([np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector_size_one_matrix(self): """Corner case of decomposing size 1 matrix""" a = np.ascontiguousarray(np.random.randn(10, 1, 1)) p, l, u = gulinalg.lu(a) res = np.stack( [np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector_permute_l(self): """test vectorized LU decomposition""" a = np.ascontiguousarray(np.random.randn(10, 75, 50)) for workers in [1, -1]: pl, u = gulinalg.lu(a, permute_l=True, workers=workers) res = np.stack([np.dot(pl[i], u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_lu_n_zero(self): """Corner case of decomposing where n = 0""" a = np.ascontiguousarray(np.random.randn(2, 0)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As N = 0 here, assert following dimensions. assert p.shape == (2, 2) assert l.shape == (2, 0) assert u.shape == (0, 0) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_m_zero(self): """Corner case of decomposing where m = 0""" a = np.ascontiguousarray(np.random.randn(0, 2)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As M = 0 here, all three of them should be empty. assert p.shape == (0, 0) assert l.shape == (0, 0) assert u.shape == (0, 2) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_m_zero(self): """Corner case of decomposing where m = 0""" a = np.ascontiguousarray(np.random.randn(0, 2)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As M = 0 here, all three of them should be empty. assert p.shape == (0, 0) assert l.shape == (0, 0) assert u.shape == (0, 2) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_n_zero(self): """Corner case of decomposing where n = 0""" a = np.ascontiguousarray(np.random.randn(2, 0)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As N = 0 here, assert following dimensions. assert p.shape == (2, 2) assert l.shape == (2, 0) assert u.shape == (0, 0) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_infinity_handling(self): """Infinity in one output shouldn't contaminate remaining outputs""" a = np.array([[[3, 4, 5], [2, np.inf, 3]], [[3, 4, 5], [2, 1, 3]]]) pl, u = gulinalg.lu(a, permute_l=True) ref_pl = np.array([[[1., 0.], [0.66666667, 1.]], [[1., 0.], [0.66666667, 1.]]]) ref_u = np.array([[[3., 4., 5.], [0., np.inf, -0.33333333]], [[3., 4., 5.], [0., -1.66666667, -0.33333333]]]) assert_allclose(pl, ref_pl) assert_allclose(u, ref_u)
def test_infinity_handling(self): """Infinity in one output shouldn't contaminate remaining outputs""" a = np.array([[[3, 4, 5], [2, np.inf, 3]], [[3, 4, 5], [2, 1, 3]]]) pl, u = gulinalg.lu(a, permute_l=True) ref_pl = np.array([[[1., 0.], [0.66666667, 1.]], [[1., 0.], [0.66666667, 1.]]]) ref_u = np.array([[[3., 4., 5.], [0., np.inf, -0.33333333]], [[3., 4., 5.], [0., -1.66666667, -0.33333333]]]) assert_allclose(pl, ref_pl) assert_allclose(u, ref_u)
def test_vector_n_zero(self): """Corner case of decomposing where n = 0""" a = np.ascontiguousarray(np.random.randn(10, 2, 0)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As N = 0 here, assert following dimensions. assert p.shape == (10, 2, 2) assert l.shape == (10, 2, 0) assert u.shape == (10, 0, 0) res = np.stack( [np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector_m_zero(self): """Corner case of decomposing where m = 0""" a = np.ascontiguousarray(np.random.randn(10, 0, 2)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As M = 0 here, all three of them should be empty. assert p.shape == (10, 0, 0) assert l.shape == (10, 0, 0) assert u.shape == (10, 0, 2) res = np.stack([np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector_m_zero(self): """Corner case of decomposing where m = 0""" a = np.ascontiguousarray(np.random.randn(10, 0, 2)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As M = 0 here, all three of them should be empty. assert p.shape == (10, 0, 0) assert l.shape == (10, 0, 0) assert u.shape == (10, 0, 2) res = np.stack( [np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_vector_n_zero(self): """Corner case of decomposing where n = 0""" a = np.ascontiguousarray(np.random.randn(10, 2, 0)) p, l, u = gulinalg.lu(a) # p is MxM, l is MxK, u is KxN where K = min(M, N) # As N = 0 here, assert following dimensions. assert p.shape == (10, 2, 2) assert l.shape == (10, 2, 0) assert u.shape == (10, 0, 0) res = np.stack([np.dot(np.dot(p[i], l[i]), u[i]) for i in range(len(a))]) assert_allclose(res, a)
def test_lu_m_gt_n(self): """LU decompose a matrix where dimension m > n""" a = np.ascontiguousarray(np.random.randn(75, 50)) p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_m_gt_n(self): """LU decompose a matrix where dimension m > n""" a = np.ascontiguousarray(np.random.randn(75, 50)) p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_input_matrix_non_contiguous(self): """Input matrix is not a contiguous matrix""" a = np.ascontiguousarray(np.random.randn(50, 75, 2))[:, :, 0] assert not a.flags.c_contiguous and not a.flags.f_contiguous p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_size_one_matrix(self): """Corner case of decomposing size 1 matrix""" a = np.ascontiguousarray(np.random.randn(1, 1)) p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_permute_m_lt_n(self): """LU decompose a matrix where dimension m < n""" a = np.ascontiguousarray(np.random.randn(50, 75)) pl, u = gulinalg.lu(a, permute_l=True) assert_allclose(np.dot(pl, u), a)
def test_lu_permute_size_1_matrix(self): a = np.ascontiguousarray(np.random.randn(1, 1)) pl, u = gulinalg.lu(a, permute_l=True) assert_allclose(np.dot(pl, u), a)
def test_lu_size_one_matrix(self): """Corner case of decomposing size 1 matrix""" a = np.ascontiguousarray(np.random.randn(1, 1)) p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_lu_permute_size_1_matrix(self): a = np.ascontiguousarray(np.random.randn(1, 1)) pl, u = gulinalg.lu(a, permute_l=True) assert_allclose(np.dot(pl, u), a)
def test_complex_numbers(self): """Test for complex numbers input.""" a = np.array([[1 + 2j, 3 + 4j], [5 + 6j, 7 + -8j]]) p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_fortran_layout_matrix(self): """Input matrix is fortran layout matrix""" a = np.asfortranarray(np.random.randn(75, 50)) pl, u = gulinalg.lu(a, permute_l=True) assert_allclose(np.dot(pl, u), a)
def test_lu_permute_m_lt_n(self): """LU decompose a matrix where dimension m < n""" a = np.ascontiguousarray(np.random.randn(50, 75)) pl, u = gulinalg.lu(a, permute_l=True) assert_allclose(np.dot(pl, u), a)
def test_fortran_layout_matrix(self): """Input matrix is fortran layout matrix""" a = np.asfortranarray(np.random.randn(75, 50)) pl, u = gulinalg.lu(a, permute_l=True) assert_allclose(np.dot(pl, u), a)
def test_complex_numbers(self): """Test for complex numbers input.""" a = np.array([[1 + 2j, 3 + 4j], [5 + 6j, 7 + -8j]]) p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)
def test_input_matrix_non_contiguous(self): """Input matrix is not a contiguous matrix""" a = np.ascontiguousarray(np.random.randn(50, 75, 2))[:, :, 0] assert not a.flags.c_contiguous and not a.flags.f_contiguous p, l, u = gulinalg.lu(a) assert_allclose(np.dot(np.dot(p, l), u), a)