|
ViennaCL - The Vienna Computing Library
1.5.1
|
Implementation namespace for sparse approximate inverse preconditioner. More...
Data Structures | |
| class | block_matrix |
| Represents a contigious matrices on GPU. More... | |
| class | block_vector |
| Represents a contigious vector on GPU. More... | |
| class | fspai_tag |
| A tag for FSPAI. Experimental. Contains values for the algorithm. Must be passed to spai_precond constructor. More... | |
| struct | CompareSecond |
| Helper functor for comparing std::pair<> based on the second member. More... | |
| class | spai_tag |
| A tag for SPAI Contains values for the algorithm. Must be passed to spai_precond constructor. More... | |
| class | sparse_vector |
| Represents sparse vector based on std::map<unsigned int, ScalarType> More... | |
Functions | |
| template<typename MatrixType , typename ScalarType > | |
| void | sym_sparse_matrix_to_stl (MatrixType const &A, std::vector< std::map< unsigned int, ScalarType > > &STL_A) |
| template<typename MatrixType > | |
| void | generateJ (MatrixType const &A, std::vector< std::vector< vcl_size_t > > &J) |
| template<typename ScalarType , typename MatrixType , typename VectorType > | |
| void | fill_blocks (std::vector< std::map< unsigned int, ScalarType > > &A, std::vector< MatrixType > &blocks, std::vector< std::vector< vcl_size_t > > const &J, std::vector< VectorType > &Y) |
| template<typename MatrixType > | |
| void | cholesky_decompose (MatrixType &A) |
| template<typename MatrixType , typename VectorType > | |
| void | cholesky_solve (MatrixType const &L, VectorType &b) |
| template<typename MatrixType , typename VectorType1 > | |
| void | computeL (MatrixType const &A, MatrixType &L, MatrixType &L_trans, std::vector< VectorType1 > &Y, std::vector< std::vector< vcl_size_t > > &J) |
| template<typename MatrixType > | |
| void | computeFSPAI (MatrixType const &A, MatrixType const &PatternA, MatrixType &L, MatrixType &L_trans, fspai_tag) |
| template<typename T , typename InputIterator > | |
| void | Print (std::ostream &ostr, InputIterator it_begin, InputIterator it_end) |
| template<typename VectorType , typename MatrixType > | |
| void | write_to_block (VectorType &con_A_I_J, unsigned int start_ind, const std::vector< unsigned int > &I, const std::vector< unsigned int > &J, MatrixType &m) |
| template<typename VectorType > | |
| void | print_continious_matrix (VectorType &con_A_I_J, std::vector< cl_uint > &blocks_ind, const std::vector< std::vector< unsigned int > > &g_I, const std::vector< std::vector< unsigned int > > &g_J) |
| template<typename VectorType > | |
| void | print_continious_vector (VectorType &con_v, std::vector< cl_uint > &block_ind, const std::vector< std::vector< unsigned int > > &g_J) |
| void | compute_blocks_size (const std::vector< std::vector< unsigned int > > &g_I, const std::vector< std::vector< unsigned int > > &g_J, unsigned int &sz, std::vector< cl_uint > &blocks_ind, std::vector< cl_uint > &matrix_dims) |
| **************************************** BLOCK FUNCTIONS ************************************// | |
| template<typename SizeType > | |
| void | get_size (const std::vector< std::vector< SizeType > > &inds, SizeType &size) |
| Computes size of particular container of index set. | |
| template<typename SizeType > | |
| void | init_start_inds (const std::vector< std::vector< SizeType > > &inds, std::vector< cl_uint > &start_inds) |
| Initializes start indices of particular index set. | |
| template<typename MatrixType , typename ScalarType > | |
| void | dot_prod (const MatrixType &A, unsigned int beg_ind, ScalarType &res) |
| Dot prod of particular column of martix A with it's self starting at a certain index beg_ind. | |
| template<typename MatrixType , typename VectorType , typename ScalarType > | |
| void | custom_inner_prod (const MatrixType &A, const VectorType &v, unsigned int col_ind, unsigned int start_ind, ScalarType &res) |
| Dot prod of particular matrix column with arbitrary vector: A(:, col_ind) | |
| template<typename MatrixType , typename VectorType > | |
| void | copy_vector (const MatrixType &A, VectorType &v, const unsigned int beg_ind) |
| Copying part of matrix column. | |
| template<typename MatrixType , typename VectorType , typename ScalarType > | |
| void | householder_vector (const MatrixType &A, unsigned int j, VectorType &v, ScalarType &b) |
| Coputation of Householder vector, householder reflection c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.210. | |
| template<typename MatrixType , typename VectorType , typename ScalarType > | |
| void | apply_householder_reflection (MatrixType &A, unsigned int iter_cnt, VectorType &v, ScalarType b) |
| Inplace application of Householder vector to a matrix A. | |
| template<typename MatrixType , typename VectorType > | |
| void | store_householder_vector (MatrixType &A, unsigned int ind, VectorType &v) |
| Storage of vector v in column(A, ind), starting from ind-1 index of a column. | |
| template<typename MatrixType , typename VectorType > | |
| void | single_qr (MatrixType &R, VectorType &b_v) |
| Inplace QR factorization via Householder reflections c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.224. | |
| template<typename SizeType > | |
| void | get_max_block_size (const std::vector< std::vector< SizeType > > &inds, SizeType &max_size) |
| Getting max size of rows/columns from container of index set. | |
| template<typename MatrixType , typename VectorType , typename ScalarType > | |
| void | custom_dot_prod (const MatrixType &A, const VectorType &v, unsigned int ind, ScalarType &res) |
| Dot_prod(column(A, ind), v) starting from index ind+1. | |
| template<typename MatrixType , typename VectorType > | |
| void | apply_q_trans_vec (const MatrixType &R, const VectorType &b_v, VectorType &y) |
| Recovery Q from matrix R and vector of betas b_v. | |
| template<typename MatrixType , typename VectorType > | |
| void | apply_q_trans_mat (const MatrixType &R, const VectorType &b_v, MatrixType &A) |
| Multiplication of Q'*A, where Q is in implicit for lower part of R and vector of betas - b_v. | |
| template<typename ScalarType > | |
| void | block_qr (std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, block_matrix &g_A_I_J_vcl, block_vector &g_bv_vcl, std::vector< cl_uint > &g_is_update, viennacl::context ctx) |
| Inplace QR factorization via Householder reflections c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.224 performed on GPU. | |
| template<typename MatrixType > | |
| void | make_rotation_matrix (MatrixType &mat, vcl_size_t new_size, vcl_size_t off_diagonal_distance=4) |
| template<typename MatrixType > | |
| double | determinant (boost::numeric::ublas::matrix_expression< MatrixType > const &mat_r) |
| template<typename MatrixType > | |
| void | composeNewR (const MatrixType &A, const MatrixType &R_n, MatrixType &R) |
| Composition of new matrix R, that is going to be used in Least Square problem solving. | |
| template<typename VectorType > | |
| void | composeNewVector (const VectorType &v_n, VectorType &v) |
| Composition of new vector of coefficients beta from QR factorizations(necessary for Q recovery) | |
| template<typename SparseVectorType , typename ScalarType > | |
| void | sparse_norm_2 (const SparseVectorType &v, ScalarType &norm) |
| Computation of Euclidean norm for sparse vector. | |
| template<typename SparseVectorType , typename ScalarType > | |
| void | sparse_inner_prod (const SparseVectorType &v1, const SparseVectorType &v2, ScalarType &res_v) |
| Dot product of two sparse vectors. | |
| template<typename SparseVectorType , typename ScalarType > | |
| bool | buildAugmentedIndexSet (const std::vector< SparseVectorType > &A_v_c, const SparseVectorType &res, std::vector< unsigned int > &J, std::vector< unsigned int > &J_u, const spai_tag &tag) |
| Building a new set of column indices J_u, cf. Kallischko dissertation p.31. | |
| template<typename SparseVectorType > | |
| void | buildNewRowSet (const std::vector< SparseVectorType > &A_v_c, const std::vector< unsigned int > &I, const std::vector< unsigned int > &J_n, std::vector< unsigned int > &I_n) |
| Building a new indices to current set of row indices I_n, cf. Kallischko dissertation p.32. | |
| template<typename MatrixType > | |
| void | QRBlockComposition (const MatrixType &A_I_J, const MatrixType &A_I_J_u, MatrixType &A_I_u_J_u) |
| Composition of new block for QR factorization cf. Kallischko dissertation p.82, figure 4.7. | |
| template<typename SparseMatrixType , typename SparseVectorType , typename DenseMatrixType , typename VectorType > | |
| void | block_update (const SparseMatrixType &A, const std::vector< SparseVectorType > &A_v_c, std::vector< SparseVectorType > &g_res, std::vector< bool > &g_is_update, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, std::vector< VectorType > &g_b_v, std::vector< DenseMatrixType > &g_A_I_J, spai_tag const &tag) |
| CPU-based dynamic update for SPAI preconditioner. | |
| template<typename ScalarType > | |
| void | block_q_multiplication (const std::vector< std::vector< unsigned int > > &g_J_u, const std::vector< std::vector< unsigned int > > &g_I, block_matrix &g_A_I_J_vcl, block_vector &g_bv_vcl, block_matrix &g_A_I_J_u_vcl, std::vector< cl_uint > &g_is_update, viennacl::context ctx) |
| Performs multiplication Q'*A(I, \tilde J) on GPU. | |
| template<typename SizeType > | |
| void | assemble_qr_row_inds (const std::vector< std::vector< SizeType > > &g_I, const std::vector< std::vector< SizeType > > g_J, const std::vector< std::vector< SizeType > > &g_I_u, std::vector< std::vector< SizeType > > &g_I_q) |
| Assembly of container of index row sets: I_q, row indices for new "QR block". | |
| template<typename ScalarType > | |
| void | assemble_qr_block (const std::vector< std::vector< unsigned int > > &g_J, const std::vector< std::vector< unsigned int > > &g_I, const std::vector< std::vector< unsigned int > > &g_J_u, const std::vector< std::vector< unsigned int > > &g_I_u, std::vector< std::vector< unsigned int > > &g_I_q, block_matrix &g_A_I_J_u_vcl, viennacl::ocl::handle< cl_mem > &matrix_dimensions, block_matrix &g_A_I_u_J_u_vcl, std::vector< cl_uint > &g_is_update, const bool is_empty_block, viennacl::context ctx) |
| Performs assembly for new QR block. | |
| template<typename ScalarType > | |
| void | assemble_r (std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, block_matrix &g_A_I_J_vcl, block_matrix &g_A_I_J_u_vcl, block_matrix &g_A_I_u_J_u_vcl, block_vector &g_bv_vcl, block_vector &g_bv_vcl_u, std::vector< cl_uint > &g_is_update, viennacl::context ctx) |
| Performs assembly for new R matrix on GPU. | |
| template<typename ScalarType , unsigned int MAT_ALIGNMENT, typename SparseVectorType > | |
| void | block_update (const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > &A, const std::vector< SparseVectorType > &A_v_c, std::vector< cl_uint > &g_is_update, std::vector< SparseVectorType > &g_res, std::vector< std::vector< unsigned int > > &g_J, std::vector< std::vector< unsigned int > > &g_I, block_matrix &g_A_I_J_vcl, block_vector &g_bv_vcl, spai_tag const &tag) |
| GPU-based block update. | |
| template<typename SizeType > | |
| bool | isInIndexSet (const std::vector< SizeType > &J, SizeType ind) |
| Determines if element ind is in set {J}. | |
| template<typename VectorType , typename SparseVectorType > | |
| void | fanOutVector (const VectorType &m_in, const std::vector< unsigned int > &J, SparseVectorType &m) |
| Projects solution of LS problem onto original column m. | |
| template<typename MatrixType , typename VectorType > | |
| void | backwardSolve (const MatrixType &R, const VectorType &y, VectorType &x) |
| Solution of linear:R*x=y system by backward substitution. | |
| template<typename VectorType , typename ScalarType > | |
| void | projectI (const std::vector< unsigned int > &I, VectorType &y, unsigned int ind) |
| Perform projection of set I on the unit-vector. | |
| template<typename SparseVectorType > | |
| void | buildColumnIndexSet (const SparseVectorType &v, std::vector< unsigned int > &J) |
| Builds index set of projected columns for current column of preconditioner. | |
| template<typename SparseMatrixType > | |
| void | initPreconditioner (const SparseMatrixType &A, SparseMatrixType &M) |
| Initialize preconditioner with sparcity pattern = p(A) | |
| template<typename SparseVectorType > | |
| void | projectRows (const std::vector< SparseVectorType > &A_v_c, const std::vector< unsigned int > &J, std::vector< unsigned int > &I) |
| Row projection for matrix A(:,J) -> A(I,J), building index set of non-zero rows. | |
| template<typename SparseVectorType > | |
| void | print_sparse_vector (const SparseVectorType &v) |
| template<typename DenseMatrixType > | |
| void | print_matrix (DenseMatrixType &m) |
| template<typename SparseVectorType , typename ScalarType > | |
| void | add_sparse_vectors (const SparseVectorType &v, const ScalarType b, SparseVectorType &res_v) |
| Add two sparse vectors res_v = b*v. | |
| template<typename SparseVectorType , typename ScalarType > | |
| void | compute_spai_residual (const std::vector< SparseVectorType > &A_v_c, const SparseVectorType &v, const unsigned int ind, SparseVectorType &res) |
| Computation of residual res = A*v - e. | |
| template<typename SparseVectorType > | |
| void | build_index_set (const std::vector< SparseVectorType > &A_v_c, const SparseVectorType &v, std::vector< unsigned int > &J, std::vector< unsigned int > &I) |
| Setting up index set of columns and rows for certain column. | |
| template<typename SparseMatrixType , typename DenseMatrixType > | |
| void | initProjectSubMatrix (const SparseMatrixType &A_in, const std::vector< unsigned int > &J, std::vector< unsigned int > &I, DenseMatrixType &A_out) |
| Initializes a dense matrix from a sparse one. | |
| template<typename SparseMatrixType , typename DenseMatrixType , typename SparseVectorType , typename VectorType > | |
| void | block_set_up (const SparseMatrixType &A, const std::vector< SparseVectorType > &A_v_c, const std::vector< SparseVectorType > &M_v, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, std::vector< DenseMatrixType > &g_A_I_J, std::vector< VectorType > &g_b_v) |
| Setting up blocks and QR factorizing them on CPU. | |
| template<typename SparseVectorType > | |
| void | index_set_up (const std::vector< SparseVectorType > &A_v_c, const std::vector< SparseVectorType > &M_v, std::vector< std::vector< unsigned int > > &g_J, std::vector< std::vector< unsigned int > > &g_I) |
| Setting up index set of columns and rows for all columns. | |
| template<typename ScalarType , unsigned int MAT_ALIGNMENT, typename SparseVectorType > | |
| void | block_set_up (const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > &A, const std::vector< SparseVectorType > &A_v_c, const std::vector< SparseVectorType > &M_v, std::vector< cl_uint > g_is_update, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, block_matrix &g_A_I_J, block_vector &g_bv) |
| Setting up blocks and QR factorizing them on GPU. | |
| template<typename ScalarType , typename SparseVectorType > | |
| void | custom_fan_out (const std::vector< ScalarType > &m_in, unsigned int start_m_ind, const std::vector< unsigned int > &J, SparseVectorType &m) |
| Elicitation of sparse vector m for particular column from m_in - contigious vector for all columns. | |
| template<typename SparseVectorType , typename ScalarType > | |
| void | least_square_solve (std::vector< SparseVectorType > &A_v_c, std::vector< SparseVectorType > &M_v, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, block_matrix &g_A_I_J_vcl, block_vector &g_bv_vcl, std::vector< SparseVectorType > &g_res, std::vector< cl_uint > &g_is_update, const spai_tag &tag, viennacl::context ctx) |
| Solution of Least square problem on GPU. | |
| template<typename SparseVectorType , typename DenseMatrixType , typename VectorType > | |
| void | least_square_solve (const std::vector< SparseVectorType > &A_v_c, std::vector< DenseMatrixType > &g_R, std::vector< VectorType > &g_b_v, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, std::vector< SparseVectorType > &g_res, std::vector< bool > &g_is_update, std::vector< SparseVectorType > &M_v, const spai_tag &tag) |
| Solution of Least square problem on CPU. | |
| template<typename VectorType > | |
| bool | is_all_update (VectorType ¶llel_is_update) |
| template<typename SparseMatrixType , typename SparseVectorType > | |
| void | vectorize_column_matrix (const SparseMatrixType &M_in, std::vector< SparseVectorType > &M_v) |
| Solution of Least square problem on CPU. | |
| template<typename SparseMatrixType , typename SparseVectorType > | |
| void | vectorize_row_matrix (const SparseMatrixType &M_in, std::vector< SparseVectorType > &M_v) |
| template<typename SizeType > | |
| void | write_set_to_array (const std::vector< std::vector< SizeType > > &ind_set, std::vector< cl_uint > &a) |
| template<typename ScalarType , unsigned int MAT_ALIGNMENT> | |
| void | block_assembly (const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > &A, const std::vector< std::vector< unsigned int > > &g_J, const std::vector< std::vector< unsigned int > > &g_I, block_matrix &g_A_I_J_vcl, std::vector< cl_uint > &g_is_update, bool &is_empty_block) |
| Assembly of blocks on GPU by a gived set of row indices: g_I and column indices: g_J. | |
| template<typename SparseMatrixType , typename SparseVectorType > | |
| void | insert_sparse_columns (const std::vector< SparseVectorType > &M_v, SparseMatrixType &M, bool is_right) |
| Insertion of vectorized matrix column into original sparse matrix. | |
| template<typename MatrixType > | |
| void | sparse_transpose (const MatrixType &A_in, MatrixType &A) |
| Transposition of sparse matrix. | |
| template<typename MatrixType > | |
| void | computeSPAI (const MatrixType &A, MatrixType &M, spai_tag &tag) |
| Construction of SPAI preconditioner on CPU. | |
| template<typename ScalarType , unsigned int MAT_ALIGNMENT> | |
| void | computeSPAI (const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > &A, const boost::numeric::ublas::compressed_matrix< ScalarType > &cpu_A, boost::numeric::ublas::compressed_matrix< ScalarType > &cpu_M, viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > &M, const spai_tag &tag) |
| Construction of SPAI preconditioner on GPU. | |
Implementation namespace for sparse approximate inverse preconditioner.
| void viennacl::linalg::detail::spai::add_sparse_vectors | ( | const SparseVectorType & | v, |
| const ScalarType | b, | ||
| SparseVectorType & | res_v | ||
| ) |
Add two sparse vectors res_v = b*v.
| v | initial sparse vector |
| b | scalar |
| res_v | output vector |
| void viennacl::linalg::detail::spai::apply_householder_reflection | ( | MatrixType & | A, |
| unsigned int | iter_cnt, | ||
| VectorType & | v, | ||
| ScalarType | b | ||
| ) |
Inplace application of Householder vector to a matrix A.
| A | init matrix |
| iter_cnt | current iteration |
| v | Householder vector |
| b | beta |
| void viennacl::linalg::detail::spai::apply_q_trans_mat | ( | const MatrixType & | R, |
| const VectorType & | b_v, | ||
| MatrixType & | A | ||
| ) |
Multiplication of Q'*A, where Q is in implicit for lower part of R and vector of betas - b_v.
| R | input matrix |
| b_v | vector of betas |
| A | output matrix |
| void viennacl::linalg::detail::spai::apply_q_trans_vec | ( | const MatrixType & | R, |
| const VectorType & | b_v, | ||
| VectorType & | y | ||
| ) |
Recovery Q from matrix R and vector of betas b_v.
| R | input matrix |
| b_v | vector of betas |
| y | output vector |
| void viennacl::linalg::detail::spai::assemble_qr_block | ( | const std::vector< std::vector< unsigned int > > & | g_J, |
| const std::vector< std::vector< unsigned int > > & | g_I, | ||
| const std::vector< std::vector< unsigned int > > & | g_J_u, | ||
| const std::vector< std::vector< unsigned int > > & | g_I_u, | ||
| std::vector< std::vector< unsigned int > > & | g_I_q, | ||
| block_matrix & | g_A_I_J_u_vcl, | ||
| viennacl::ocl::handle< cl_mem > & | matrix_dimensions, | ||
| block_matrix & | g_A_I_u_J_u_vcl, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| const bool | is_empty_block, | ||
| viennacl::context | ctx | ||
| ) |
Performs assembly for new QR block.
| g_J | container of column indices |
| g_I | container of row indices |
| g_J_u | container of new column indices |
| g_I_u | container of new row indices |
| g_I_q | container of row indices for new QR blocks |
| g_A_I_J_u_vcl | blocks of Q'*A(I, \tilde J) |
| matrix_dimensions | array with matrix dimensions for all blocks |
| g_A_I_u_J_u_vcl | blocks A(\tilde I, \tilde J) |
| g_is_update | container with update indicators |
| is_empty_block | indicator if all previous blocks A(\tilde I, \tilde J) - are empty, in case if they are empty kernel with smaller number of arguments is used |
| ctx | Optional context in which the matrix is created (one out of multiple OpenCL contexts, CUDA, host) |
| void viennacl::linalg::detail::spai::assemble_qr_row_inds | ( | const std::vector< std::vector< SizeType > > & | g_I, |
| const std::vector< std::vector< SizeType > > | g_J, | ||
| const std::vector< std::vector< SizeType > > & | g_I_u, | ||
| std::vector< std::vector< SizeType > > & | g_I_q | ||
| ) |
Assembly of container of index row sets: I_q, row indices for new "QR block".
| g_I | container of row indices |
| g_J | container of column indices |
| g_I_u | container of new row indices |
| g_I_q | container of row indices for new QR blocks |
| void viennacl::linalg::detail::spai::assemble_r | ( | std::vector< std::vector< unsigned int > > & | g_I, |
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| block_matrix & | g_A_I_J_vcl, | ||
| block_matrix & | g_A_I_J_u_vcl, | ||
| block_matrix & | g_A_I_u_J_u_vcl, | ||
| block_vector & | g_bv_vcl, | ||
| block_vector & | g_bv_vcl_u, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| viennacl::context | ctx | ||
| ) |
Performs assembly for new R matrix on GPU.
| g_I | container of row indices |
| g_J | container of column indices |
| g_A_I_J_vcl | container of block matrices from previous update |
| g_A_I_J_u_vcl | container of block matrices Q'*A(I, \tilde J) |
| g_A_I_u_J_u_vcl | container of block matrices QR factored on current iteration |
| g_bv_vcl | block of beta vectors from previous iteration |
| g_bv_vcl_u | block of updated beta vectors got after recent QR factorization |
| g_is_update | container with identificators that shows which block should be modified |
| ctx | Optional context in which the auxiliary data is created (one out of multiple OpenCL contexts, CUDA, host) |
| void viennacl::linalg::detail::spai::backwardSolve | ( | const MatrixType & | R, |
| const VectorType & | y, | ||
| VectorType & | x | ||
| ) |
Solution of linear:R*x=y system by backward substitution.
| R | uppertriangular matrix |
| y | right handside vector |
| x | solution vector |
| void viennacl::linalg::detail::spai::block_assembly | ( | const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > & | A, |
| const std::vector< std::vector< unsigned int > > & | g_J, | ||
| const std::vector< std::vector< unsigned int > > & | g_I, | ||
| block_matrix & | g_A_I_J_vcl, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| bool & | is_empty_block | ||
| ) |
Assembly of blocks on GPU by a gived set of row indices: g_I and column indices: g_J.
| A | intial sparse matrix |
| g_J | container of column index set |
| g_I | container of row index set |
| g_A_I_J_vcl | contigious blocks A(I, J) using GPU memory |
| g_is_update | container with indicators which blocks are active |
| is_empty_block | parameter that indicates if no block were assembled |
| void viennacl::linalg::detail::spai::block_q_multiplication | ( | const std::vector< std::vector< unsigned int > > & | g_J_u, |
| const std::vector< std::vector< unsigned int > > & | g_I, | ||
| block_matrix & | g_A_I_J_vcl, | ||
| block_vector & | g_bv_vcl, | ||
| block_matrix & | g_A_I_J_u_vcl, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| viennacl::context | ctx | ||
| ) |
Performs multiplication Q'*A(I, \tilde J) on GPU.
| g_J_u | container of sets of new column indices |
| g_I | container of row indices |
| g_A_I_J_vcl | block matrix composed from previous blocks, they are blocks of R |
| g_bv_vcl | block of beta vectors |
| g_A_I_J_u_vcl | block of matrices A(I, \tilde J) |
| g_is_update | indicators, that show if a certain block should be processed |
| ctx | Optional context in which the auxiliary data is created (one out of multiple OpenCL contexts, CUDA, host) |
| void viennacl::linalg::detail::spai::block_qr | ( | std::vector< std::vector< unsigned int > > & | g_I, |
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| block_matrix & | g_A_I_J_vcl, | ||
| block_vector & | g_bv_vcl, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| viennacl::context | ctx | ||
| ) |
Inplace QR factorization via Householder reflections c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.224 performed on GPU.
| g_I | container of row indices |
| g_J | container of column indices |
| g_A_I_J_vcl | contigious matrices, GPU memory is used |
| g_bv_vcl | contigiuos vectors beta, GPU memory is used |
| g_is_update | container of indicators that show active blocks |
| ctx | Optional context in which the auxiliary data is created (one out of multiple OpenCL contexts, CUDA, host) |
| void viennacl::linalg::detail::spai::block_set_up | ( | const SparseMatrixType & | A, |
| const std::vector< SparseVectorType > & | A_v_c, | ||
| const std::vector< SparseVectorType > & | M_v, | ||
| std::vector< std::vector< unsigned int > > & | g_I, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| std::vector< DenseMatrixType > & | g_A_I_J, | ||
| std::vector< VectorType > & | g_b_v | ||
| ) |
Setting up blocks and QR factorizing them on CPU.
| A | initial sparse matrix |
| A_v_c | column major vectorized initial sparse matrix |
| M_v | initialized preconditioner |
| g_I | container of row indices |
| g_J | container of column indices |
| g_A_I_J | container of dense matrices -> R matrices after QR factorization |
| g_b_v | container of vectors beta, necessary for Q recovery |
| void viennacl::linalg::detail::spai::block_set_up | ( | const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > & | A, |
| const std::vector< SparseVectorType > & | A_v_c, | ||
| const std::vector< SparseVectorType > & | M_v, | ||
| std::vector< cl_uint > | g_is_update, | ||
| std::vector< std::vector< unsigned int > > & | g_I, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| block_matrix & | g_A_I_J, | ||
| block_vector & | g_bv | ||
| ) |
Setting up blocks and QR factorizing them on GPU.
| A | initial sparse matrix |
| A_v_c | column major vectorized initial sparse matrix |
| M_v | initialized preconditioner |
| g_is_update | container that indicates which blocks are active |
| g_I | container of row indices |
| g_J | container of column indices |
| g_A_I_J | container of dense matrices -> R matrices after QR factorization |
| g_bv | container of vectors beta, necessary for Q recovery |
| void viennacl::linalg::detail::spai::block_update | ( | const SparseMatrixType & | A, |
| const std::vector< SparseVectorType > & | A_v_c, | ||
| std::vector< SparseVectorType > & | g_res, | ||
| std::vector< bool > & | g_is_update, | ||
| std::vector< std::vector< unsigned int > > & | g_I, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| std::vector< VectorType > & | g_b_v, | ||
| std::vector< DenseMatrixType > & | g_A_I_J, | ||
| spai_tag const & | tag | ||
| ) |
CPU-based dynamic update for SPAI preconditioner.
| A | initial sparse matrix |
| A_v_c | vectorized column-wise initial matrix |
| g_res | container of residuals for all columns |
| g_is_update | container with identificators that shows which block should be modified |
| g_I | container of row index sets for all columns |
| g_J | container of column index sets for all columns |
| g_b_v | container of vectors of beta for Q recovery(cf. Golub Van Loan "Matrix Computations", 3rd edition p.211) |
| g_A_I_J | container of block matrices from previous update |
| tag | SPAI configuration tag |
| void viennacl::linalg::detail::spai::block_update | ( | const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > & | A, |
| const std::vector< SparseVectorType > & | A_v_c, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| std::vector< SparseVectorType > & | g_res, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| std::vector< std::vector< unsigned int > > & | g_I, | ||
| block_matrix & | g_A_I_J_vcl, | ||
| block_vector & | g_bv_vcl, | ||
| spai_tag const & | tag | ||
| ) |
GPU-based block update.
| A | sparse matrix |
| A_v_c | vectorized column-wise initial matrix |
| g_is_update | container with identificators that shows which block should be modified |
| g_res | container of residuals for all columns |
| g_J | container of column index sets for all columns |
| g_I | container of row index sets for all columns |
| g_A_I_J_vcl | container of block matrices from previous update |
| g_bv_vcl | block of beta vectors from previous iteration |
| tag | SPAI configuration tag |
| void viennacl::linalg::detail::spai::build_index_set | ( | const std::vector< SparseVectorType > & | A_v_c, |
| const SparseVectorType & | v, | ||
| std::vector< unsigned int > & | J, | ||
| std::vector< unsigned int > & | I | ||
| ) |
Setting up index set of columns and rows for certain column.
| A_v_c | column major vectorized initial sparse matrix |
| v | current column of preconditioner matrix |
| J | set of column indices |
| I | set of row indices |
| bool viennacl::linalg::detail::spai::buildAugmentedIndexSet | ( | const std::vector< SparseVectorType > & | A_v_c, |
| const SparseVectorType & | res, | ||
| std::vector< unsigned int > & | J, | ||
| std::vector< unsigned int > & | J_u, | ||
| const spai_tag & | tag | ||
| ) |
Building a new set of column indices J_u, cf. Kallischko dissertation p.31.
| A_v_c | vectorized column-wise initial matrix |
| res | residual vector |
| J | set of column indices |
| J_u | set of new column indices |
| tag | SPAI tag with parameters |
| void viennacl::linalg::detail::spai::buildColumnIndexSet | ( | const SparseVectorType & | v, |
| std::vector< unsigned int > & | J | ||
| ) |
Builds index set of projected columns for current column of preconditioner.
| v | current column of preconditioner |
| J | output - index set of non-zero columns |
| void viennacl::linalg::detail::spai::buildNewRowSet | ( | const std::vector< SparseVectorType > & | A_v_c, |
| const std::vector< unsigned int > & | I, | ||
| const std::vector< unsigned int > & | J_n, | ||
| std::vector< unsigned int > & | I_n | ||
| ) |
Building a new indices to current set of row indices I_n, cf. Kallischko dissertation p.32.
| A_v_c | vectorized column-wise initial matrix |
| I | set of previous determined row indices |
| J_n | set of new column indices |
| I_n | set of new indices |
| void viennacl::linalg::detail::spai::cholesky_decompose | ( | MatrixType & | A | ) |
| void viennacl::linalg::detail::spai::cholesky_solve | ( | MatrixType const & | L, |
| VectorType & | b | ||
| ) |
| void viennacl::linalg::detail::spai::composeNewR | ( | const MatrixType & | A, |
| const MatrixType & | R_n, | ||
| MatrixType & | R | ||
| ) |
Composition of new matrix R, that is going to be used in Least Square problem solving.
| A | matrix Q'*A(I, \tilde J), where \tilde J - set of new column indices |
| R_n | matrix A_Iu_J_u after QR factorization |
| R | previously composed matrix R |
| void viennacl::linalg::detail::spai::composeNewVector | ( | const VectorType & | v_n, |
| VectorType & | v | ||
| ) |
Composition of new vector of coefficients beta from QR factorizations(necessary for Q recovery)
| v_n | new vector from last QR factorization |
| v | composition of previous vectors from QR factorizations |
| void viennacl::linalg::detail::spai::compute_blocks_size | ( | const std::vector< std::vector< unsigned int > > & | g_I, |
| const std::vector< std::vector< unsigned int > > & | g_J, | ||
| unsigned int & | sz, | ||
| std::vector< cl_uint > & | blocks_ind, | ||
| std::vector< cl_uint > & | matrix_dims | ||
| ) | [inline] |
**************************************** BLOCK FUNCTIONS ************************************//
Computes size of elements, start indices and matrix dimensions for a certain block
| g_I | container of row indices |
| g_J | container of column indices |
| sz | general size for all elements in a certain block |
| blocks_ind | start indices in a certain |
| matrix_dims | matrix dimensions for each block |
| void viennacl::linalg::detail::spai::compute_spai_residual | ( | const std::vector< SparseVectorType > & | A_v_c, |
| const SparseVectorType & | v, | ||
| const unsigned int | ind, | ||
| SparseVectorType & | res | ||
| ) |
Computation of residual res = A*v - e.
| A_v_c | column major vectorized input sparse matrix |
| v | sparse vector, in this case new column of preconditioner matrix |
| ind | index for current column |
| res | residual |
| void viennacl::linalg::detail::spai::computeFSPAI | ( | MatrixType const & | A, |
| MatrixType const & | PatternA, | ||
| MatrixType & | L, | ||
| MatrixType & | L_trans, | ||
| fspai_tag | |||
| ) |
| void viennacl::linalg::detail::spai::computeL | ( | MatrixType const & | A, |
| MatrixType & | L, | ||
| MatrixType & | L_trans, | ||
| std::vector< VectorType1 > & | Y, | ||
| std::vector< std::vector< vcl_size_t > > & | J | ||
| ) |
| void viennacl::linalg::detail::spai::computeSPAI | ( | const MatrixType & | A, |
| MatrixType & | M, | ||
| spai_tag & | tag | ||
| ) |
Construction of SPAI preconditioner on CPU.
| A | initial sparse matrix |
| M | output preconditioner |
| tag | spai tag |
| void viennacl::linalg::detail::spai::computeSPAI | ( | const viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > & | A, |
| const boost::numeric::ublas::compressed_matrix< ScalarType > & | cpu_A, | ||
| boost::numeric::ublas::compressed_matrix< ScalarType > & | cpu_M, | ||
| viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > & | M, | ||
| const spai_tag & | tag | ||
| ) |
Construction of SPAI preconditioner on GPU.
| A | initial sparse matrix |
| cpu_A | copy of initial matrix on CPU |
| cpu_M | output preconditioner on CPU |
| M | output preconditioner |
| tag | SPAI tag class with parameters |
| void viennacl::linalg::detail::spai::copy_vector | ( | const MatrixType & | A, |
| VectorType & | v, | ||
| const unsigned int | beg_ind | ||
| ) |
Copying part of matrix column.
| A | init matrix |
| v | output vector |
| beg_ind | start index for copying |
| void viennacl::linalg::detail::spai::custom_dot_prod | ( | const MatrixType & | A, |
| const VectorType & | v, | ||
| unsigned int | ind, | ||
| ScalarType & | res | ||
| ) |
Dot_prod(column(A, ind), v) starting from index ind+1.
| A | input matrix |
| v | input vector |
| ind | index |
| res | result value |
| void viennacl::linalg::detail::spai::custom_fan_out | ( | const std::vector< ScalarType > & | m_in, |
| unsigned int | start_m_ind, | ||
| const std::vector< unsigned int > & | J, | ||
| SparseVectorType & | m | ||
| ) |
Elicitation of sparse vector m for particular column from m_in - contigious vector for all columns.
| m_in | contigious sparse vector for all columns |
| start_m_ind | start index of particular vector |
| J | column index set |
| m | sparse vector for particular column |
| void viennacl::linalg::detail::spai::custom_inner_prod | ( | const MatrixType & | A, |
| const VectorType & | v, | ||
| unsigned int | col_ind, | ||
| unsigned int | start_ind, | ||
| ScalarType & | res | ||
| ) |
Dot prod of particular matrix column with arbitrary vector: A(:, col_ind)
| A | init matrix |
| v | input vector |
| col_ind | starting column index |
| start_ind | starting index inside column |
| res | result of dot product |
| double viennacl::linalg::detail::spai::determinant | ( | boost::numeric::ublas::matrix_expression< MatrixType > const & | mat_r | ) |
| void viennacl::linalg::detail::spai::dot_prod | ( | const MatrixType & | A, |
| unsigned int | beg_ind, | ||
| ScalarType & | res | ||
| ) |
Dot prod of particular column of martix A with it's self starting at a certain index beg_ind.
| A | init matrix |
| beg_ind | starting index |
| res | result of dot product |
| void viennacl::linalg::detail::spai::fanOutVector | ( | const VectorType & | m_in, |
| const std::vector< unsigned int > & | J, | ||
| SparseVectorType & | m | ||
| ) |
Projects solution of LS problem onto original column m.
| m_in | solution of LS |
| J | set of non-zero columns |
| m | original column of M |
| void viennacl::linalg::detail::spai::fill_blocks | ( | std::vector< std::map< unsigned int, ScalarType > > & | A, |
| std::vector< MatrixType > & | blocks, | ||
| std::vector< std::vector< vcl_size_t > > const & | J, | ||
| std::vector< VectorType > & | Y | ||
| ) |
| void viennacl::linalg::detail::spai::generateJ | ( | MatrixType const & | A, |
| std::vector< std::vector< vcl_size_t > > & | J | ||
| ) |
| void viennacl::linalg::detail::spai::get_max_block_size | ( | const std::vector< std::vector< SizeType > > & | inds, |
| SizeType & | max_size | ||
| ) |
Getting max size of rows/columns from container of index set.
| inds | container of index set |
| max_size | max size that corresponds to that container |
| void viennacl::linalg::detail::spai::get_size | ( | const std::vector< std::vector< SizeType > > & | inds, |
| SizeType & | size | ||
| ) |
Computes size of particular container of index set.
| inds | container of index sets |
| size | output size |
| void viennacl::linalg::detail::spai::householder_vector | ( | const MatrixType & | A, |
| unsigned int | j, | ||
| VectorType & | v, | ||
| ScalarType & | b | ||
| ) |
Coputation of Householder vector, householder reflection c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.210.
| A | init matrix |
| j | start index for computations |
| v | output Householder vector |
| b | beta |
| void viennacl::linalg::detail::spai::index_set_up | ( | const std::vector< SparseVectorType > & | A_v_c, |
| const std::vector< SparseVectorType > & | M_v, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| std::vector< std::vector< unsigned int > > & | g_I | ||
| ) |
Setting up index set of columns and rows for all columns.
| A_v_c | column major vectorized initial sparse matrix |
| M_v | initialized preconditioner |
| g_J | container of column indices |
| g_I | container of row indices |
| void viennacl::linalg::detail::spai::init_start_inds | ( | const std::vector< std::vector< SizeType > > & | inds, |
| std::vector< cl_uint > & | start_inds | ||
| ) |
Initializes start indices of particular index set.
| inds | container of index sets |
| start_inds | output index set |
| void viennacl::linalg::detail::spai::initPreconditioner | ( | const SparseMatrixType & | A, |
| SparseMatrixType & | M | ||
| ) |
Initialize preconditioner with sparcity pattern = p(A)
| A | input matrix |
| M | output matrix - initialized preconditioner |
| void viennacl::linalg::detail::spai::initProjectSubMatrix | ( | const SparseMatrixType & | A_in, |
| const std::vector< unsigned int > & | J, | ||
| std::vector< unsigned int > & | I, | ||
| DenseMatrixType & | A_out | ||
| ) |
Initializes a dense matrix from a sparse one.
| A_in | Riginal sparse matrix |
| J | Set of column indices |
| I | Set of row indices |
| A_out | dense matrix output |
| void viennacl::linalg::detail::spai::insert_sparse_columns | ( | const std::vector< SparseVectorType > & | M_v, |
| SparseMatrixType & | M, | ||
| bool | is_right | ||
| ) |
Insertion of vectorized matrix column into original sparse matrix.
| M_v | column-major vectorized matrix |
| M | original sparse matrix |
| is_right | indicates if matrix should be transposed in the output |
| bool viennacl::linalg::detail::spai::is_all_update | ( | VectorType & | parallel_is_update | ) |
| bool viennacl::linalg::detail::spai::isInIndexSet | ( | const std::vector< SizeType > & | J, |
| SizeType | ind | ||
| ) |
Determines if element ind is in set {J}.
| J | current set |
| ind | current element |
| void viennacl::linalg::detail::spai::least_square_solve | ( | std::vector< SparseVectorType > & | A_v_c, |
| std::vector< SparseVectorType > & | M_v, | ||
| std::vector< std::vector< unsigned int > > & | g_I, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| block_matrix & | g_A_I_J_vcl, | ||
| block_vector & | g_bv_vcl, | ||
| std::vector< SparseVectorType > & | g_res, | ||
| std::vector< cl_uint > & | g_is_update, | ||
| const spai_tag & | tag, | ||
| viennacl::context | ctx | ||
| ) |
Solution of Least square problem on GPU.
| A_v_c | column-major vectorized initial sparse matrix |
| M_v | column-major vectorized sparse preconditioner matrix |
| g_I | container of row set indices |
| g_J | container of column set indices |
| g_A_I_J_vcl | contigious matrix that consists of blocks A(I_k, J_k) |
| g_bv_vcl | contigious vector that consists of betas, necessary for Q recovery |
| g_res | container of residuals |
| g_is_update | container with indicators which blocks are active |
| tag | spai tag |
| ctx | Optional context in which the auxiliary data is created (one out of multiple OpenCL contexts, CUDA, host) |
| void viennacl::linalg::detail::spai::least_square_solve | ( | const std::vector< SparseVectorType > & | A_v_c, |
| std::vector< DenseMatrixType > & | g_R, | ||
| std::vector< VectorType > & | g_b_v, | ||
| std::vector< std::vector< unsigned int > > & | g_I, | ||
| std::vector< std::vector< unsigned int > > & | g_J, | ||
| std::vector< SparseVectorType > & | g_res, | ||
| std::vector< bool > & | g_is_update, | ||
| std::vector< SparseVectorType > & | M_v, | ||
| const spai_tag & | tag | ||
| ) |
Solution of Least square problem on CPU.
| A_v_c | column-major vectorized initial sparse matrix |
| g_R | blocks for least square solution |
| g_b_v | vectors beta, necessary for Q recovery |
| g_I | container of row index set for all columns of matrix M |
| g_J | container of column index set for all columns of matrix M |
| g_res | container of residuals |
| g_is_update | container with indicators which blocks are active |
| M_v | column-major vectorized sparse matrix, final preconditioner |
| tag | spai tag |
| void viennacl::linalg::detail::spai::make_rotation_matrix | ( | MatrixType & | mat, |
| vcl_size_t | new_size, | ||
| vcl_size_t | off_diagonal_distance = 4 |
||
| ) |
| void viennacl::linalg::detail::spai::Print | ( | std::ostream & | ostr, |
| InputIterator | it_begin, | ||
| InputIterator | it_end | ||
| ) |
| void viennacl::linalg::detail::spai::print_continious_matrix | ( | VectorType & | con_A_I_J, |
| std::vector< cl_uint > & | blocks_ind, | ||
| const std::vector< std::vector< unsigned int > > & | g_I, | ||
| const std::vector< std::vector< unsigned int > > & | g_J | ||
| ) |
| void viennacl::linalg::detail::spai::print_continious_vector | ( | VectorType & | con_v, |
| std::vector< cl_uint > & | block_ind, | ||
| const std::vector< std::vector< unsigned int > > & | g_J | ||
| ) |
| void viennacl::linalg::detail::spai::print_matrix | ( | DenseMatrixType & | m | ) |
| void viennacl::linalg::detail::spai::print_sparse_vector | ( | const SparseVectorType & | v | ) |
| void viennacl::linalg::detail::spai::projectI | ( | const std::vector< unsigned int > & | I, |
| VectorType & | y, | ||
| unsigned int | ind | ||
| ) |
Perform projection of set I on the unit-vector.
| I | set of non-zero rows |
| y | result vector |
| ind | index of unit vector |
| void viennacl::linalg::detail::spai::projectRows | ( | const std::vector< SparseVectorType > & | A_v_c, |
| const std::vector< unsigned int > & | J, | ||
| std::vector< unsigned int > & | I | ||
| ) |
Row projection for matrix A(:,J) -> A(I,J), building index set of non-zero rows.
| A_v_c | input matrix |
| J | set of non-zero rows |
| I | output matrix |
| void viennacl::linalg::detail::spai::QRBlockComposition | ( | const MatrixType & | A_I_J, |
| const MatrixType & | A_I_J_u, | ||
| MatrixType & | A_I_u_J_u | ||
| ) |
Composition of new block for QR factorization cf. Kallischko dissertation p.82, figure 4.7.
| A_I_J | previously composed block |
| A_I_J_u | matrix Q'*A(I, \tilde J), where \tilde J - set of new column indices |
| A_I_u_J_u | is composition of lower part A(I, \tilde J) and A(\tilde I, \tilde J) - new block for QR decomposition |
| void viennacl::linalg::detail::spai::single_qr | ( | MatrixType & | R, |
| VectorType & | b_v | ||
| ) |
Inplace QR factorization via Householder reflections c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.224.
| R | input matrix |
| b_v | vector of betas |
| void viennacl::linalg::detail::spai::sparse_inner_prod | ( | const SparseVectorType & | v1, |
| const SparseVectorType & | v2, | ||
| ScalarType & | res_v | ||
| ) |
Dot product of two sparse vectors.
| v1 | initial sparse vector |
| v2 | initial sparse vector |
| res_v | scalar that represents dot product result |
| void viennacl::linalg::detail::spai::sparse_norm_2 | ( | const SparseVectorType & | v, |
| ScalarType & | norm | ||
| ) |
Computation of Euclidean norm for sparse vector.
| v | initial sparse vector |
| norm | scalar that represents Euclidean norm |
| void viennacl::linalg::detail::spai::sparse_transpose | ( | const MatrixType & | A_in, |
| MatrixType & | A | ||
| ) |
Transposition of sparse matrix.
| A_in | intial sparse matrix |
| A | output transposed matrix |
| void viennacl::linalg::detail::spai::store_householder_vector | ( | MatrixType & | A, |
| unsigned int | ind, | ||
| VectorType & | v | ||
| ) |
Storage of vector v in column(A, ind), starting from ind-1 index of a column.
| A | init matrix |
| ind | index of a column |
| v | vector that should be stored |
| void viennacl::linalg::detail::spai::sym_sparse_matrix_to_stl | ( | MatrixType const & | A, |
| std::vector< std::map< unsigned int, ScalarType > > & | STL_A | ||
| ) |
| void viennacl::linalg::detail::spai::vectorize_column_matrix | ( | const SparseMatrixType & | M_in, |
| std::vector< SparseVectorType > & | M_v | ||
| ) |
Solution of Least square problem on CPU.
| M_in | input sparse, boost::numeric::ublas::compressed_matrix |
| M_v | array of sparse vectors |
| void viennacl::linalg::detail::spai::vectorize_row_matrix | ( | const SparseMatrixType & | M_in, |
| std::vector< SparseVectorType > & | M_v | ||
| ) |
| void viennacl::linalg::detail::spai::write_set_to_array | ( | const std::vector< std::vector< SizeType > > & | ind_set, |
| std::vector< cl_uint > & | a | ||
| ) |
| void viennacl::linalg::detail::spai::write_to_block | ( | VectorType & | con_A_I_J, |
| unsigned int | start_ind, | ||
| const std::vector< unsigned int > & | I, | ||
| const std::vector< unsigned int > & | J, | ||
| MatrixType & | m | ||
| ) |
1.7.6.1