def test_block_diag_1(self): """ block_diag with one matrix """ assert_equal( construct.block_diag([[1, 0]]).todense(), matrix([[1, 0]])) assert_equal( construct.block_diag([[[1, 0]]]).todense(), matrix([[1, 0]])) assert_equal( construct.block_diag([[[1], [0]]]).todense(), matrix([[1], [0]])) # just on scalar assert_equal(construct.block_diag([1]).todense(), matrix([[1]]))
def test_block_diag_1(self): """ block_diag with one matrix """ assert_equal(construct.block_diag([[1, 0]]).todense(), matrix([[1, 0]])) assert_equal(construct.block_diag([[[1, 0]]]).todense(), matrix([[1, 0]])) assert_equal(construct.block_diag([[[1], [0]]]).todense(), matrix([[1], [0]])) # just on scalar assert_equal(construct.block_diag([1]).todense(), matrix([[1]]))
def test_misc_types(self): A = expm(np.array([[1]])) assert_allclose(expm(((1, ), )), A) assert_allclose(expm([[1]]), A) assert_allclose(expm(matrix([[1]])), A) assert_allclose(expm(np.array([[1]])), A) assert_allclose(expm(csc_matrix([[1]])).A, A) B = expm(np.array([[1j]])) assert_allclose(expm(((1j, ), )), B) assert_allclose(expm([[1j]]), B) assert_allclose(expm(matrix([[1j]])), B) assert_allclose(expm(csc_matrix([[1j]])).A, B)
def test_misc_types(self): A = expm(np.array([[1]])) assert_allclose(expm(((1,),)), A) assert_allclose(expm([[1]]), A) assert_allclose(expm(matrix([[1]])), A) assert_allclose(expm(np.array([[1]])), A) assert_allclose(expm(csc_matrix([[1]])).A, A) B = expm(np.array([[1j]])) assert_allclose(expm(((1j,),)), B) assert_allclose(expm([[1j]]), B) assert_allclose(expm(matrix([[1j]])), B) assert_allclose(expm(csc_matrix([[1j]])).A, B)
def test_orthogonal_procrustes_array_conversion(): np.random.seed(1234) for m, n in ((6, 4), (4, 4), (4, 6)): A_arr = np.random.randn(m, n) B_arr = np.random.randn(m, n) As = (A_arr, A_arr.tolist(), matrix(A_arr)) Bs = (B_arr, B_arr.tolist(), matrix(B_arr)) R_arr, s = orthogonal_procrustes(A_arr, B_arr) AR_arr = A_arr.dot(R_arr) for A, B in product(As, Bs): R, s = orthogonal_procrustes(A, B) AR = A_arr.dot(R) assert_allclose(AR, AR_arr)
def test_orthogonal_procrustes_array_conversion(): np.random.seed(1234) for m, n in ((6, 4), (4, 4), (4, 6)): A_arr = np.random.randn(m, n) B_arr = np.random.randn(m, n) As = (A_arr, A_arr.tolist(), matrix(A_arr)) Bs = (B_arr, B_arr.tolist(), matrix(B_arr)) R_arr, s = orthogonal_procrustes(A_arr, B_arr) AR_arr = A_arr.dot(R_arr) for A, B in product(As, Bs): R, s = orthogonal_procrustes(A, B) AR = A_arr.dot(R) assert_allclose(AR, AR_arr)
def test_double_integrator(self): # double integrator: y'' = 2u A = matrix("0. 1.; 0. 0.") B = matrix("0.; 1.") C = matrix("2. 0.") system = self.lti_nowarn(A, B, C, 0.) t = np.linspace(0, 5) u = np.ones_like(t) tout, y, x = lsim(system, u, t) expected_x = np.transpose(np.array([0.5 * tout**2, tout])) expected_y = tout**2 assert_almost_equal(x, expected_x) assert_almost_equal(y, expected_y)
def test_double_integrator(self): # double integrator: y'' = 2u A = matrix("0. 1.; 0. 0.") B = matrix("0.; 1.") C = matrix("2. 0.") system = self.lti_nowarn(A, B, C, 0.) t = np.linspace(0,5) u = np.ones_like(t) tout, y, x = lsim(system, u, t) expected_x = np.transpose(np.array([0.5 * tout**2, tout])) expected_y = tout**2 assert_almost_equal(x, expected_x) assert_almost_equal(y, expected_y)
def test_matrix(self): a = [[1, 2, 3]] b = np.array(a) assert isinstance(sputils.matrix(a), np.matrix) assert isinstance(sputils.matrix(b), np.matrix) c = sputils.matrix(b) c[:, :] = 123 assert_equal(b, a) c = sputils.matrix(b, copy=False) c[:, :] = 123 assert_equal(b, [[123, 123, 123]])
def test_block_diag_sparse_matrices(self): """ block_diag with sparse matrices """ sparse_col_matrices = [coo_matrix(([[1, 2, 3]]), shape=(1, 3)), coo_matrix(([[4, 5]]), shape=(1, 2))] block_sparse_cols_matrices = construct.block_diag(sparse_col_matrices) assert_equal(block_sparse_cols_matrices.todense(), matrix([[1, 2, 3, 0, 0], [0, 0, 0, 4, 5]])) sparse_row_matrices = [coo_matrix(([[1], [2], [3]]), shape=(3, 1)), coo_matrix(([[4], [5]]), shape=(2, 1))] block_sparse_row_matrices = construct.block_diag(sparse_row_matrices) assert_equal(block_sparse_row_matrices.todense(), matrix([[1, 0], [2, 0], [3, 0], [0, 4], [0, 5]]))
def test_jordan_block(self): # Non-diagonalizable A matrix # x1' + x1 = x2 # x2' + x2 = u # y = x1 # Exact solution with u = 0 is y(t) = t exp(-t) A = matrix("-1. 1.; 0. -1.") B = matrix("0.; 1.") C = matrix("1. 0.") system = self.lti_nowarn(A, B, C, 0.) t = np.linspace(0, 5) u = np.zeros_like(t) tout, y, x = lsim(system, u, t, X0=[0.0, 1.0]) expected_y = tout * np.exp(-tout) assert_almost_equal(y, expected_y)
def test_jordan_block(self): # Non-diagonalizable A matrix # x1' + x1 = x2 # x2' + x2 = u # y = x1 # Exact solution with u = 0 is y(t) = t exp(-t) A = matrix("-1. 1.; 0. -1.") B = matrix("0.; 1.") C = matrix("1. 0.") system = self.lti_nowarn(A, B, C, 0.) t = np.linspace(0,5) u = np.zeros_like(t) tout, y, x = lsim(system, u, t, X0=[0.0, 1.0]) expected_y = tout * np.exp(-tout) assert_almost_equal(y, expected_y)
def test_linear_sum_assignment_input_validation(): # Since the input should be a 2D array. assert_raises(ValueError, lap.solve, [1, 2, 3]) cost_matrix = [[1, 2, 3], [4, 5, 6]] assert_array_equal(lap.solve(cost_matrix), lap.solve(np.asarray(cost_matrix))) assert_array_equal(lap.solve(cost_matrix), lap.solve(matrix(cost_matrix))) eye = np.identity(3) assert_array_equal(lap.solve(eye.astype(np.bool)), lap.solve(eye)) assert_raises(ValueError, lap.solve, eye.astype(str)) eye[0][0] = np.nan assert_raises(ValueError, lap.solve, eye) eye = np.identity(3) eye[1][1] = -np.inf assert_raises(ValueError, lap.solve, eye) eye = np.identity(3) eye[:, 0] = np.inf assert_raises(ValueError, lap.solve, eye) # Note that solve requires that num_rows cannot exceed num_cols cost_matrix = np.array([[0 , np.inf, np.inf], [np.inf, 0, np.inf], [np.inf, np.inf, 0], [0 , 0, 0]]) assert_raises(ValueError, laptools._solve, cost_matrix)
def test_linear_sum_assignment_input_validation(): assert_raises(ValueError, linear_sum_assignment, [1, 2, 3]) C = [[1, 2, 3], [4, 5, 6]] assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(np.asarray(C))) assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(matrix(C))) I = np.identity(3) assert_array_equal(linear_sum_assignment(I.astype(np.bool_)), linear_sum_assignment(I)) assert_raises(ValueError, linear_sum_assignment, I.astype(str)) I[0][0] = np.nan with pytest.raises(ValueError, match="contains invalid numeric entries"): linear_sum_assignment(I) I = np.identity(3) I[1][1] = -np.inf with pytest.raises(ValueError, match="contains invalid numeric entries"): linear_sum_assignment(I) I = np.identity(3) I[:, 0] = np.inf with pytest.raises(ValueError, match="cost matrix is infeasible"): linear_sum_assignment(I)
def _divide_sparse(self, other): """ Divide this matrix by a second sparse matrix. """ if other.shape != self.shape: raise ValueError('inconsistent shapes') r = self._binopt(other, '_eldiv_') if np.issubdtype(r.dtype, np.inexact): # Eldiv leaves entries outside the combined sparsity # pattern empty, so they must be filled manually. # Everything outside of other's sparsity is NaN, and everything # inside it is either zero or defined by eldiv. out = np.empty(self.shape, dtype=self.dtype) out.fill(np.nan) row, col = other.nonzero() out[row, col] = 0 r = r.tocoo() out[r.row, r.col] = r.data out = matrix(out) else: # integers types go with nan <-> 0 out = r return out
def test_linear_sum_assignment_input_validation(): assert_raises(ValueError, linear_sum_assignment, [1, 2, 3]) C = [[1, 2, 3], [4, 5, 6]] assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(np.asarray(C))) assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(matrix(C))) I = np.identity(3) assert_array_equal(linear_sum_assignment(I.astype(np.bool)), linear_sum_assignment(I)) assert_raises(ValueError, linear_sum_assignment, I.astype(str)) I[0][0] = np.nan assert_raises(ValueError, linear_sum_assignment, I) I = np.identity(3) I[1][1] = -np.inf assert_raises(ValueError, linear_sum_assignment, I) I = np.identity(3) I[:, 0] = np.inf assert_raises(ValueError, linear_sum_assignment, I)
def test_minimize_tnc1b(self): x0, bnds = matrix([-2, 1]), ([-np.inf, None], [-1.5, None]) xopt = [1, 1] x = optimize.minimize(self.f1, x0, method='TNC', bounds=bnds, options=self.opts).x assert_allclose(self.f1(x), self.f1(xopt), atol=1e-4)
def test_regression_std_vector_dtypes(): # Regression test for gh-3780, checking the std::vector typemaps # in sparsetools.cxx are complete. for dtype in supported_dtypes: ad = matrix([[1, 2], [3, 4]]).astype(dtype) a = csr_matrix(ad, dtype=dtype) # getcol is one function using std::vector typemaps, and should not fail assert_equal(a.getcol(0).todense(), ad[:, 0])
def make_cases(original, dtype): cases = [] cases.append((matrix(original, dtype=dtype), original)) cases.append((np.array(original, dtype=dtype), original)) cases.append((sparse.csr_matrix(original, dtype=dtype), original)) # Test default implementations of _adjoint and _rmatvec, which # refer to each other. def mv(x, dtype): y = original.dot(x) if len(x.shape) == 2: y = y.reshape(-1, 1) return y def rmv(x, dtype): return original.T.conj().dot(x) class BaseMatlike(interface.LinearOperator): args = () def __init__(self, dtype): self.dtype = np.dtype(dtype) self.shape = original.shape def _matvec(self, x): return mv(x, self.dtype) class HasRmatvec(BaseMatlike): args = () def _rmatvec(self, x): return rmv(x, self.dtype) class HasAdjoint(BaseMatlike): args = () def _adjoint(self): shape = self.shape[1], self.shape[0] matvec = partial(rmv, dtype=self.dtype) rmatvec = partial(mv, dtype=self.dtype) return interface.LinearOperator(matvec=matvec, rmatvec=rmatvec, dtype=self.dtype, shape=shape) class HasRmatmat(HasRmatvec): def _matmat(self, x): return original.dot(x) def _rmatmat(self, x): return original.T.conj().dot(x) cases.append((HasRmatvec(dtype), original)) cases.append((HasAdjoint(dtype), original)) cases.append((HasRmatmat(dtype), original)) return cases
def _add_dense(self, other): if other.shape != self.shape: raise ValueError('Incompatible shapes.') dtype = upcast_char(self.dtype.char, other.dtype.char) order = self._swap('CF')[0] result = np.array(other, dtype=dtype, order=order, copy=True) M, N = self._swap(self.shape) y = result if result.flags.c_contiguous else result.T csr_todense(M, N, self.indptr, self.indices, self.data, y) return matrix(result, copy=False)
def test_block_diag_basic(self): """ basic test for block_diag """ A = coo_matrix([[1, 2], [3, 4]]) B = coo_matrix([[5], [6]]) C = coo_matrix([[7]]) expected = matrix([[1, 2, 0, 0], [3, 4, 0, 0], [0, 0, 5, 0], [0, 0, 6, 0], [0, 0, 0, 7]]) assert_equal(construct.block_diag((A, B, C)).todense(), expected)
def test_block_diag_basic(self): """ basic test for block_diag """ A = coo_matrix([[1,2],[3,4]]) B = coo_matrix([[5],[6]]) C = coo_matrix([[7]]) expected = matrix([[1, 2, 0, 0], [3, 4, 0, 0], [0, 0, 5, 0], [0, 0, 6, 0], [0, 0, 0, 7]]) assert_equal(construct.block_diag((A, B, C)).todense(), expected)
def test_hstack(self): A = coo_matrix([[1,2],[3,4]]) B = coo_matrix([[5],[6]]) expected = matrix([[1, 2, 5], [3, 4, 6]]) assert_equal(construct.hstack([A,B]).todense(), expected) assert_equal(construct.hstack([A,B], dtype=np.float32).dtype, np.float32) assert_equal(construct.hstack([A.tocsc(),B.tocsc()]).todense(), expected) assert_equal(construct.hstack([A.tocsc(),B.tocsc()], dtype=np.float32).dtype, np.float32)
def test_bmat(self): A = coo_matrix([[1,2],[3,4]]) B = coo_matrix([[5],[6]]) C = coo_matrix([[7]]) D = coo_matrix((0,0)) expected = matrix([[1, 2, 5], [3, 4, 6], [0, 0, 7]]) assert_equal(construct.bmat([[A,B],[None,C]]).todense(), expected) expected = matrix([[1, 2, 0], [3, 4, 0], [0, 0, 7]]) assert_equal(construct.bmat([[A,None],[None,C]]).todense(), expected) expected = matrix([[0, 5], [0, 6], [7, 0]]) assert_equal(construct.bmat([[None,B],[C,None]]).todense(), expected) expected = matrix(np.empty((0,0))) assert_equal(construct.bmat([[None,None]]).todense(), expected) assert_equal(construct.bmat([[None,D],[D,None]]).todense(), expected) # test bug reported in gh-5976 expected = matrix([[7]]) assert_equal(construct.bmat([[None,D],[C,None]]).todense(), expected) # test failure cases with assert_raises(ValueError) as excinfo: construct.bmat([[A], [B]]) excinfo.match(r'Got blocks\[1,0\]\.shape\[1\] == 1, expected 2') with assert_raises(ValueError) as excinfo: construct.bmat([[A, C]]) excinfo.match(r'Got blocks\[0,1\]\.shape\[0\] == 1, expected 2')
def test_vstack(self): A = coo_matrix([[1,2],[3,4]]) B = coo_matrix([[5,6]]) expected = matrix([[1, 2], [3, 4], [5, 6]]) assert_equal(construct.vstack([A,B]).todense(), expected) assert_equal(construct.vstack([A,B], dtype=np.float32).dtype, np.float32) assert_equal(construct.vstack([A.tocsr(),B.tocsr()]).todense(), expected) assert_equal(construct.vstack([A.tocsr(),B.tocsr()], dtype=np.float32).dtype, np.float32) assert_equal(construct.vstack([A.tocsr(),B.tocsr()], dtype=np.float32).indices.dtype, np.int32) assert_equal(construct.vstack([A.tocsr(),B.tocsr()], dtype=np.float32).indptr.dtype, np.int32)
def make_cases(dtype): self.cases.append(matrix([[1,2,3],[4,5,6]], dtype=dtype)) self.cases.append(np.array([[1,2,3],[4,5,6]], dtype=dtype)) self.cases.append(sparse.csr_matrix([[1,2,3],[4,5,6]], dtype=dtype)) # Test default implementations of _adjoint and _rmatvec, which # refer to each other. def mv(x, dtype): y = np.array([1 * x[0] + 2 * x[1] + 3 * x[2], 4 * x[0] + 5 * x[1] + 6 * x[2]], dtype=dtype) if len(x.shape) == 2: y = y.reshape(-1, 1) return y def rmv(x, dtype): return np.array([1 * x[0] + 4 * x[1], 2 * x[0] + 5 * x[1], 3 * x[0] + 6 * x[1]], dtype=dtype) class BaseMatlike(interface.LinearOperator): def __init__(self, dtype): self.dtype = np.dtype(dtype) self.shape = (2,3) def _matvec(self, x): return mv(x, self.dtype) class HasRmatvec(BaseMatlike): def _rmatvec(self,x): return rmv(x, self.dtype) class HasAdjoint(BaseMatlike): def _adjoint(self): shape = self.shape[1], self.shape[0] matvec = partial(rmv, dtype=self.dtype) rmatvec = partial(mv, dtype=self.dtype) return interface.LinearOperator(matvec=matvec, rmatvec=rmatvec, dtype=self.dtype, shape=shape) self.cases.append(HasRmatvec(dtype)) self.cases.append(HasAdjoint(dtype))
def test_linear_sum_assignment_input_validation(): assert_raises(ValueError, linear_sum_assignment, [1, 2, 3]) C = [[1, 2, 3], [4, 5, 6]] assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(np.asarray(C))) assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(matrix(C))) I = np.identity(3) assert_array_equal(linear_sum_assignment(I.astype(np.bool)), linear_sum_assignment(I)) assert_raises(ValueError, linear_sum_assignment, I.astype(str)) I[0][0] = np.nan assert_raises(ValueError, linear_sum_assignment, I) I = np.identity(3) I[1][1] = np.inf assert_raises(ValueError, linear_sum_assignment, I)
def test_scale_rows_and_cols(self): D = matrix([[1,0,0,2,3], [0,4,0,5,0], [0,0,6,7,0]]) #TODO expose through function S = csr_matrix(D) v = array([1,2,3]) csr_scale_rows(3,5,S.indptr,S.indices,S.data,v) assert_equal(S.todense(), diag(v)*D) S = csr_matrix(D) v = array([1,2,3,4,5]) csr_scale_columns(3,5,S.indptr,S.indices,S.data,v) assert_equal(S.todense(), D@diag(v)) # blocks E = kron(D,[[1,2],[3,4]]) S = bsr_matrix(E,blocksize=(2,2)) v = array([1,2,3,4,5,6]) bsr_scale_rows(3,5,2,2,S.indptr,S.indices,S.data,v) assert_equal(S.todense(), diag(v)@E) S = bsr_matrix(E,blocksize=(2,2)) v = array([1,2,3,4,5,6,7,8,9,10]) bsr_scale_columns(3,5,2,2,S.indptr,S.indices,S.data,v) assert_equal(S.todense(), E@diag(v)) E = kron(D,[[1,2,3],[4,5,6]]) S = bsr_matrix(E,blocksize=(2,3)) v = array([1,2,3,4,5,6]) bsr_scale_rows(3,5,2,3,S.indptr,S.indices,S.data,v) assert_equal(S.todense(), diag(v)@E) S = bsr_matrix(E,blocksize=(2,3)) v = array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]) bsr_scale_columns(3,5,2,3,S.indptr,S.indices,S.data,v) assert_equal(S.todense(), E@diag(v))
def test_scale_rows_and_cols(self): D = matrix([[1, 0, 0, 2, 3], [0, 4, 0, 5, 0], [0, 0, 6, 7, 0]]) #TODO expose through function S = csr_matrix(D) v = array([1, 2, 3]) csr_scale_rows(3, 5, S.indptr, S.indices, S.data, v) assert_equal(S.todense(), diag(v) * D) S = csr_matrix(D) v = array([1, 2, 3, 4, 5]) csr_scale_columns(3, 5, S.indptr, S.indices, S.data, v) assert_equal(S.todense(), D @ diag(v)) # blocks E = kron(D, [[1, 2], [3, 4]]) S = bsr_matrix(E, blocksize=(2, 2)) v = array([1, 2, 3, 4, 5, 6]) bsr_scale_rows(3, 5, 2, 2, S.indptr, S.indices, S.data, v) assert_equal(S.todense(), diag(v) @ E) S = bsr_matrix(E, blocksize=(2, 2)) v = array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) bsr_scale_columns(3, 5, 2, 2, S.indptr, S.indices, S.data, v) assert_equal(S.todense(), E @ diag(v)) E = kron(D, [[1, 2, 3], [4, 5, 6]]) S = bsr_matrix(E, blocksize=(2, 3)) v = array([1, 2, 3, 4, 5, 6]) bsr_scale_rows(3, 5, 2, 3, S.indptr, S.indices, S.data, v) assert_equal(S.todense(), diag(v) @ E) S = bsr_matrix(E, blocksize=(2, 3)) v = array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) bsr_scale_columns(3, 5, 2, 3, S.indptr, S.indices, S.data, v) assert_equal(S.todense(), E @ diag(v))
def test_bmat(self): A = coo_matrix([[1, 2], [3, 4]]) B = coo_matrix([[5], [6]]) C = coo_matrix([[7]]) D = coo_matrix((0, 0)) expected = array([[1, 2, 5], [3, 4, 6], [0, 0, 7]]) assert_equal(construct.bmat([[A, B], [None, C]]).toarray(), expected) E = csr_matrix((1, 2), dtype=np.int32) assert_equal( construct.bmat([[A.tocsr(), B.tocsr()], [E, C.tocsr()]]).toarray(), expected) assert_equal( construct.bmat([[A.tocsc(), B.tocsc()], [E.tocsc(), C.tocsc()]]).toarray(), expected) expected = array([[1, 2, 0], [3, 4, 0], [0, 0, 7]]) assert_equal( construct.bmat([[A, None], [None, C]]).toarray(), expected) assert_equal( construct.bmat([[A.tocsr(), E.T.tocsr()], [E, C.tocsr()]]).toarray(), expected) assert_equal( construct.bmat([[A.tocsc(), E.T.tocsc()], [E.tocsc(), C.tocsc()]]).toarray(), expected) Z = csr_matrix((1, 1), dtype=np.int32) expected = array([[0, 5], [0, 6], [7, 0]]) assert_equal( construct.bmat([[None, B], [C, None]]).toarray(), expected) assert_equal( construct.bmat([[E.T.tocsr(), B.tocsr()], [C.tocsr(), Z]]).toarray(), expected) assert_equal( construct.bmat([[E.T.tocsc(), B.tocsc()], [C.tocsc(), Z.tocsc()]]).toarray(), expected) expected = matrix(np.empty((0, 0))) assert_equal(construct.bmat([[None, None]]).toarray(), expected) assert_equal( construct.bmat([[None, D], [D, None]]).toarray(), expected) # test bug reported in gh-5976 expected = array([[7]]) assert_equal( construct.bmat([[None, D], [C, None]]).toarray(), expected) # test failure cases with assert_raises(ValueError) as excinfo: construct.bmat([[A], [B]]) excinfo.match(r'Got blocks\[1,0\]\.shape\[1\] == 1, expected 2') with assert_raises(ValueError) as excinfo: construct.bmat([[A.tocsr()], [B.tocsr()]]) excinfo.match(r'incompatible dimensions for axis 1') with assert_raises(ValueError) as excinfo: construct.bmat([[A.tocsc()], [B.tocsc()]]) excinfo.match(r'Mismatching dimensions along axis 1: {1, 2}') with assert_raises(ValueError) as excinfo: construct.bmat([[A, C]]) excinfo.match(r'Got blocks\[0,1\]\.shape\[0\] == 1, expected 2') with assert_raises(ValueError) as excinfo: construct.bmat([[A.tocsr(), C.tocsr()]]) excinfo.match(r'Mismatching dimensions along axis 0: {1, 2}') with assert_raises(ValueError) as excinfo: construct.bmat([[A.tocsc(), C.tocsc()]]) excinfo.match(r'incompatible dimensions for axis 0')
def test_linear_sum_assignment_input_object(): C = [[1, 2, 3], [4, 5, 6]] assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(np.asarray(C))) assert_array_equal(linear_sum_assignment(C), linear_sum_assignment(matrix(C)))
def test_isdense(self): assert_equal(sputils.isdense(np.array([1])), True) assert_equal(sputils.isdense(matrix([1])), True)
def test_matvec(self): def get_matvecs(A): return [{ 'shape': A.shape, 'matvec': lambda x: np.dot(A, x).reshape(A.shape[0]), 'rmatvec': lambda x: np.dot(A.T.conj(), x).reshape(A.shape[1]) }, { 'shape': A.shape, 'matvec': lambda x: np.dot(A, x), 'rmatvec': lambda x: np.dot(A.T.conj(), x), 'matmat': lambda x: np.dot(A, x) }] for matvecs in get_matvecs(self.A): A = interface.LinearOperator(**matvecs) assert_(A.args == ()) assert_equal(A.matvec(np.array([1,2,3])), [14,32]) assert_equal(A.matvec(np.array([[1],[2],[3]])), [[14],[32]]) assert_equal(A * np.array([1,2,3]), [14,32]) assert_equal(A * np.array([[1],[2],[3]]), [[14],[32]]) assert_equal(A.dot(np.array([1,2,3])), [14,32]) assert_equal(A.dot(np.array([[1],[2],[3]])), [[14],[32]]) assert_equal(A.matvec(matrix([[1],[2],[3]])), [[14],[32]]) assert_equal(A * matrix([[1],[2],[3]]), [[14],[32]]) assert_equal(A.dot(matrix([[1],[2],[3]])), [[14],[32]]) assert_equal((2*A)*[1,1,1], [12,30]) assert_equal((2*A).rmatvec([1,1]), [10, 14, 18]) assert_equal((2*A).H.matvec([1,1]), [10, 14, 18]) assert_equal((2*A)*[[1],[1],[1]], [[12],[30]]) assert_equal((2*A).matmat([[1],[1],[1]]), [[12],[30]]) assert_equal((A*2)*[1,1,1], [12,30]) assert_equal((A*2)*[[1],[1],[1]], [[12],[30]]) assert_equal((2j*A)*[1,1,1], [12j,30j]) assert_equal((A+A)*[1,1,1], [12, 30]) assert_equal((A+A).rmatvec([1,1]), [10, 14, 18]) assert_equal((A+A).H.matvec([1,1]), [10, 14, 18]) assert_equal((A+A)*[[1],[1],[1]], [[12], [30]]) assert_equal((A+A).matmat([[1],[1],[1]]), [[12], [30]]) assert_equal((-A)*[1,1,1], [-6,-15]) assert_equal((-A)*[[1],[1],[1]], [[-6],[-15]]) assert_equal((A-A)*[1,1,1], [0,0]) assert_equal((A-A)*[[1],[1],[1]], [[0],[0]]) z = A+A assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] is A) z = 2*A assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] == 2) assert_(isinstance(A.matvec([1, 2, 3]), np.ndarray)) assert_(isinstance(A.matvec(np.array([[1],[2],[3]])), np.ndarray)) assert_(isinstance(A * np.array([1,2,3]), np.ndarray)) assert_(isinstance(A * np.array([[1],[2],[3]]), np.ndarray)) assert_(isinstance(A.dot(np.array([1,2,3])), np.ndarray)) assert_(isinstance(A.dot(np.array([[1],[2],[3]])), np.ndarray)) assert_(isinstance(A.matvec(matrix([[1],[2],[3]])), np.ndarray)) assert_(isinstance(A * matrix([[1],[2],[3]]), np.ndarray)) assert_(isinstance(A.dot(matrix([[1],[2],[3]])), np.ndarray)) assert_(isinstance(2*A, interface._ScaledLinearOperator)) assert_(isinstance(2j*A, interface._ScaledLinearOperator)) assert_(isinstance(A+A, interface._SumLinearOperator)) assert_(isinstance(-A, interface._ScaledLinearOperator)) assert_(isinstance(A-A, interface._SumLinearOperator)) assert_((2j*A).dtype == np.complex_) assert_raises(ValueError, A.matvec, np.array([1,2])) assert_raises(ValueError, A.matvec, np.array([1,2,3,4])) assert_raises(ValueError, A.matvec, np.array([[1],[2]])) assert_raises(ValueError, A.matvec, np.array([[1],[2],[3],[4]])) assert_raises(ValueError, lambda: A*A) assert_raises(ValueError, lambda: A**2) for matvecsA, matvecsB in product(get_matvecs(self.A), get_matvecs(self.B)): A = interface.LinearOperator(**matvecsA) B = interface.LinearOperator(**matvecsB) assert_equal((A*B)*[1,1], [50,113]) assert_equal((A*B)*[[1],[1]], [[50],[113]]) assert_equal((A*B).matmat([[1],[1]]), [[50],[113]]) assert_equal((A*B).rmatvec([1,1]), [71,92]) assert_equal((A*B).H.matvec([1,1]), [71,92]) assert_(isinstance(A*B, interface._ProductLinearOperator)) assert_raises(ValueError, lambda: A+B) assert_raises(ValueError, lambda: A**2) z = A*B assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] is B) for matvecsC in get_matvecs(self.C): C = interface.LinearOperator(**matvecsC) assert_equal((C**2)*[1,1], [17,37]) assert_equal((C**2).rmatvec([1,1]), [22,32]) assert_equal((C**2).H.matvec([1,1]), [22,32]) assert_equal((C**2).matmat([[1],[1]]), [[17],[37]]) assert_(isinstance(C**2, interface._PowerLinearOperator))
def test_zero_matrix(self): a = matrix([[0., 0], [0, 0]]) assert_array_almost_equal(expm(a), [[1, 0], [0, 1]])
def test_matvec(self): def get_matvecs(A): return [{ 'shape': A.shape, 'matvec': lambda x: np.dot(A, x).reshape(A.shape[0]), 'rmatvec': lambda x: np.dot(A.T.conj(), x).reshape(A.shape[1]) }, { 'shape': A.shape, 'matvec': lambda x: np.dot(A, x), 'rmatvec': lambda x: np.dot(A.T.conj(), x), 'rmatmat': lambda x: np.dot(A.T.conj(), x), 'matmat': lambda x: np.dot(A, x) }] for matvecs in get_matvecs(self.A): A = interface.LinearOperator(**matvecs) assert_(A.args == ()) assert_equal(A.matvec(np.array([1, 2, 3])), [14, 32]) assert_equal(A.matvec(np.array([[1], [2], [3]])), [[14], [32]]) assert_equal(A * np.array([1, 2, 3]), [14, 32]) assert_equal(A * np.array([[1], [2], [3]]), [[14], [32]]) assert_equal(A.dot(np.array([1, 2, 3])), [14, 32]) assert_equal(A.dot(np.array([[1], [2], [3]])), [[14], [32]]) assert_equal(A.matvec(matrix([[1], [2], [3]])), [[14], [32]]) assert_equal(A * matrix([[1], [2], [3]]), [[14], [32]]) assert_equal(A.dot(matrix([[1], [2], [3]])), [[14], [32]]) assert_equal((2 * A) * [1, 1, 1], [12, 30]) assert_equal((2 * A).rmatvec([1, 1]), [10, 14, 18]) assert_equal((2 * A).H.matvec([1, 1]), [10, 14, 18]) assert_equal((2 * A) * [[1], [1], [1]], [[12], [30]]) assert_equal((2 * A).matmat([[1], [1], [1]]), [[12], [30]]) assert_equal((A * 2) * [1, 1, 1], [12, 30]) assert_equal((A * 2) * [[1], [1], [1]], [[12], [30]]) assert_equal((2j * A) * [1, 1, 1], [12j, 30j]) assert_equal((A + A) * [1, 1, 1], [12, 30]) assert_equal((A + A).rmatvec([1, 1]), [10, 14, 18]) assert_equal((A + A).H.matvec([1, 1]), [10, 14, 18]) assert_equal((A + A) * [[1], [1], [1]], [[12], [30]]) assert_equal((A + A).matmat([[1], [1], [1]]), [[12], [30]]) assert_equal((-A) * [1, 1, 1], [-6, -15]) assert_equal((-A) * [[1], [1], [1]], [[-6], [-15]]) assert_equal((A - A) * [1, 1, 1], [0, 0]) assert_equal((A - A) * [[1], [1], [1]], [[0], [0]]) X = np.array([[1, 2], [3, 4]]) # A_asarray = np.array([[1, 2, 3], [4, 5, 6]]) assert_equal((2 * A).rmatmat(X), np.dot((2 * self.A).T, X)) assert_equal((A * 2).rmatmat(X), np.dot((self.A * 2).T, X)) assert_equal((2j * A).rmatmat(X), np.dot((2j * self.A).T.conj(), X)) assert_equal((A * 2j).rmatmat(X), np.dot((self.A * 2j).T.conj(), X)) assert_equal((A + A).rmatmat(X), np.dot((self.A + self.A).T, X)) assert_equal((A + 2j * A).rmatmat(X), np.dot((self.A + 2j * self.A).T.conj(), X)) assert_equal((-A).rmatmat(X), np.dot((-self.A).T, X)) assert_equal((A - A).rmatmat(X), np.dot((self.A - self.A).T, X)) assert_equal((2j * A).rmatmat(2j * X), np.dot((2j * self.A).T.conj(), 2j * X)) z = A + A assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] is A) z = 2 * A assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] == 2) assert_(isinstance(A.matvec([1, 2, 3]), np.ndarray)) assert_(isinstance(A.matvec(np.array([[1], [2], [3]])), np.ndarray)) assert_(isinstance(A * np.array([1, 2, 3]), np.ndarray)) assert_(isinstance(A * np.array([[1], [2], [3]]), np.ndarray)) assert_(isinstance(A.dot(np.array([1, 2, 3])), np.ndarray)) assert_(isinstance(A.dot(np.array([[1], [2], [3]])), np.ndarray)) assert_(isinstance(A.matvec(matrix([[1], [2], [3]])), np.ndarray)) assert_(isinstance(A * matrix([[1], [2], [3]]), np.ndarray)) assert_(isinstance(A.dot(matrix([[1], [2], [3]])), np.ndarray)) assert_(isinstance(2 * A, interface._ScaledLinearOperator)) assert_(isinstance(2j * A, interface._ScaledLinearOperator)) assert_(isinstance(A + A, interface._SumLinearOperator)) assert_(isinstance(-A, interface._ScaledLinearOperator)) assert_(isinstance(A - A, interface._SumLinearOperator)) assert_((2j * A).dtype == np.complex_) assert_raises(ValueError, A.matvec, np.array([1, 2])) assert_raises(ValueError, A.matvec, np.array([1, 2, 3, 4])) assert_raises(ValueError, A.matvec, np.array([[1], [2]])) assert_raises(ValueError, A.matvec, np.array([[1], [2], [3], [4]])) assert_raises(ValueError, lambda: A * A) assert_raises(ValueError, lambda: A**2) for matvecsA, matvecsB in product(get_matvecs(self.A), get_matvecs(self.B)): A = interface.LinearOperator(**matvecsA) B = interface.LinearOperator(**matvecsB) # AtimesB = np.array([[22, 28], [49, 64]]) AtimesB = self.A.dot(self.B) X = np.array([[1, 2], [3, 4]]) assert_equal((A * B).rmatmat(X), np.dot((AtimesB).T, X)) assert_equal((2j * A * B).rmatmat(X), np.dot((2j * AtimesB).T.conj(), X)) assert_equal((A * B) * [1, 1], [50, 113]) assert_equal((A * B) * [[1], [1]], [[50], [113]]) assert_equal((A * B).matmat([[1], [1]]), [[50], [113]]) assert_equal((A * B).rmatvec([1, 1]), [71, 92]) assert_equal((A * B).H.matvec([1, 1]), [71, 92]) assert_(isinstance(A * B, interface._ProductLinearOperator)) assert_raises(ValueError, lambda: A + B) assert_raises(ValueError, lambda: A**2) z = A * B assert_(len(z.args) == 2 and z.args[0] is A and z.args[1] is B) for matvecsC in get_matvecs(self.C): C = interface.LinearOperator(**matvecsC) X = np.array([[1, 2], [3, 4]]) assert_equal(C.rmatmat(X), np.dot((self.C).T, X)) assert_equal((C**2).rmatmat(X), np.dot((np.dot(self.C, self.C)).T, X)) assert_equal((C**2) * [1, 1], [17, 37]) assert_equal((C**2).rmatvec([1, 1]), [22, 32]) assert_equal((C**2).H.matvec([1, 1]), [22, 32]) assert_equal((C**2).matmat([[1], [1]]), [[17], [37]]) assert_(isinstance(C**2, interface._PowerLinearOperator))
def test_isdense(self): assert_equal(sputils.isdense(np.array([1])), True) assert_equal(sputils.isdense(matrix([1])), True)
class TestSolveLyapunov(object): cases = [ (np.array([[1, 2], [3, 4]]), np.array([[9, 10], [11, 12]])), # a, q all complex. (np.array([[1.0 + 1j, 2.0], [3.0 - 4.0j, 5.0]]), np.array([[2.0 - 2j, 2.0 + 2j], [-1.0 - 1j, 2.0]])), # a real; q complex. (np.array([[1.0, 2.0], [3.0, 5.0]]), np.array([[2.0 - 2j, 2.0 + 2j], [-1.0 - 1j, 2.0]])), # a complex; q real. (np.array([[1.0 + 1j, 2.0], [3.0 - 4.0j, 5.0]]), np.array([[2.0, 2.0], [-1.0, 2.0]])), # An example from Kitagawa, 1977 (np.array([[3, 9, 5, 1, 4], [1, 2, 3, 8, 4], [4, 6, 6, 6, 3], [1, 5, 2, 0, 7], [5, 3, 3, 1, 5]]), np.array([[2, 4, 1, 0, 1], [4, 1, 0, 2, 0], [1, 0, 3, 0, 3], [0, 2, 0, 1, 0], [1, 0, 3, 0, 4]])), # Companion matrix example. a complex; q real; a.shape[0] = 11 (np.array([[ 0.100 + 0.j, 0.091 + 0.j, 0.082 + 0.j, 0.073 + 0.j, 0.064 + 0.j, 0.055 + 0.j, 0.046 + 0.j, 0.037 + 0.j, 0.028 + 0.j, 0.019 + 0.j, 0.010 + 0.j ], [ 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j ], [ 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 0.000 + 0.j, 1.000 + 0.j, 0.000 + 0.j ]]), np.eye(11)), # https://github.com/scipy/scipy/issues/4176 (matrix([[0, 1], [-1 / 2, -1]]), (matrix([0, 3]).T * matrix([0, 3]).T.T)), # https://github.com/scipy/scipy/issues/4176 (matrix([[0, 1], [-1 / 2, -1]]), (np.array(matrix([0, 3]).T * matrix([0, 3]).T.T))), ] def test_continuous_squareness_and_shape(self): nsq = np.ones((3, 2)) sq = np.eye(3) assert_raises(ValueError, solve_continuous_lyapunov, nsq, sq) assert_raises(ValueError, solve_continuous_lyapunov, sq, nsq) assert_raises(ValueError, solve_continuous_lyapunov, sq, np.eye(2)) def check_continuous_case(self, a, q): x = solve_continuous_lyapunov(a, q) assert_array_almost_equal( np.dot(a, x) + np.dot(x, a.conj().transpose()), q) def check_discrete_case(self, a, q, method=None): x = solve_discrete_lyapunov(a, q, method=method) assert_array_almost_equal( np.dot(np.dot(a, x), a.conj().transpose()) - x, -1.0 * q) def test_cases(self): for case in self.cases: self.check_continuous_case(case[0], case[1]) self.check_discrete_case(case[0], case[1]) self.check_discrete_case(case[0], case[1], method='direct') self.check_discrete_case(case[0], case[1], method='bilinear')
def test_zero_matrix(self): a = matrix([[0.,0],[0,0]]) assert_array_almost_equal(expm(a),[[1,0],[0,1]])