def test_mkl_spsolve7(): """ MKL spsolve : Solution shape same as input RHS vec """ row = np.array([0,0,1,2,2,2]) col = np.array([0,2,2,0,1,2]) data = np.array([1,2,3,-4,5,6], dtype=complex) A = sp.csr_matrix((data,(row,col)), shape=(3,3), dtype=complex) b = np.array([0,2,0],dtype=complex) out = mkl_spsolve(A,b) assert_(b.shape==out.shape) b = np.array([0,2,0],dtype=complex).reshape((3,1)) out = mkl_spsolve(A,b) assert_(b.shape==out.shape)
def test_mklspsolve2(): """ MKL spsolve : Single RHS vector (Complex) """ A = rand_herm(10) x = rand_ket(10).full() b = A * x y = mkl_spsolve(A.data,b) assert_array_almost_equal(x, y)
def test_mkl_spsolve9(): """ MKL spsolve : Hermitian (complex) solver """ A = rand_herm(np.arange(1,11)).data x = np.ones(10,dtype=complex) b = A.dot(x) y = mkl_spsolve(A, b, hermitian=1) assert_array_almost_equal(x, y)
def test_mkl_spsolve10(): """ MKL spsolve : Hermitian (real) solver """ A = rand_herm(np.arange(1,11)).data A = sp.csr_matrix((np.real(A.data), A.indices, A.indptr), dtype=float) x = np.ones(10, dtype=float) b = A.dot(x) y = mkl_spsolve(A, b, hermitian=1) assert_array_almost_equal(x, y)
def test_mkl_spsolve1(): """ MKL spsolve : Single RHS vector (Real) """ Adense = np.array([[0., 1., 1.], [1., 0., 1.], [0., 0., 1.]]) As = sp.csr_matrix(Adense) np.random.seed(1234) x = np.random.randn(3) b = As * x x2 = mkl_spsolve(As, b) assert_array_almost_equal(x, x2)
def _pseudo_inverse_sparse(L, rhoss, method='splu', **pseudo_args): """ Internal function for computing the pseudo inverse of an Liouvillian using sparse matrix methods. See pseudo_inverse for details. """ N = np.prod(L.dims[0][0]) rhoss_vec = operator_to_vector(rhoss) tr_op = tensor([identity(n) for n in L.dims[0][0]]) tr_op_vec = operator_to_vector(tr_op) P = sp.kron(rhoss_vec.data, tr_op_vec.data.T, format='csr') I = sp.eye(N*N, N*N, format='csr') Q = I - P if pseudo_args['use_rcm']: perm = reverse_cuthill_mckee(L.data) A = sp_permute(L.data, perm, perm, 'csr') Q = sp_permute(Q, perm, perm, 'csr') else: if not settings.has_mkl: A = L.data.tocsc() A.sort_indices() if method == 'splu': if settings.has_mkl: LIQ = mkl_spsolve(A,Q.toarray()) else: lu = sp.linalg.splu(A, permc_spec=pseudo_args['permc_spec'], diag_pivot_thresh=pseudo_args['diag_pivot_thresh'], options=dict(ILU_MILU=pseudo_args['ILU_MILU'])) LIQ = lu.solve(Q.toarray()) elif method == 'spilu': lu = sp.linalg.spilu(A, permc_spec=pseudo_args['permc_spec'], fill_factor=pseudo_args['fill_factor'], drop_tol=pseudo_args['drop_tol']) LIQ = lu.solve(Q.toarray()) else: raise ValueError("unsupported method '%s'" % method) R = sp.csr_matrix(Q * LIQ) if pseudo_args['use_rcm']: rev_perm = np.argsort(perm) R = sp_permute(R, rev_perm, rev_perm, 'csr') return Qobj(R, dims=L.dims)
def test_mkl_spsolve4(): """ MKL spsolve : Multi RHS vector (Complex) """ row = np.array([0,0,1,2,2,2]) col = np.array([0,2,2,0,1,2]) data = np.array([1,2,3,-4,5,6],dtype=complex) sM = sp.csr_matrix((data,(row,col)), shape=(3,3), dtype=complex) M = sM.toarray() row = np.array([0,0,1,1,0,0]) col = np.array([0,2,1,1,0,0]) data = np.array([1,1,1,1,1,1],dtype=complex) sN = sp.csr_matrix((data, (row,col)), shape=(3,3), dtype=complex) N = sN.toarray() sX = mkl_spsolve(sM, N) X = la.solve(M, N) assert_array_almost_equal(X, sX)
def test_mkl_spsolve8(): """ MKL spsolve : Sparse RHS matrix """ A = sp.csr_matrix([ [1, 2, 0], [0, 3, 0], [0, 0, 5]]) b = sp.csr_matrix([ [0, 1], [1, 0], [0, 0]]) x = mkl_spsolve(A, b) ans = np.array([[-0.66666667, 1], [0.33333333, 0], [0, 0]]) assert_array_almost_equal(x.toarray(), ans)
def _steadystate_direct_sparse(L, ss_args): """ Direct solver that uses scipy sparse matrices """ if settings.debug: logger.debug('Starting direct LU solver.') dims = L.dims[0] n = int(np.sqrt(L.shape[0])) b = np.zeros(n ** 2, dtype=complex) b[0] = ss_args['weight'] if settings.has_mkl: has_mkl = 1 else: has_mkl = 0 L, perm, perm2, rev_perm, ss_args = _steadystate_LU_liouvillian(L, ss_args, has_mkl) if np.any(perm): b = b[np.ix_(perm,)] if np.any(perm2): b = b[np.ix_(perm2,)] ss_args['info']['permc_spec'] = ss_args['permc_spec'] ss_args['info']['drop_tol'] = ss_args['drop_tol'] ss_args['info']['diag_pivot_thresh'] = ss_args['diag_pivot_thresh'] ss_args['info']['fill_factor'] = ss_args['fill_factor'] ss_args['info']['ILU_MILU'] = ss_args['ILU_MILU'] if not has_mkl: # Use superLU solver orig_nnz = L.nnz _direct_start = time.time() lu = splu(L, permc_spec=ss_args['permc_spec'], diag_pivot_thresh=ss_args['diag_pivot_thresh'], options=dict(ILU_MILU=ss_args['ILU_MILU'])) v = lu.solve(b) _direct_end = time.time() ss_args['info']['solution_time'] = _direct_end - _direct_start if (settings.debug or ss_args['return_info']) and _scipy_check: L_nnz = lu.L.nnz U_nnz = lu.U.nnz ss_args['info']['l_nnz'] = L_nnz ss_args['info']['u_nnz'] = U_nnz ss_args['info']['lu_fill_factor'] = (L_nnz + U_nnz)/L.nnz if settings.debug: logger.debug('L NNZ: %i ; U NNZ: %i' % (L_nnz, U_nnz)) logger.debug('Fill factor: %f' % ((L_nnz + U_nnz)/orig_nnz)) else: # Use MKL solver if len(ss_args['info']['perm']) !=0: in_perm = np.arange(n**2, dtype=np.int32) else: in_perm = None _direct_start = time.time() v = mkl_spsolve(L, b, perm = in_perm, verbose = ss_args['verbose']) _direct_end = time.time() ss_args['info']['solution_time'] = _direct_end-_direct_start if ss_args['return_info']: ss_args['info']['residual_norm'] = la.norm(b - L*v) if (not ss_args['use_umfpack']) and ss_args['use_rcm']: v = v[np.ix_(rev_perm,)] data = vec2mat(v) data = 0.5 * (data + data.conj().T) if ss_args['return_info']: return Qobj(data, dims=dims, isherm=True), ss_args['info'] else: return Qobj(data, dims=dims, isherm=True)