ViennaCL - The Vienna Computing Library: viennacl::linalg::detail::spai Namespace Reference

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Functions
viennacl::linalg::detail::spai Namespace Reference

Implementation namespace for sparse approximate inverse preconditioner. More...

## Classes
class | block_matrix
| Represents contigious matrices on GPU. More...
class | block_vector
| Represents a contiguous vector on the GPU to represent a concatentation of small vectors. More...
struct | CompareSecond
| Helper functor for comparing std::pair<> based on the second member. More...
class | fspai_tag
| A tag for FSPAI. Experimental. More...
class | spai_tag
| A tag for SPAI. More...
class | sparse_vector
| Represents a sparse vector based on std::map<unsigned int, NumericT> More...

## Functions
template<typename MatrixT , typename NumericT >
void | sym_sparse_matrix_to_stl (MatrixT const &A, std::vector< std::map< unsigned int, NumericT > > &STL_A)
template<typename MatrixT >
void | generateJ (MatrixT const &A, std::vector< std::vector< vcl_size_t > > &J)
template<typename NumericT , typename MatrixT , typename VectorT >
void | fill_blocks (std::vector< std::map< unsigned int, NumericT > > &A, std::vector< MatrixT > &blocks, std::vector< std::vector< vcl_size_t > > const &J, std::vector< VectorT > &Y)
template<typename MatrixT >
void | cholesky_decompose (MatrixT &A)
template<typename MatrixT , typename VectorT >
void | cholesky_solve (MatrixT const &L, VectorT &b)
template<typename MatrixT , typename VectorT >
void | computeL (MatrixT const &A, MatrixT &L, MatrixT &L_trans, std::vector< VectorT > &Y, std::vector< std::vector< vcl_size_t > > &J)
template<typename MatrixT >
void | computeFSPAI (MatrixT const &A, MatrixT const &PatternA, MatrixT &L, MatrixT &L_trans, fspai_tag)
template<typename T , typename InputIteratorT >
void | Print (std::ostream &ostr, InputIteratorT it_begin, InputIteratorT it_end)
template<typename VectorT , typename MatrixT >
void | write_to_block (VectorT &con_A_I_J, unsigned int start_ind, std::vector< unsigned int > const &I, std::vector< unsigned int > const &J, MatrixT &m)
template<typename VectorT >
void | print_continious_matrix (VectorT &con_A_I_J, std::vector< cl_uint > &blocks_ind, std::vector< std::vector< unsigned int > > const &g_I, std::vector< std::vector< unsigned int > > const &g_J)
template<typename VectorT >
void | print_continious_vector (VectorT &con_v, std::vector< cl_uint > &block_ind, std::vector< std::vector< unsigned int > > const &g_J)
void | compute_blocks_size (std::vector< std::vector< unsigned int > > const &g_I, std::vector< std::vector< unsigned int > > const &g_J, unsigned int &sz, std::vector< cl_uint > &blocks_ind, std::vector< cl_uint > &matrix_dims)
| **************************************** BLOCK FUNCTIONS ************************************// More...
template<typename SizeT >
void | get_size (std::vector< std::vector< SizeT > > const &inds, SizeT &size)
| Computes size of particular container of index set. More...
template<typename SizeT >
void | init_start_inds (std::vector< std::vector< SizeT > > const &inds, std::vector< cl_uint > &start_inds)
| Initializes start indices of particular index set. More...
template<typename MatrixT , typename NumericT >
void | dot_prod (MatrixT const &A, unsigned int beg_ind, NumericT &res)
| Dot prod of particular column of martix A with it's self starting at a certain index beg_ind. More...
template<typename MatrixT , typename VectorT , typename NumericT >
void | custom_inner_prod (MatrixT const &A, VectorT const &v, unsigned int col_ind, unsigned int start_ind, NumericT &res)
| Dot prod of particular matrix column with arbitrary vector: A(:, col_ind) More...
template<typename MatrixT , typename VectorT >
void | copy_vector (MatrixT const &A, VectorT &v, unsigned int beg_ind)
| Copying part of matrix column. More...
template<typename MatrixT , typename VectorT , typename NumericT >
void | householder_vector (MatrixT const &A, unsigned int j, VectorT &v, NumericT &b)
| Computation of Householder vector, householder reflection c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.210. More...
template<typename MatrixT , typename VectorT , typename NumericT >
void | apply_householder_reflection (MatrixT &A, unsigned int iter_cnt, VectorT &v, NumericT b)
| Inplace application of Householder vector to a matrix A. More...
template<typename MatrixT , typename VectorT >
void | store_householder_vector (MatrixT &A, unsigned int ind, VectorT &v)
| Storage of vector v in column(A, ind), starting from ind-1 index of a column. More...
template<typename MatrixT , typename VectorT >
void | single_qr (MatrixT &R, VectorT &b_v)
| Inplace QR factorization via Householder reflections c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.224. More...
template<typename SizeT >
void | get_max_block_size (std::vector< std::vector< SizeT > > const &inds, SizeT &max_size)
| Getting max size of rows/columns from container of index set. More...
template<typename MatrixT , typename VectorT , typename NumericT >
void | custom_dot_prod (MatrixT const &A, VectorT const &v, unsigned int ind, NumericT &res)
| Dot_prod(column(A, ind), v) starting from index ind+1. More...
template<typename MatrixT , typename VectorT >
void | apply_q_trans_vec (MatrixT const &R, VectorT const &b_v, VectorT &y)
| Recovery Q from matrix R and vector of betas b_v. More...
template<typename MatrixT , typename VectorT >
void | apply_q_trans_mat (MatrixT const &R, VectorT const &b_v, MatrixT &A)
| Multiplication of Q'*A, where Q is in implicit for lower part of R and vector of betas - b_v. More...
template<typename NumericT >
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. More...
template<typename MatrixT >
void | make_rotation_matrix (MatrixT &mat, vcl_size_t new_size, vcl_size_t off_diagonal_distance=4)
template<typename MatrixT >
double | determinant (boost::numeric::ublas::matrix_expression< MatrixT > const &mat_r)
template<typename MatrixT >
void | composeNewR (MatrixT const &A, MatrixT const &R_n, MatrixT &R)
| Composition of new matrix R, that is going to be used in Least Square problem solving. More...
template<typename VectorT >
void | composeNewVector (VectorT const &v_n, VectorT &v)
| Composition of new vector of coefficients beta from QR factorizations(necessary for Q recovery) More...
template<typename SparseVectorT , typename NumericT >
void | sparse_norm_2 (SparseVectorT const &v, NumericT &norm)
| Computation of Euclidean norm for sparse vector. More...
template<typename SparseVectorT , typename NumericT >
void | sparse_inner_prod (SparseVectorT const &v1, SparseVectorT const &v2, NumericT &res_v)
| Dot product of two sparse vectors. More...
template<typename SparseVectorT , typename NumericT >
bool | buildAugmentedIndexSet (std::vector< SparseVectorT > const &A_v_c, SparseVectorT const &res, std::vector< unsigned int > &J, std::vector< unsigned int > &J_u, spai_tag const &tag)
| Building a new set of column indices J_u, cf. Kallischko dissertation p.31. More...
template<typename SparseVectorT >
void | buildNewRowSet (std::vector< SparseVectorT > const &A_v_c, std::vector< unsigned int > const &I, std::vector< unsigned int > const &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. More...
template<typename MatrixT >
void | QRBlockComposition (MatrixT const &A_I_J, MatrixT const &A_I_J_u, MatrixT &A_I_u_J_u)
| Composition of new block for QR factorization cf. Kallischko dissertation p.82, figure 4.7. More...
template<typename SparseMatrixT , typename SparseVectorT , typename DenseMatrixT , typename VectorT >
void | block_update (SparseMatrixT const &A, std::vector< SparseVectorT > const &A_v_c, std::vector< SparseVectorT > &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< VectorT > &g_b_v, std::vector< DenseMatrixT > &g_A_I_J, spai_tag const &tag)
| CPU-based dynamic update for SPAI preconditioner. More...
template<typename NumericT >
void | block_q_multiplication (std::vector< std::vector< unsigned int > > const &g_J_u, std::vector< std::vector< unsigned int > > const &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. More...
template<typename SizeT >
void | assemble_qr_row_inds (std::vector< std::vector< SizeT > > const &g_I, std::vector< std::vector< SizeT > > const &g_J, std::vector< std::vector< SizeT > > const &g_I_u, std::vector< std::vector< SizeT > > &g_I_q)
| Assembly of container of index row sets: I_q, row indices for new "QR block". More...
template<typename NumericT >
void | assemble_qr_block (std::vector< std::vector< unsigned int > > const &g_J, std::vector< std::vector< unsigned int > > const &g_I, std::vector< std::vector< unsigned int > > const &g_J_u, std::vector< std::vector< unsigned int > > const &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, bool is_empty_block, viennacl::context ctx)
| Performs assembly for new QR block. More...
template<typename NumericT >
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. More...
template<typename NumericT , unsigned int AlignmentV, typename SparseVectorT >
void | block_update (viennacl::compressed_matrix< NumericT, AlignmentV > const &A, std::vector< SparseVectorT > const &A_v_c, std::vector< cl_uint > &g_is_update, std::vector< SparseVectorT > &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. More...
template<typename SizeT >
bool | isInIndexSet (std::vector< SizeT > const &J, SizeT ind)
| Determines if element ind is in set {J}. More...
template<typename VectorT , typename SparseVectorT >
void | fanOutVector (VectorT const &m_in, std::vector< unsigned int > const &J, SparseVectorT &m)
| Projects solution of LS problem onto original column m. More...
template<typename MatrixT , typename VectorT >
void | backwardSolve (MatrixT const &R, VectorT const &y, VectorT &x)
| Solution of linear:R*x=y system by backward substitution. More...
template<typename VectorT , typename NumericT >
void | projectI (std::vector< unsigned int > const &I, VectorT &y, unsigned int ind)
| Perform projection of set I on the unit-vector. More...
template<typename SparseVectorT >
void | buildColumnIndexSet (SparseVectorT const &v, std::vector< unsigned int > &J)
| Builds index set of projected columns for current column of preconditioner. More...
template<typename SparseMatrixT >
void | initPreconditioner (SparseMatrixT const &A, SparseMatrixT &M)
| Initialize preconditioner with sparcity pattern = p(A) More...
template<typename SparseVectorT >
void | projectRows (std::vector< SparseVectorT > const &A_v_c, std::vector< unsigned int > const &J, std::vector< unsigned int > &I)
| Row projection for matrix A(:,J) -> A(I,J), building index set of non-zero rows. More...
template<typename SparseVectorT >
void | print_sparse_vector (SparseVectorT const &v)
template<typename DenseMatrixT >
void | print_matrix (DenseMatrixT &m)
template<typename SparseVectorT , typename NumericT >
void | add_sparse_vectors (SparseVectorT const &v, NumericT b, SparseVectorT &res_v)
| Add two sparse vectors res_v = b*v. More...
template<typename SparseVectorT , typename NumericT >
void | compute_spai_residual (std::vector< SparseVectorT > const &A_v_c, SparseVectorT const &v, unsigned int ind, SparseVectorT &res)
| Computation of residual res = A*v - e. More...
template<typename SparseVectorT >
void | build_index_set (std::vector< SparseVectorT > const &A_v_c, SparseVectorT const &v, std::vector< unsigned int > &J, std::vector< unsigned int > &I)
| Setting up index set of columns and rows for certain column. More...
template<typename SparseMatrixT , typename DenseMatrixT >
void | initProjectSubMatrix (SparseMatrixT const &A_in, std::vector< unsigned int > const &J, std::vector< unsigned int > &I, DenseMatrixT &A_out)
| Initializes a dense matrix from a sparse one. More...
template<typename SparseMatrixT , typename DenseMatrixT , typename SparseVectorT , typename VectorT >
void | block_set_up (SparseMatrixT const &A, std::vector< SparseVectorT > const &A_v_c, std::vector< SparseVectorT > const &M_v, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, std::vector< DenseMatrixT > &g_A_I_J, std::vector< VectorT > &g_b_v)
| Setting up blocks and QR factorizing them on CPU. More...
template<typename SparseVectorT >
void | index_set_up (std::vector< SparseVectorT > const &A_v_c, std::vector< SparseVectorT > const &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. More...
template<typename NumericT , unsigned int AlignmentV, typename SparseVectorT >
void | block_set_up (viennacl::compressed_matrix< NumericT, AlignmentV > const &A, std::vector< SparseVectorT > const &A_v_c, std::vector< SparseVectorT > const &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. More...
template<typename NumericT , typename SparseVectorT >
void | custom_fan_out (std::vector< NumericT > const &m_in, unsigned int start_m_ind, std::vector< unsigned int > const &J, SparseVectorT &m)
| Elicitation of sparse vector m for particular column from m_in - contigious vector for all columns. More...
template<typename SparseVectorT , typename NumericT >
void | least_square_solve (std::vector< SparseVectorT > &A_v_c, std::vector< SparseVectorT > &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< SparseVectorT > &g_res, std::vector< cl_uint > &g_is_update, const spai_tag &tag, viennacl::context ctx)
| Solution of Least square problem on GPU. More...
template<typename SparseVectorT , typename DenseMatrixT , typename VectorT >
void | least_square_solve (std::vector< SparseVectorT > const &A_v_c, std::vector< DenseMatrixT > &g_R, std::vector< VectorT > &g_b_v, std::vector< std::vector< unsigned int > > &g_I, std::vector< std::vector< unsigned int > > &g_J, std::vector< SparseVectorT > &g_res, std::vector< bool > &g_is_update, std::vector< SparseVectorT > &M_v, spai_tag const &tag)
| Solution of Least square problem on CPU. More...
template<typename VectorType >
bool | is_all_update (VectorType &parallel_is_update)
template<typename SparseMatrixT , typename SparseVectorT >
void | vectorize_column_matrix (SparseMatrixT const &M_in, std::vector< SparseVectorT > &M_v)
| Solution of Least square problem on CPU. More...
template<typename SparseMatrixT , typename SparseVectorT >
void | vectorize_row_matrix (SparseMatrixT const &M_in, std::vector< SparseVectorT > &M_v)
template<typename SizeT >
void | write_set_to_array (std::vector< std::vector< SizeT > > const &ind_set, std::vector< cl_uint > &a)
template<typename NumericT , unsigned int AlignmentV>
void | block_assembly (viennacl::compressed_matrix< NumericT, AlignmentV > const &A, std::vector< std::vector< unsigned int > > const &g_J, std::vector< std::vector< unsigned int > > const &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. More...
template<typename SparseMatrixT , typename SparseVectorT >
void | insert_sparse_columns (std::vector< SparseVectorT > const &M_v, SparseMatrixT &M, bool is_right)
| Insertion of vectorized matrix column into original sparse matrix. More...
template<typename MatrixT >
void | sparse_transpose (MatrixT const &A_in, MatrixT &A)
| Transposition of sparse matrix. More...
template<typename MatrixT >
void | computeSPAI (MatrixT const &A, MatrixT &M, spai_tag &tag)
| Construction of SPAI preconditioner on CPU. More...
template<typename NumericT , unsigned int AlignmentV>
void | computeSPAI (viennacl::compressed_matrix< NumericT, AlignmentV > const &A, boost::numeric::ublas::compressed_matrix< NumericT > const &cpu_A, boost::numeric::ublas::compressed_matrix< NumericT > &cpu_M, viennacl::compressed_matrix< NumericT, AlignmentV > &M, spai_tag const &tag)
| Construction of SPAI preconditioner on GPU. More...

## Detailed Description

Implementation namespace for sparse approximate inverse preconditioner.

## Function Documentation

template<typename SparseVectorT , typename NumericT >

void viennacl::linalg::detail::spai::add_sparse_vectors | ( | SparseVectorT const & | v,
|  | NumericT | b,
|  | SparseVectorT & | res_v
| ) |  |

Add two sparse vectors res_v = b*v.

Parameters

  v | initial sparse vector
  b | scalar
  res_v | output vector

Definition at line 105 of file spai.hpp.

template<typename MatrixT , typename VectorT , typename NumericT >

void viennacl::linalg::detail::spai::apply_householder_reflection | ( | MatrixT & | A,
|  | unsigned int | iter_cnt,
|  | VectorT & | v,
|  | NumericT | b
| ) |  |

Inplace application of Householder vector to a matrix A.

Parameters

  A | init matrix
  iter_cnt | current iteration
  v | Householder vector
  b | beta

Definition at line 271 of file qr.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::apply_q_trans_mat | ( | MatrixT const & | R,
|  | VectorT const & | b_v,
|  | MatrixT & | A
| ) |  |

Multiplication of Q'*A, where Q is in implicit for lower part of R and vector of betas - b_v.

Parameters

  R | input matrix
  b_v | vector of betas
  A | output matrix

Definition at line 404 of file qr.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::apply_q_trans_vec | ( | MatrixT const & | R,
|  | VectorT const & | b_v,
|  | VectorT & | y
| ) |  |

Recovery Q from matrix R and vector of betas b_v.

Parameters

  R | input matrix
  b_v | vector of betas
  y | output vector

Definition at line 377 of file qr.hpp.

template<typename NumericT >

void viennacl::linalg::detail::spai::assemble_qr_block | ( | std::vector< std::vector< unsigned int > > const & | g_J,
|  | std::vector< std::vector< unsigned int > > const & | g_I,
|  | std::vector< std::vector< unsigned int > > const & | g_J_u,
|  | std::vector< std::vector< unsigned int > > const & | 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,
|  | bool | is_empty_block,
|  | viennacl::context | ctx
| ) |  |

Performs assembly for new QR block.

Parameters

  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)

Definition at line 439 of file spai-dynamic.hpp.

template<typename SizeT >

void viennacl::linalg::detail::spai::assemble_qr_row_inds | ( | std::vector< std::vector< SizeT > > const & | g_I,
|  | std::vector< std::vector< SizeT > > const & | g_J,
|  | std::vector< std::vector< SizeT > > const & | g_I_u,
|  | std::vector< std::vector< SizeT > > & | g_I_q
| ) |  |

Assembly of container of index row sets: I_q, row indices for new "QR block".

Parameters

  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

Definition at line 406 of file spai-dynamic.hpp.

template<typename NumericT >

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.

Parameters

  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)

Definition at line 533 of file spai-dynamic.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::backwardSolve | ( | MatrixT const & | R,
|  | VectorT const & | y,
|  | VectorT & | x
| ) |  |

Solution of linear:R*x=y system by backward substitution.

Parameters

  R | uppertriangular matrix
  y | right handside vector
  x | solution vector

Definition at line 102 of file spai-static.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::detail::spai::block_assembly | ( | viennacl::compressed_matrix< NumericT, AlignmentV > const & | A,
|  | std::vector< std::vector< unsigned int > > const & | g_J,
|  | std::vector< std::vector< unsigned int > > const & | 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.

Parameters

  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

Definition at line 507 of file spai.hpp.

template<typename NumericT >

void viennacl::linalg::detail::spai::block_q_multiplication | ( | std::vector< std::vector< unsigned int > > const & | g_J_u,
|  | std::vector< std::vector< unsigned int > > const & | 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.

Parameters

  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)

Definition at line 361 of file spai-dynamic.hpp.

template<typename NumericT >

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.

Parameters

  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)

Definition at line 428 of file qr.hpp.

template<typename SparseMatrixT , typename DenseMatrixT , typename SparseVectorT , typename VectorT >

void viennacl::linalg::detail::spai::block_set_up | ( | SparseMatrixT const & | A,
|  | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< SparseVectorT > const & | M_v,
|  | std::vector< std::vector< unsigned int > > & | g_I,
|  | std::vector< std::vector< unsigned int > > & | g_J,
|  | std::vector< DenseMatrixT > & | g_A_I_J,
|  | std::vector< VectorT > & | g_b_v
| ) |  |

Setting up blocks and QR factorizing them on CPU.

Parameters

  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

Definition at line 181 of file spai.hpp.

template<typename NumericT , unsigned int AlignmentV, typename SparseVectorT >

void viennacl::linalg::detail::spai::block_set_up | ( | viennacl::compressed_matrix< NumericT, AlignmentV > const & | A,
|  | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< SparseVectorT > const & | 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.

Parameters

  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

Definition at line 240 of file spai.hpp.

template<typename SparseMatrixT , typename SparseVectorT , typename DenseMatrixT , typename VectorT >

void viennacl::linalg::detail::spai::block_update | ( | SparseMatrixT const & | A,
|  | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< SparseVectorT > & | 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< VectorT > & | g_b_v,
|  | std::vector< DenseMatrixT > & | g_A_I_J,
|  | spai_tag const & | tag
| ) |  |

CPU-based dynamic update for SPAI preconditioner.

Parameters

  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

Definition at line 291 of file spai-dynamic.hpp.

template<typename NumericT , unsigned int AlignmentV, typename SparseVectorT >

void viennacl::linalg::detail::spai::block_update | ( | viennacl::compressed_matrix< NumericT, AlignmentV > const & | A,
|  | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< cl_uint > & | g_is_update,
|  | std::vector< SparseVectorT > & | 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.

Parameters

  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

Definition at line 625 of file spai-dynamic.hpp.

template<typename SparseVectorT >

void viennacl::linalg::detail::spai::build_index_set | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | SparseVectorT const & | v,
|  | std::vector< unsigned int > & | J,
|  | std::vector< unsigned int > & | I
| ) |  |

Setting up index set of columns and rows for certain column.

Parameters

  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

Definition at line 139 of file spai.hpp.

template<typename SparseVectorT , typename NumericT >

bool viennacl::linalg::detail::spai::buildAugmentedIndexSet | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | SparseVectorT const & | res,
|  | std::vector< unsigned int > & | J,
|  | std::vector< unsigned int > & | J_u,
|  | spai_tag const & | tag
| ) |  |

Building a new set of column indices J_u, cf. Kallischko dissertation p.31.

Parameters

  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

Definition at line 188 of file spai-dynamic.hpp.

template<typename SparseVectorT >

void viennacl::linalg::detail::spai::buildColumnIndexSet | ( | SparseVectorT const & | v,
|  | std::vector< unsigned int > & | J
| ) |  |

Builds index set of projected columns for current column of preconditioner.

Parameters

  v | current column of preconditioner
  J | output - index set of non-zero columns

Definition at line 140 of file spai-static.hpp.

template<typename SparseVectorT >

void viennacl::linalg::detail::spai::buildNewRowSet | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< unsigned int > const & | I,
|  | std::vector< unsigned int > const & | 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.

Parameters

  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

Definition at line 228 of file spai-dynamic.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::cholesky_decompose | ( | MatrixT & | A | ) |

Definition at line 210 of file fspai.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::cholesky_solve | ( | MatrixT const & | L,
|  | VectorT & | b
| ) |  |

Definition at line 238 of file fspai.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::composeNewR | ( | MatrixT const & | A,
|  | MatrixT const & | R_n,
|  | MatrixT & | R
| ) |  |

Composition of new matrix R, that is going to be used in Least Square problem solving.

Parameters

  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

Definition at line 94 of file spai-dynamic.hpp.

template<typename VectorT >

void viennacl::linalg::detail::spai::composeNewVector | ( | VectorT const & | v_n,
|  | VectorT & | v
| ) |  |

Composition of new vector of coefficients beta from QR factorizations(necessary for Q recovery)

Parameters

  v_n | new vector from last QR factorization
  v | composition of previous vectors from QR factorizations

Definition at line 124 of file spai-dynamic.hpp.

void viennacl::linalg::detail::spai::compute_blocks_size | ( | std::vector< std::vector< unsigned int > > const & | g_I,
|  | std::vector< std::vector< unsigned int > > const & | 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

Parameters

  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

Definition at line 129 of file qr.hpp.

template<typename SparseVectorT , typename NumericT >

void viennacl::linalg::detail::spai::compute_spai_residual | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | SparseVectorT const & | v,
|  | unsigned int | ind,
|  | SparseVectorT & | res
| ) |  |

Computation of residual res = A*v - e.

Parameters

  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

Definition at line 120 of file spai.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::computeFSPAI | ( | MatrixT const & | A,
|  | MatrixT const & | PatternA,
|  | MatrixT & | L,
|  | MatrixT & | L_trans,
|  | fspai_tag |
| ) |  |

Definition at line 313 of file fspai.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::computeL | ( | MatrixT const & | A,
|  | MatrixT & | L,
|  | MatrixT & | L_trans,
|  | std::vector< VectorT > & | Y,
|  | std::vector< std::vector< vcl_size_t > > & | J
| ) |  |

Definition at line 266 of file fspai.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::computeSPAI | ( | MatrixT const & | A,
|  | MatrixT & | M,
|  | spai_tag & | tag
| ) |  |

Construction of SPAI preconditioner on CPU.

Parameters

  A | initial sparse matrix
  M | output preconditioner
  tag | spai tag

Definition at line 686 of file spai.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::detail::spai::computeSPAI | ( | viennacl::compressed_matrix< NumericT, AlignmentV > const & | A,
|  | boost::numeric::ublas::compressed_matrix< NumericT > const & | cpu_A,
|  | boost::numeric::ublas::compressed_matrix< NumericT > & | cpu_M,
|  | viennacl::compressed_matrix< NumericT, AlignmentV > & | M,
|  | spai_tag const & | tag
| ) |  |

Construction of SPAI preconditioner on GPU.

Parameters

  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

Definition at line 775 of file spai.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::copy_vector | ( | MatrixT const & | A,
|  | VectorT & | v,
|  | unsigned int | beg_ind
| ) |  |

Copying part of matrix column.

Parameters

  A | init matrix
  v | output vector
  beg_ind | start index for copying

Definition at line 218 of file qr.hpp.

template<typename MatrixT , typename VectorT , typename NumericT >

void viennacl::linalg::detail::spai::custom_dot_prod | ( | MatrixT const & | A,
|  | VectorT const & | v,
|  | unsigned int | ind,
|  | NumericT & | res
| ) |  |

Dot_prod(column(A, ind), v) starting from index ind+1.

Parameters

  A | input matrix
  v | input vector
  ind | index
  res | result value

Definition at line 355 of file qr.hpp.

template<typename NumericT , typename SparseVectorT >

void viennacl::linalg::detail::spai::custom_fan_out | ( | std::vector< NumericT > const & | m_in,
|  | unsigned int | start_m_ind,
|  | std::vector< unsigned int > const & | J,
|  | SparseVectorT & | m
| ) |  |

Elicitation of sparse vector m for particular column from m_in - contigious vector for all columns.

Parameters

  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

Definition at line 271 of file spai.hpp.

template<typename MatrixT , typename VectorT , typename NumericT >

void viennacl::linalg::detail::spai::custom_inner_prod | ( | MatrixT const & | A,
|  | VectorT const & | v,
|  | unsigned int | col_ind,
|  | unsigned int | start_ind,
|  | NumericT & | res
| ) |  |

Dot prod of particular matrix column with arbitrary vector: A(:, col_ind)

Parameters

  A | init matrix
  v | input vector
  col_ind | starting column index
  start_ind | starting index inside column
  res | result of dot product

Definition at line 200 of file qr.hpp.

template<typename MatrixT >

double viennacl::linalg::detail::spai::determinant | ( | boost::numeric::ublas::matrix_expression< MatrixT > const & | mat_r | ) |

Definition at line 84 of file small_matrix.hpp.

template<typename MatrixT , typename NumericT >

void viennacl::linalg::detail::spai::dot_prod | ( | MatrixT const & | A,
|  | unsigned int | beg_ind,
|  | NumericT & | res
| ) |  |

Dot prod of particular column of martix A with it's self starting at a certain index beg_ind.

Parameters

  A | init matrix
  beg_ind | starting index
  res | result of dot product

Definition at line 182 of file qr.hpp.

template<typename VectorT , typename SparseVectorT >

void viennacl::linalg::detail::spai::fanOutVector | ( | VectorT const & | m_in,
|  | std::vector< unsigned int > const & | J,
|  | SparseVectorT & | m
| ) |  |

Projects solution of LS problem onto original column m.

Parameters

  m_in | solution of LS
  J | set of non-zero columns
  m | original column of M

Definition at line 88 of file spai-static.hpp.

template<typename NumericT , typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::fill_blocks | ( | std::vector< std::map< unsigned int, NumericT > > & | A,
|  | std::vector< MatrixT > & | blocks,
|  | std::vector< std::vector< vcl_size_t > > const & | J,
|  | std::vector< VectorT > & | Y
| ) |  |

Definition at line 172 of file fspai.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::generateJ | ( | MatrixT const & | A,
|  | std::vector< std::vector< vcl_size_t > > & | J
| ) |  |

Definition at line 145 of file fspai.hpp.

template<typename SizeT >

void viennacl::linalg::detail::spai::get_max_block_size | ( | std::vector< std::vector< SizeT > > const & | inds,
|  | SizeT & | max_size
| ) |  |

Getting max size of rows/columns from container of index set.

Parameters

  inds | container of index set
  max_size | max size that corresponds to that container

Definition at line 338 of file qr.hpp.

template<typename SizeT >

void viennacl::linalg::detail::spai::get_size | ( | std::vector< std::vector< SizeT > > const & | inds,
|  | SizeT & | size
| ) |  |

Computes size of particular container of index set.

Parameters

  inds | container of index sets
  size | output size

Definition at line 151 of file qr.hpp.

template<typename MatrixT , typename VectorT , typename NumericT >

void viennacl::linalg::detail::spai::householder_vector | ( | MatrixT const & | A,
|  | unsigned int | j,
|  | VectorT & | v,
|  | NumericT & | b
| ) |  |

Computation of Householder vector, householder reflection c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.210.

Parameters

  A | init matrix
  j | start index for computations
  v | output Householder vector
  b | beta

Definition at line 236 of file qr.hpp.

template<typename SparseVectorT >

void viennacl::linalg::detail::spai::index_set_up | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< SparseVectorT > const & | 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.

Parameters

  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

Definition at line 211 of file spai.hpp.

template<typename SizeT >

void viennacl::linalg::detail::spai::init_start_inds | ( | std::vector< std::vector< SizeT > > const & | inds,
|  | std::vector< cl_uint > & | start_inds
| ) |  |

Initializes start indices of particular index set.

Parameters

  inds | container of index sets
  start_inds | output index set

Definition at line 165 of file qr.hpp.

template<typename SparseMatrixT >

void viennacl::linalg::detail::spai::initPreconditioner | ( | SparseMatrixT const & | A,
|  | SparseMatrixT & | M
| ) |  |

Initialize preconditioner with sparcity pattern = p(A)

Parameters

  A | input matrix
  M | output matrix - initialized preconditioner

Definition at line 154 of file spai-static.hpp.

template<typename SparseMatrixT , typename DenseMatrixT >

void viennacl::linalg::detail::spai::initProjectSubMatrix | ( | SparseMatrixT const & | A_in,
|  | std::vector< unsigned int > const & | J,
|  | std::vector< unsigned int > & | I,
|  | DenseMatrixT & | A_out
| ) |  |

Initializes a dense matrix from a sparse one.

Parameters

  A_in | Oiginal sparse matrix
  J | Set of column indices
  I | Set of row indices
  A_out | dense matrix output

Definition at line 156 of file spai.hpp.

template<typename SparseMatrixT , typename SparseVectorT >

void viennacl::linalg::detail::spai::insert_sparse_columns | ( | std::vector< SparseVectorT > const & | M_v,
|  | SparseMatrixT & | M,
|  | bool | is_right
| ) |  |

Insertion of vectorized matrix column into original sparse matrix.

Parameters

  M_v | column-major vectorized matrix
  M | original sparse matrix
  is_right | indicates if matrix should be transposed in the output

Definition at line 616 of file spai.hpp.

template<typename VectorType >

bool viennacl::linalg::detail::spai::is_all_update | ( | VectorType & | parallel_is_update | ) |

Definition at line 443 of file spai.hpp.

template<typename SizeT >

bool viennacl::linalg::detail::spai::isInIndexSet | ( | std::vector< SizeT > const & | J,
|  | SizeT | ind
| ) |  |

Determines if element ind is in set {J}.

Parameters

  J | current set
  ind | current element

Definition at line 72 of file spai-static.hpp.

template<typename SparseVectorT , typename NumericT >

void viennacl::linalg::detail::spai::least_square_solve | ( | std::vector< SparseVectorT > & | A_v_c,
|  | std::vector< SparseVectorT > & | 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< SparseVectorT > & | g_res,
|  | std::vector< cl_uint > & | g_is_update,
|  | const spai_tag & | tag,
|  | viennacl::context | ctx
| ) |  |

Solution of Least square problem on GPU.

Parameters

  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)

Definition at line 298 of file spai.hpp.

template<typename SparseVectorT , typename DenseMatrixT , typename VectorT >

void viennacl::linalg::detail::spai::least_square_solve | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< DenseMatrixT > & | g_R,
|  | std::vector< VectorT > & | g_b_v,
|  | std::vector< std::vector< unsigned int > > & | g_I,
|  | std::vector< std::vector< unsigned int > > & | g_J,
|  | std::vector< SparseVectorT > & | g_res,
|  | std::vector< bool > & | g_is_update,
|  | std::vector< SparseVectorT > & | M_v,
|  | spai_tag const & | tag
| ) |  |

Solution of Least square problem on CPU.

Parameters

  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

Definition at line 398 of file spai.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::make_rotation_matrix | ( | MatrixT & | mat,
|  | vcl_size_t | new_size,
|  | vcl_size_t | off_diagonal_distance = `4`
| ) |  |

Definition at line 61 of file small_matrix.hpp.

template<typename T , typename InputIteratorT >

void viennacl::linalg::detail::spai::Print | ( | std::ostream & | ostr,
|  | InputIteratorT | it_begin,
|  | InputIteratorT | it_end
| ) |  |

Definition at line 63 of file qr.hpp.

template<typename VectorT >

void viennacl::linalg::detail::spai::print_continious_matrix | ( | VectorT & | con_A_I_J,
|  | std::vector< cl_uint > & | blocks_ind,
|  | std::vector< std::vector< unsigned int > > const & | g_I,
|  | std::vector< std::vector< unsigned int > > const & | g_J
| ) |  |

Definition at line 85 of file qr.hpp.

template<typename VectorT >

void viennacl::linalg::detail::spai::print_continious_vector | ( | VectorT & | con_v,
|  | std::vector< cl_uint > & | block_ind,
|  | std::vector< std::vector< unsigned int > > const & | g_J
| ) |  |

Definition at line 101 of file qr.hpp.

template<typename DenseMatrixT >

void viennacl::linalg::detail::spai::print_matrix | ( | DenseMatrixT & | m | ) |

Definition at line 88 of file spai.hpp.

template<typename SparseVectorT >

void viennacl::linalg::detail::spai::print_sparse_vector | ( | SparseVectorT const & | v | ) |

Definition at line 81 of file spai.hpp.

template<typename VectorT , typename NumericT >

void viennacl::linalg::detail::spai::projectI | ( | std::vector< unsigned int > const & | I,
|  | VectorT & | y,
|  | unsigned int | ind
| ) |  |

Perform projection of set I on the unit-vector.

Parameters

  I | set of non-zero rows
  y | result vector
  ind | index of unit vector

Definition at line 122 of file spai-static.hpp.

template<typename SparseVectorT >

void viennacl::linalg::detail::spai::projectRows | ( | std::vector< SparseVectorT > const & | A_v_c,
|  | std::vector< unsigned int > const & | J,
|  | std::vector< unsigned int > & | I
| ) |  |

Row projection for matrix A(:,J) -> A(I,J), building index set of non-zero rows.

Parameters

  A_v_c | input matrix
  J | set of non-zero rows
  I | output matrix

Definition at line 171 of file spai-static.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::QRBlockComposition | ( | MatrixT const & | A_I_J,
|  | MatrixT const & | A_I_J_u,
|  | MatrixT & | A_I_u_J_u
| ) |  |

Composition of new block for QR factorization cf. Kallischko dissertation p.82, figure 4.7.

Parameters

  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

Definition at line 250 of file spai-dynamic.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::single_qr | ( | MatrixT & | R,
|  | VectorT & | b_v
| ) |  |

Inplace QR factorization via Householder reflections c.f. Gene H. Golub, Charles F. Van Loan "Matrix Computations" 3rd edition p.224.

Parameters

  R | input matrix
  b_v | vector of betas

Definition at line 311 of file qr.hpp.

template<typename SparseVectorT , typename NumericT >

void viennacl::linalg::detail::spai::sparse_inner_prod | ( | SparseVectorT const & | v1,
|  | SparseVectorT const & | v2,
|  | NumericT & | res_v
| ) |  |

Dot product of two sparse vectors.

Parameters

  v1 | initial sparse vector
  v2 | initial sparse vector
  res_v | scalar that represents dot product result

Definition at line 157 of file spai-dynamic.hpp.

template<typename SparseVectorT , typename NumericT >

void viennacl::linalg::detail::spai::sparse_norm_2 | ( | SparseVectorT const & | v,
|  | NumericT & | norm
| ) |  |

Computation of Euclidean norm for sparse vector.

Parameters

  v | initial sparse vector
  norm | scalar that represents Euclidean norm

Definition at line 141 of file spai-dynamic.hpp.

template<typename MatrixT >

void viennacl::linalg::detail::spai::sparse_transpose | ( | MatrixT const & | A_in,
|  | MatrixT & | A
| ) |  |

Transposition of sparse matrix.

Parameters

  A_in | intial sparse matrix
  A | output transposed matrix

Definition at line 640 of file spai.hpp.

template<typename MatrixT , typename VectorT >

void viennacl::linalg::detail::spai::store_householder_vector | ( | MatrixT & | A,
|  | unsigned int | ind,
|  | VectorT & | v
| ) |  |

Storage of vector v in column(A, ind), starting from ind-1 index of a column.

Parameters

  A | init matrix
  ind | index of a column
  v | vector that should be stored

Definition at line 295 of file qr.hpp.

template<typename MatrixT , typename NumericT >

void viennacl::linalg::detail::spai::sym_sparse_matrix_to_stl | ( | MatrixT const & | A,
|  | std::vector< std::map< unsigned int, NumericT > > & | STL_A
| ) |  |

Definition at line 121 of file fspai.hpp.

template<typename SparseMatrixT , typename SparseVectorT >

void viennacl::linalg::detail::spai::vectorize_column_matrix | ( | SparseMatrixT const & | M_in,
|  | std::vector< SparseVectorT > & | M_v
| ) |  |

Solution of Least square problem on CPU.

Parameters

  M_in | input sparse, boost::numeric::ublas::compressed_matrix
  M_v | array of sparse vectors

Definition at line 462 of file spai.hpp.

template<typename SparseMatrixT , typename SparseVectorT >

void viennacl::linalg::detail::spai::vectorize_row_matrix | ( | SparseMatrixT const & | M_in,
|  | std::vector< SparseVectorT > & | M_v
| ) |  |

Definition at line 472 of file spai.hpp.

template<typename SizeT >

void viennacl::linalg::detail::spai::write_set_to_array | ( | std::vector< std::vector< SizeT > > const & | ind_set,
|  | std::vector< cl_uint > & | a
| ) |  |

Definition at line 484 of file spai.hpp.

template<typename VectorT , typename MatrixT >

void viennacl::linalg::detail::spai::write_to_block | ( | VectorT & | con_A_I_J,
|  | unsigned int | start_ind,
|  | std::vector< unsigned int > const & | I,
|  | std::vector< unsigned int > const & | J,
|  | MatrixT & | m
| ) |  |

Definition at line 72 of file qr.hpp.