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)
