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

Holds all routines providing OpenCL linear algebra operations. More...

## Namespaces

| amg
| detail
| Helper functions for OpenCL-accelerated linear algebra operations.
| kernels
| Contains the OpenCL kernel generation functions for a predefined set of functionality.

## Functions

template<typename NumericT >
void | bisectSmall (const viennacl::linalg::detail::InputData< NumericT > &input, viennacl::linalg::detail::ResultDataSmall< NumericT > &result, const unsigned int mat_size, const NumericT lg, const NumericT ug, const NumericT precision)
template<typename NumericT >
void | bisectLarge (const viennacl::linalg::detail::InputData< NumericT > &input, viennacl::linalg::detail::ResultDataLarge< NumericT > &result, const unsigned int mat_size, const NumericT lg, const NumericT ug, const NumericT precision)
template<typename NumericT >
void | bisectLargeOneIntervals (const viennacl::linalg::detail::InputData< NumericT > &input, viennacl::linalg::detail::ResultDataLarge< NumericT > &result, const unsigned int mat_size, const NumericT precision)
template<typename NumericT >
void | bisectLargeMultIntervals (const viennacl::linalg::detail::InputData< NumericT > &input, viennacl::linalg::detail::ResultDataLarge< NumericT > &result, const unsigned int mat_size, const NumericT precision)
template<typename NumericT , typename SolverTagT >
void | inplace_solve (matrix_base< NumericT > const &A, matrix_base< NumericT > &B, SolverTagT)
| Direct inplace solver for dense triangular systems. Matlab notation: A \ B. More...
template<typename NumericT , typename SOLVERTAG >
void | inplace_solve (matrix_base< NumericT > const &A, vector_base< NumericT > &x, SOLVERTAG)
template<typename NumericT >
void | direct (viennacl::ocl::handle< cl_mem > const &in, viennacl::ocl::handle< cl_mem > const &out, vcl_size_t size, vcl_size_t stride, vcl_size_t batch_num, NumericT sign=NumericT(-1), viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::DATA_ORDER data_order=viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::ROW_MAJOR)
| Direct algorithm for computing Fourier transformation. More...
template<typename NumericT >
void | reorder (viennacl::ocl::handle< cl_mem > const &in, vcl_size_t size, vcl_size_t stride, vcl_size_t bits_datasize, vcl_size_t batch_num, viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::DATA_ORDER data_order=viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::ROW_MAJOR)
template<typename NumericT >
void | radix2 (viennacl::ocl::handle< cl_mem > const &in, vcl_size_t size, vcl_size_t stride, vcl_size_t batch_num, NumericT sign=NumericT(-1), viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::DATA_ORDER data_order=viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::ROW_MAJOR)
| Radix-2 algorithm for computing Fourier transformation. More...
template<typename NumericT , unsigned int AlignmentV>
void | bluestein (viennacl::vector< NumericT, AlignmentV > &in, viennacl::vector< NumericT, AlignmentV > &out, vcl_size_t)
| Bluestein's algorithm for computing Fourier transformation. More...
template<typename NumericT , unsigned int AlignmentV>
void | multiply_complex (viennacl::vector< NumericT, AlignmentV > const &input1, viennacl::vector< NumericT, AlignmentV > const &input2, viennacl::vector< NumericT, AlignmentV > &output)
| Mutiply two complex vectors and store result in output. More...
template<typename NumericT , unsigned int AlignmentV>
void | normalize (viennacl::vector< NumericT, AlignmentV > &input)
| Normalize vector on with his own size. More...
template<typename NumericT , unsigned int AlignmentV>
void | transpose (viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > &input)
| Inplace_transpose matrix. More...
template<typename NumericT , unsigned int AlignmentV>
void | transpose (viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > const &input, viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > &output)
| Transpose matrix. More...
template<typename NumericT >
void | real_to_complex (viennacl::vector_base< NumericT > const &in, viennacl::vector_base< NumericT > &out, vcl_size_t size)
| Create complex vector from real vector (even elements(2*k) = real part, odd elements(2*k+1) = imaginary part) More...
template<typename NumericT >
void | complex_to_real (viennacl::vector_base< NumericT > const &in, viennacl::vector_base< NumericT > &out, vcl_size_t size)
| Create real vector from complex vector (even elements(2*k) = real part, odd elements(2*k+1) = imaginary part) More...
template<typename NumericT >
void | reverse (viennacl::vector_base< NumericT > &in)
| Reverse vector to oposite order and save it in input vector. More...
template<typename NumericT >
void | extract_L (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &L)
template<typename NumericT >
void | icc_scale (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &L)
| Scales the values extracted from A such that A' = DAD has unit diagonal. Updates values from A in L and U accordingly. More...
template<typename NumericT >
void | icc_chow_patel_sweep (compressed_matrix< NumericT > &L, vector< NumericT > const &aij_L)
| Performs one nonlinear relaxation step in the Chow-Patel-ILU using OpenCL (cf. Algorithm 2 in paper) More...
template<typename NumericT >
void | extract_LU (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &L, compressed_matrix< NumericT > &U)
template<typename NumericT >
void | ilu_scale (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &L, compressed_matrix< NumericT > &U)
| Scales the values extracted from A such that A' = DAD has unit diagonal. Updates values from A in L and U accordingly. More...
template<typename NumericT >
void | ilu_chow_patel_sweep (compressed_matrix< NumericT > &L, vector< NumericT > const &aij_L, compressed_matrix< NumericT > &U_trans, vector< NumericT > const &aij_U_trans)
| Performs one nonlinear relaxation step in the Chow-Patel-ILU using OpenCL (cf. Algorithm 2 in paper) More...
template<typename NumericT >
void | ilu_form_neumann_matrix (compressed_matrix< NumericT > &R, vector< NumericT > &diag_R)
template<typename NumericT >
void | pipelined_cg_vector_update (vector_base< NumericT > &result, NumericT alpha, vector_base< NumericT > &p, vector_base< NumericT > &r, vector_base< NumericT > const &Ap, NumericT beta, vector_base< NumericT > &inner_prod_buffer)
template<typename NumericT >
void | pipelined_cg_prod (compressed_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > &inner_prod_buffer)
template<typename NumericT >
void | pipelined_cg_prod (coordinate_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > &inner_prod_buffer)
template<typename NumericT >
void | pipelined_cg_prod (ell_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > &inner_prod_buffer)
template<typename NumericT >
void | pipelined_cg_prod (sliced_ell_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > &inner_prod_buffer)
template<typename NumericT >
void | pipelined_cg_prod (hyb_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > &inner_prod_buffer)
template<typename NumericT >
void | pipelined_bicgstab_update_s (vector_base< NumericT > &s, vector_base< NumericT > &r, vector_base< NumericT > const &Ap, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
template<typename NumericT >
void | pipelined_bicgstab_vector_update (vector_base< NumericT > &result, NumericT alpha, vector_base< NumericT > &p, NumericT omega, vector_base< NumericT > const &s, vector_base< NumericT > &residual, vector_base< NumericT > const &As, NumericT beta, vector_base< NumericT > const &Ap, vector_base< NumericT > const &r0star, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size)
template<typename NumericT >
void | pipelined_bicgstab_prod (compressed_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > const &r0star, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
template<typename NumericT >
void | pipelined_bicgstab_prod (coordinate_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > const &r0star, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
template<typename NumericT >
void | pipelined_bicgstab_prod (ell_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > const &r0star, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
template<typename NumericT >
void | pipelined_bicgstab_prod (sliced_ell_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > const &r0star, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
template<typename NumericT >
void | pipelined_bicgstab_prod (hyb_matrix< NumericT > const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > const &r0star, vector_base< NumericT > &inner_prod_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
template<typename T >
void | pipelined_gmres_normalize_vk (vector_base< T > &v_k, vector_base< T > const &residual, vector_base< T > &R_buffer, vcl_size_t offset_in_R, vector_base< T > const &inner_prod_buffer, vector_base< T > &r_dot_vk_buffer, vcl_size_t buffer_chunk_size, vcl_size_t buffer_chunk_offset)
| Performs a vector normalization needed for an efficient pipelined GMRES algorithm. More...
template<typename T >
void | pipelined_gmres_gram_schmidt_stage1 (vector_base< T > const &device_krylov_basis, vcl_size_t v_k_size, vcl_size_t v_k_internal_size, vcl_size_t param_k, vector_base< T > &vi_in_vk_buffer, vcl_size_t buffer_chunk_size)
template<typename T >
void | pipelined_gmres_gram_schmidt_stage2 (vector_base< T > &device_krylov_basis, vcl_size_t v_k_size, vcl_size_t v_k_internal_size, vcl_size_t param_k, vector_base< T > const &vi_in_vk_buffer, vector_base< T > &R_buffer, vcl_size_t krylov_dim, vector_base< T > &inner_prod_buffer, vcl_size_t buffer_chunk_size)
template<typename T >
void | pipelined_gmres_update_result (vector_base< T > &result, vector_base< T > const &residual, vector_base< T > const &krylov_basis, vcl_size_t v_k_size, vcl_size_t v_k_internal_size, vector_base< T > const &coefficients, vcl_size_t param_k)
template<typename T >
void | pipelined_gmres_prod (compressed_matrix< T > const &A, vector_base< T > const &p, vector_base< T > &Ap, vector_base< T > &inner_prod_buffer)
template<typename T >
void | pipelined_gmres_prod (coordinate_matrix< T > const &A, vector_base< T > const &p, vector_base< T > &Ap, vector_base< T > &inner_prod_buffer)
template<typename T >
void | pipelined_gmres_prod (ell_matrix< T > const &A, vector_base< T > const &p, vector_base< T > &Ap, vector_base< T > &inner_prod_buffer)
template<typename T >
void | pipelined_gmres_prod (sliced_ell_matrix< T > const &A, vector_base< T > const &p, vector_base< T > &Ap, vector_base< T > &inner_prod_buffer)
template<typename T >
void | pipelined_gmres_prod (hyb_matrix< T > const &A, vector_base< T > const &p, vector_base< T > &Ap, vector_base< T > &inner_prod_buffer)
template<typename DestNumericT , typename SrcNumericT >
void | convert (matrix_base< DestNumericT > &dest, matrix_base< SrcNumericT > const &src)
template<typename NumericT , typename ScalarT1 >
void | am (matrix_base< NumericT > &mat1, matrix_base< NumericT > const &mat2, ScalarT1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
template<typename NumericT , typename ScalarT1 , typename ScalarT2 >
void | ambm (matrix_base< NumericT > &mat1, matrix_base< NumericT > const &mat2, ScalarT1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, matrix_base< NumericT > const &mat3, ScalarT2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename NumericT , typename ScalarT1 , typename ScalarT2 >
void | ambm_m (matrix_base< NumericT > &mat1, matrix_base< NumericT > const &mat2, ScalarT1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, matrix_base< NumericT > const &mat3, ScalarT2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename NumericT , typename SizeT , typename DistanceT >
void | trans (const matrix_expression< const matrix_base< NumericT, SizeT, DistanceT >, const matrix_base< NumericT, SizeT, DistanceT >, op_trans > &proxy, matrix_base< NumericT > &temp_trans)
template<typename NumericT >
void | matrix_assign (matrix_base< NumericT > &mat, NumericT s, bool clear=false)
template<typename NumericT >
void | matrix_diagonal_assign (matrix_base< NumericT > &mat, NumericT s)
template<typename NumericT >
void | matrix_diag_from_vector (const vector_base< NumericT > &vec, int k, matrix_base< NumericT > &mat)
template<typename NumericT >
void | matrix_diag_to_vector (const matrix_base< NumericT > &mat, int k, vector_base< NumericT > &vec)
template<typename NumericT >
void | matrix_row (matrix_base< NumericT > const &mat, unsigned int i, vector_base< NumericT > &vec)
template<typename NumericT >
void | matrix_column (const matrix_base< NumericT > &mat, unsigned int j, vector_base< NumericT > &vec)
template<typename T , typename OP >
void | element_op (matrix_base< T > &A, matrix_expression< const matrix_base< T >, const matrix_base< T >, op_element_binary< OP > > const &proxy)
| Implementation of binary element-wise operations A = OP(B,C) More...
template<typename T , typename OP >
void | element_op (matrix_base< T > &A, matrix_expression< const matrix_base< T >, const matrix_base< T >, op_element_unary< OP > > const &proxy)
| Implementation of unary element-wise operations A = OP(B) More...
template<typename NumericT >
void | prod_impl (const matrix_base< NumericT > &mat, bool trans_A, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
| Carries out matrix-vector multiplication. More...
template<typename NumericT , typename ScalarType >
void | prod_impl (matrix_base< NumericT > const &A, bool A_trans, matrix_base< NumericT > const &B, bool B_trans, matrix_base< NumericT > &C, ScalarType alpha, ScalarType beta)
| Carries out matrix-matrix multiplication. More...
template<typename NumericT , typename ScalarT1 >
void | scaled_rank_1_update (matrix_base< NumericT > &A, ScalarT1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, const vector_base< NumericT > &vec1, const vector_base< NumericT > &vec2)
| The implementation of the operation mat += alpha * vec1 * vec2^T, i.e. a scaled rank 1 update. More...
template<typename SCALARTYPE , typename VectorType >
void | bidiag_pack_svd (viennacl::matrix< SCALARTYPE > &A, VectorType &dh, VectorType &sh)
template<typename NumericT >
void | bidiag_pack (matrix_base< NumericT > &A, viennacl::vector< NumericT > &dh, viennacl::vector< NumericT > &sh)
template<typename NumericT >
void | house_update_A_left (matrix_base< NumericT > &A, vector_base< NumericT > &D, vcl_size_t start)
template<typename NumericT >
void | house_update_A_right (matrix_base< NumericT > &A, vector_base< NumericT > &D)
template<typename NumericT >
void | house_update_QL (matrix_base< NumericT > &Q, vector_base< NumericT > &D, vcl_size_t A_size1)
template<typename NumericT >
void | givens_next (matrix_base< NumericT > &matrix, vector_base< NumericT > &tmp1, vector_base< NumericT > &tmp2, int l, int m)
template<typename NumericT >
void | copy_vec (matrix_base< NumericT > &A, vector_base< NumericT > &V, vcl_size_t row_start, vcl_size_t col_start, bool copy_col)
template<typename NumericT >
void | nmf (viennacl::matrix_base< NumericT > const &V, viennacl::matrix_base< NumericT > &W, viennacl::matrix_base< NumericT > &H, viennacl::linalg::nmf_config const &conf)
| The nonnegative matrix factorization (approximation) algorithm as suggested by Lee and Seung. Factorizes a matrix V with nonnegative entries into matrices W and H such that ||V - W*H|| is minimized. More...
template<typename ScalarT1 , typename ScalarT2 , typename NumericT >
viennacl::enable_if < viennacl::is_scalar < ScalarT1 >::value &&viennacl::is_scalar < ScalarT2 >::value &&viennacl::is_any_scalar < NumericT >::value >::type | as (ScalarT1 &s1, ScalarT2 const &s2, NumericT const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
template<typename ScalarT1 , typename ScalarT2 , typename NumericT2 , typename ScalarT3 , typename NumericT3 >

viennacl::enable_if
< viennacl::is_scalar
< ScalarT1 >::value
&&viennacl::is_scalar
< ScalarT2 >::value
&&viennacl::is_scalar
< ScalarT3 >::value
&&viennacl::is_any_scalar
< NumericT2 >::value
&&viennacl::is_any_scalar
< NumericT3 >::value >::type

asbs (ScalarT1 &s1, ScalarT2 const &s2, NumericT2 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, ScalarT3 const &s3, NumericT3 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)

template<typename ScalarT1 , typename ScalarT2 , typename NumericT2 , typename ScalarT3 , typename NumericT3 >

viennacl::enable_if
< viennacl::is_scalar
< ScalarT1 >::value
&&viennacl::is_scalar
< ScalarT2 >::value
&&viennacl::is_scalar
< ScalarT3 >::value
&&viennacl::is_any_scalar
< NumericT2 >::value
&&viennacl::is_any_scalar
< NumericT3 >::value >::type

asbs_s (ScalarT1 &s1, ScalarT2 const &s2, NumericT2 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, ScalarT3 const &s3, NumericT3 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)

template<typename ScalarT1 , typename ScalarT2 >
viennacl::enable_if < viennacl::is_scalar < ScalarT1 >::value &&viennacl::is_scalar < ScalarT2 >::value >::type | swap (ScalarT1 &s1, ScalarT2 &s2)
| Swaps the contents of two scalars, data is copied. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (const viennacl::compressed_matrix< NumericT, AlignmentV > &A, const viennacl::vector_base< NumericT > &x, NumericT alpha, viennacl::vector_base< NumericT > &y, NumericT beta)
| Carries out matrix-vector multiplication with a compressed_matrix. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (const viennacl::compressed_matrix< NumericT, AlignmentV > &sp_A, const viennacl::matrix_base< NumericT > &d_A, viennacl::matrix_base< NumericT > &y)
| Carries out sparse_matrix-matrix multiplication first matrix being compressed. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::compressed_matrix< NumericT, AlignmentV > const &sp_A, viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const &d_A, viennacl::matrix_base< NumericT > &y)
| Carries out matrix-trans(matrix) multiplication first matrix being compressed and the second transposed. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::compressed_matrix< NumericT, AlignmentV > const &A, viennacl::compressed_matrix< NumericT, AlignmentV > const &B, viennacl::compressed_matrix< NumericT, AlignmentV > &C)
| Carries out sparse_matrix-sparse_matrix multiplication for CSR matrices. More...
template<typename NumericT , unsigned int MAT_AlignmentV>
void | inplace_solve (compressed_matrix< NumericT, MAT_AlignmentV > const &L, vector_base< NumericT > &x, viennacl::linalg::unit_lower_tag)
| Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (compressed_matrix< NumericT, AlignmentV > const &L, vector_base< NumericT > &x, viennacl::linalg::lower_tag)
| Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (compressed_matrix< NumericT, AlignmentV > const &U, vector_base< NumericT > &x, viennacl::linalg::unit_upper_tag)
| Inplace solution of an upper triangular compressed_matrix with unit diagonal. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (compressed_matrix< NumericT, AlignmentV > const &U, vector_base< NumericT > &x, viennacl::linalg::upper_tag)
| Inplace solution of an upper triangular compressed_matrix. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const &proxy_L, vector_base< NumericT > &x, viennacl::linalg::unit_lower_tag)
| Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const &proxy_L, vector_base< NumericT > &x, viennacl::linalg::lower_tag)
| Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const &proxy_U, vector_base< NumericT > &x, viennacl::linalg::unit_upper_tag)
| Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions. More...
template<typename NumericT , unsigned int AlignmentV>
void | inplace_solve (matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const &proxy_U, vector_base< NumericT > &x, viennacl::linalg::upper_tag)
| Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions. More...
template<typename NumericT >
void | prod_impl (viennacl::compressed_compressed_matrix< NumericT > const &A, viennacl::vector_base< NumericT > const &x, NumericT alpha, viennacl::vector_base< NumericT > &y, NumericT beta)
| Carries out matrix-vector multiplication with a compressed_compressed_matrix. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::coordinate_matrix< NumericT, AlignmentV > const &A, viennacl::vector_base< NumericT > const &x, NumericT alpha, viennacl::vector_base< NumericT > &y, NumericT beta)
| Carries out matrix-vector multiplication with a coordinate_matrix. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::coordinate_matrix< NumericT, AlignmentV > const &A, viennacl::matrix_base< NumericT > const &d_A, viennacl::matrix_base< NumericT > &y)
| Carries out sparse-matrix-dense-matrix multiplication, where the sparse matrix is a coordinate_matrix. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::coordinate_matrix< NumericT, AlignmentV > const &A, viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const &d_A, viennacl::matrix_base< NumericT > &y)
| Carries out sparse-matrix-dense-matrix multiplication, where the sparse matrix is a coordinate_matrix. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::ell_matrix< NumericT, AlignmentV > const &A, viennacl::vector_base< NumericT > const &x, NumericT alpha, viennacl::vector_base< NumericT > &y, NumericT beta)
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::ell_matrix< NumericT, AlignmentV > const &sp_A, viennacl::matrix_base< NumericT > const &d_A, viennacl::matrix_base< NumericT > &y)
| Carries out Sparse Matrix(ELL)-Dense Matrix multiplication. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::ell_matrix< NumericT, AlignmentV > const &sp_A, viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const &d_A, viennacl::matrix_base< NumericT > &y)
| Carries out Sparse Matrix(ELL)-Dense Transposed Matrix multiplication. More...
template<typename ScalarT , typename IndexT >
void | prod_impl (viennacl::sliced_ell_matrix< ScalarT, IndexT > const &A, viennacl::vector_base< ScalarT > const &x, ScalarT alpha, viennacl::vector_base< ScalarT > &y, ScalarT beta)
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::hyb_matrix< NumericT, AlignmentV > const &A, viennacl::vector_base< NumericT > const &x, NumericT alpha, viennacl::vector_base< NumericT > &y, NumericT beta)
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::hyb_matrix< NumericT, AlignmentV > const &A, viennacl::matrix_base< NumericT > const &d_A, viennacl::matrix_base< NumericT > &y)
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::hyb_matrix< NumericT, AlignmentV > const &A, viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const &d_A, viennacl::matrix_base< NumericT > &y)
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::vandermonde_matrix< NumericT, AlignmentV > const &A, viennacl::vector_base< NumericT > const &x, viennacl::vector_base< NumericT > &y)
| Carries out matrix-vector multiplication with a vandermonde_matrix. More...
template<typename DestNumericT , typename SrcNumericT >
void | convert (vector_base< DestNumericT > &dest, vector_base< SrcNumericT > const &src)
template<typename T , typename ScalarType1 >
void | av (vector_base< T > &vec1, vector_base< T > const &vec2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
template<typename T , typename ScalarType1 , typename ScalarType2 >
void | avbv (vector_base< T > &vec1, vector_base< T > const &vec2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, vector_base< T > const &vec3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename T , typename ScalarType1 , typename ScalarType2 >
void | avbv_v (vector_base< T > &vec1, vector_base< T > const &vec2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, vector_base< T > const &vec3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename T >
void | vector_assign (vector_base< T > &vec1, const T &alpha, bool up_to_internal_size=false)
| Assign a constant value to a vector (-range/-slice) More...
template<typename T >
void | vector_swap (vector_base< T > &vec1, vector_base< T > &vec2)
| Swaps the contents of two vectors, data is copied. More...
template<typename T , typename OP >
void | element_op (vector_base< T > &vec1, vector_expression< const vector_base< T >, const vector_base< T >, op_element_binary< OP > > const &proxy)
| Implementation of the element-wise operation v1 = v2 .* v3 and v1 = v2 ./ v3 (using MATLAB syntax) More...
template<typename T , typename OP >
void | element_op (vector_base< T > &vec1, vector_expression< const vector_base< T >, const vector_base< T >, op_element_unary< OP > > const &proxy)
| Implementation of unary element-wise operations v1 = OP(v2) More...
template<typename T >
void | inner_prod_impl (vector_base< T > const &vec1, vector_base< T > const &vec2, vector_base< T > &partial_result)
| Computes the partial inner product of two vectors - implementation. Library users should call inner_prod(vec1, vec2). More...
template<typename T >
void | inner_prod_impl (vector_base< T > const &vec1, vector_base< T > const &vec2, scalar< T > &result)
| Computes the inner product of two vectors - implementation. Library users should call inner_prod(vec1, vec2). More...
template<typename NumericT >
void | inner_prod_impl (vector_base< NumericT > const &x, vector_tuple< NumericT > const &vec_tuple, vector_base< NumericT > &result)
| Computes multiple inner products where one argument is common to all inner products. <x, y1>, <x, y2>, ..., <x, yN> More...
template<typename T >
void | inner_prod_cpu (vector_base< T > const &vec1, vector_base< T > const &vec2, T &result)
| Computes the inner product of two vectors - implementation. Library users should call inner_prod(vec1, vec2). More...
template<typename T >
void | norm_reduction_impl (vector_base< T > const &vec, vector_base< T > &partial_result, cl_uint norm_id)
| Computes the partial work group results for vector norms. More...
template<typename T >
void | norm_1_impl (vector_base< T > const &vec, scalar< T > &result)
| Computes the l^1-norm of a vector. More...
template<typename T >
void | norm_1_cpu (vector_base< T > const &vec, T &result)
| Computes the l^1-norm of a vector with final reduction on CPU. More...
template<typename T >
void | norm_2_impl (vector_base< T > const &vec, scalar< T > &result)
| Computes the l^2-norm of a vector - implementation using OpenCL summation at second step. More...
template<typename T >
void | norm_2_cpu (vector_base< T > const &vec, T &result)
| Computes the l^1-norm of a vector with final reduction on CPU. More...
template<typename T >
void | norm_inf_impl (vector_base< T > const &vec, scalar< T > &result)
| Computes the supremum-norm of a vector. More...
template<typename T >
void | norm_inf_cpu (vector_base< T > const &vec, T &result)
| Computes the supremum-norm of a vector. More...
template<typename T >
cl_uint | index_norm_inf (vector_base< T > const &vec)
| Computes the index of the first entry that is equal to the supremum-norm in modulus. More...
template<typename NumericT >
void | max_impl (vector_base< NumericT > const &x, scalar< NumericT > &result)
| Computes the maximum value of a vector, where the result is stored in an OpenCL buffer. More...
template<typename NumericT >
void | max_cpu (vector_base< NumericT > const &x, NumericT &result)
| Computes the maximum value of a vector, where the value is stored in a host value. More...
template<typename NumericT >
void | min_impl (vector_base< NumericT > const &x, scalar< NumericT > &result)
| Computes the minimum of a vector, where the result is stored in an OpenCL buffer. More...
template<typename NumericT >
void | min_cpu (vector_base< NumericT > const &x, NumericT &result)
| Computes the minimum of a vector, where the result is stored on a CPU scalar. More...
template<typename NumericT >
void | sum_impl (vector_base< NumericT > const &x, scalar< NumericT > &result)
| Computes the sum over all entries of a vector. More...
template<typename NumericT >
void | sum_cpu (vector_base< NumericT > const &x, NumericT &result)
| Computes the sum over all entries of a vector. More...
template<typename T >
void | plane_rotation (vector_base< T > &vec1, vector_base< T > &vec2, T alpha, T beta)
| Computes a plane rotation of two vectors. More...
template<typename NumericT >
void | inclusive_scan (vector_base< NumericT > const &input, vector_base< NumericT > &output)
| This function implements an inclusive scan using CUDA. More...
template<typename NumericT >
void | exclusive_scan (vector_base< NumericT > const &input, vector_base< NumericT > &output)
| This function implements an exclusive scan using CUDA. More...

## Variables

const std::string | BISECT_KERNEL_SMALL = "bisectKernelSmall"
const std::string | BISECT_KERNEL_LARGE = "bisectKernelLarge"
const std::string | BISECT_KERNEL_LARGE_ONE_INTERVALS = "bisectKernelLarge_OneIntervals"
const std::string | BISECT_KERNEL_LARGE_MULT_INTERVALS = "bisectKernelLarge_MultIntervals"
const std::string | SVD_BIDIAG_PACK_KERNEL = "bidiag_pack"
const std::string | SVD_HOUSEHOLDER_UPDATE_A_LEFT_KERNEL = "house_update_A_left"
const std::string | SVD_HOUSEHOLDER_UPDATE_A_RIGHT_KERNEL = "house_update_A_right"
const std::string | SVD_HOUSEHOLDER_UPDATE_QL_KERNEL = "house_update_QL"
const std::string | SVD_GIVENS_NEXT_KERNEL = "givens_next"
const std::string | SVD_COPY_COL_KERNEL = "copy_col"
const std::string | SVD_COPY_ROW_KERNEL = "copy_row"

## Detailed Description

Holds all routines providing OpenCL linear algebra operations.

## Function Documentation

template<typename NumericT , typename ScalarT1 >

void viennacl::linalg::opencl::am | ( | matrix_base< NumericT > & | mat1,
|  | matrix_base< NumericT > const & | mat2,
|  | ScalarT1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha
| ) |  |

Definition at line 161 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarT1 , typename ScalarT2 >

void viennacl::linalg::opencl::ambm | ( | matrix_base< NumericT > & | mat1,
|  | matrix_base< NumericT > const & | mat2,
|  | ScalarT1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | matrix_base< NumericT > const & | mat3,
|  | ScalarT2 const & | beta,
|  | vcl_size_t | len_beta,
|  | bool | reciprocal_beta,
|  | bool | flip_sign_beta
| ) |  |

Definition at line 187 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarT1 , typename ScalarT2 >

void viennacl::linalg::opencl::ambm_m | ( | matrix_base< NumericT > & | mat1,
|  | matrix_base< NumericT > const & | mat2,
|  | ScalarT1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | matrix_base< NumericT > const & | mat3,
|  | ScalarT2 const & | beta,
|  | vcl_size_t | len_beta,
|  | bool | reciprocal_beta,
|  | bool | flip_sign_beta
| ) |  |

Definition at line 232 of file matrix_operations.hpp.

template<typename ScalarT1 , typename ScalarT2 , typename NumericT >

viennacl::enable_if< viennacl::is_scalar<ScalarT1>::value && viennacl::is_scalar<ScalarT2>::value && viennacl::is_any_scalar<NumericT>::value >::type viennacl::linalg::opencl::as | ( | ScalarT1 & | s1,
|  | ScalarT2 const & | s2,
|  | NumericT const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha
| ) |  |

Definition at line 54 of file scalar_operations.hpp.

template<typename ScalarT1 , typename ScalarT2 , typename NumericT2 , typename ScalarT3 , typename NumericT3 >

viennacl::enable_if< viennacl::is_scalar<ScalarT1>::value && viennacl::is_scalar<ScalarT2>::value && viennacl::is_scalar<ScalarT3>::value && viennacl::is_any_scalar<NumericT2>::value && viennacl::is_any_scalar<NumericT3>::value >::type viennacl::linalg::opencl::asbs | ( | ScalarT1 & | s1,
|  | ScalarT2 const & | s2,
|  | NumericT2 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | ScalarT3 const & | s3,
|  | NumericT3 const & | beta,
|  | vcl_size_t | len_beta,
|  | bool | reciprocal_beta,
|  | bool | flip_sign_beta
| ) |  |

Definition at line 86 of file scalar_operations.hpp.

template<typename ScalarT1 , typename ScalarT2 , typename NumericT2 , typename ScalarT3 , typename NumericT3 >

viennacl::enable_if< viennacl::is_scalar<ScalarT1>::value && viennacl::is_scalar<ScalarT2>::value && viennacl::is_scalar<ScalarT3>::value && viennacl::is_any_scalar<NumericT2>::value && viennacl::is_any_scalar<NumericT3>::value >::type viennacl::linalg::opencl::asbs_s | ( | ScalarT1 & | s1,
|  | ScalarT2 const & | s2,
|  | NumericT2 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | ScalarT3 const & | s3,
|  | NumericT3 const & | beta,
|  | vcl_size_t | len_beta,
|  | bool | reciprocal_beta,
|  | bool | flip_sign_beta
| ) |  |

Definition at line 135 of file scalar_operations.hpp.

template<typename T , typename ScalarType1 >

void viennacl::linalg::opencl::av | ( | vector_base< T > & | vec1,
|  | vector_base< T > const & | vec2,
|  | ScalarType1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha
| ) |  |

Definition at line 76 of file vector_operations.hpp.

template<typename T , typename ScalarType1 , typename ScalarType2 >

void viennacl::linalg::opencl::avbv | ( | vector_base< T > & | vec1,
|  | vector_base< T > const & | vec2,
|  | ScalarType1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | vector_base< T > const & | vec3,
|  | ScalarType2 const & | beta,
|  | vcl_size_t | len_beta,
|  | bool | reciprocal_beta,
|  | bool | flip_sign_beta
| ) |  |

Definition at line 116 of file vector_operations.hpp.

template<typename T , typename ScalarType1 , typename ScalarType2 >

void viennacl::linalg::opencl::avbv_v | ( | vector_base< T > & | vec1,
|  | vector_base< T > const & | vec2,
|  | ScalarType1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | vector_base< T > const & | vec3,
|  | ScalarType2 const & | beta,
|  | vcl_size_t | len_beta,
|  | bool | reciprocal_beta,
|  | bool | flip_sign_beta
| ) |  |

Definition at line 178 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::bidiag_pack | ( | matrix_base< NumericT > & | A,
|  | viennacl::vector< NumericT > & | dh,
|  | viennacl::vector< NumericT > & | sh
| ) |  |

Definition at line 758 of file matrix_operations.hpp.

template<typename SCALARTYPE , typename VectorType >

void viennacl::linalg::opencl::bidiag_pack_svd | ( | viennacl::matrix< SCALARTYPE > & | A,
|  | VectorType & | dh,
|  | VectorType & | sh
| ) |  |

Definition at line 732 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::bisectLarge | ( | const viennacl::linalg::detail::InputData< NumericT > & | input,
|  | viennacl::linalg::detail::ResultDataLarge< NumericT > & | result,
|  | const unsigned int | mat_size,
|  | const NumericT | lg,
|  | const NumericT | ug,
|  | const NumericT | precision
| ) |  |

Definition at line 79 of file bisect_kernel_calls.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::bisectLargeMultIntervals | ( | const viennacl::linalg::detail::InputData< NumericT > & | input,
|  | viennacl::linalg::detail::ResultDataLarge< NumericT > & | result,
|  | const unsigned int | mat_size,
|  | const NumericT | precision
| ) |  |

Definition at line 145 of file bisect_kernel_calls.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::bisectLargeOneIntervals | ( | const viennacl::linalg::detail::InputData< NumericT > & | input,
|  | viennacl::linalg::detail::ResultDataLarge< NumericT > & | result,
|  | const unsigned int | mat_size,
|  | const NumericT | precision
| ) |  |

Definition at line 116 of file bisect_kernel_calls.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::bisectSmall | ( | const viennacl::linalg::detail::InputData< NumericT > & | input,
|  | viennacl::linalg::detail::ResultDataSmall< NumericT > & | result,
|  | const unsigned int | mat_size,
|  | const NumericT | lg,
|  | const NumericT | ug,
|  | const NumericT | precision
| ) |  |

Definition at line 49 of file bisect_kernel_calls.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::bluestein | ( | viennacl::vector< NumericT, AlignmentV > & | in,
|  | viennacl::vector< NumericT, AlignmentV > & | out,
|  | vcl_size_t |
| ) |  |

Bluestein's algorithm for computing Fourier transformation.

Currently, Works only for sizes of input data which less than 2^16. Uses a lot of additional memory, but should be fast for any size of data. Serial implementation has something about o(n * lg n) complexity

Definition at line 212 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::complex_to_real | ( | viennacl::vector_base< NumericT > const & | in,
|  | viennacl::vector_base< NumericT > & | out,
|  | vcl_size_t | size
| ) |  |

Create real vector from complex vector (even elements(2*k) = real part, odd elements(2*k+1) = imaginary part)

Definition at line 320 of file fft_operations.hpp.

template<typename DestNumericT , typename SrcNumericT >

void viennacl::linalg::opencl::convert | ( | vector_base< DestNumericT > & | dest,
|  | vector_base< SrcNumericT > const & | src
| ) |  |

Definition at line 56 of file vector_operations.hpp.

template<typename DestNumericT , typename SrcNumericT >

void viennacl::linalg::opencl::convert | ( | matrix_base< DestNumericT > & | dest,
|  | matrix_base< SrcNumericT > const & | src
| ) |  |

Definition at line 134 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::copy_vec | ( | matrix_base< NumericT > & | A,
|  | vector_base< NumericT > & | V,
|  | vcl_size_t | row_start,
|  | vcl_size_t | col_start,
|  | bool | copy_col
| ) |  |

Definition at line 970 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::direct | ( | viennacl::ocl::handle< cl_mem > const & | in,
|  | viennacl::ocl::handle< cl_mem > const & | out,
|  | vcl_size_t | size,
|  | vcl_size_t | stride,
|  | vcl_size_t | batch_num,
|  | NumericT | sign = `NumericT(-1)`,
|  | viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::DATA_ORDER | data_order = `viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::ROW_MAJOR`
| ) |  |

Direct algorithm for computing Fourier transformation.

Works on any sizes of data. Serial implementation has o(n^2) complexity

Definition at line 99 of file fft_operations.hpp.

template<typename T , typename OP >

void viennacl::linalg::opencl::element_op | ( | vector_base< T > & | vec1,
|  | vector_expression< const vector_base< T >, const vector_base< T >, op_element_binary< OP > > const & | proxy
| ) |  |

Implementation of the element-wise operation v1 = v2 .* v3 and v1 = v2 ./ v3 (using MATLAB syntax)

Parameters

  vec1 | The result vector (or -range, or -slice)
  proxy | The proxy object holding v2, v3 and the operation

Definition at line 300 of file vector_operations.hpp.

template<typename T , typename OP >

void viennacl::linalg::opencl::element_op | ( | vector_base< T > & | vec1,
|  | vector_expression< const vector_base< T >, const vector_base< T >, op_element_unary< OP > > const & | proxy
| ) |  |

Implementation of unary element-wise operations v1 = OP(v2)

Parameters

  vec1 | The result vector (or -range, or -slice)
  proxy | The proxy object holding v2 and the operation

Definition at line 349 of file vector_operations.hpp.

template<typename T , typename OP >

void viennacl::linalg::opencl::element_op | ( | matrix_base< T > & | A,
|  | matrix_expression< const matrix_base< T >, const matrix_base< T >, op_element_binary< OP > > const & | proxy
| ) |  |

Implementation of binary element-wise operations A = OP(B,C)

Parameters

  A | The result matrix (or -range, or -slice)
  proxy | The proxy object holding B, C, and the operation

Definition at line 540 of file matrix_operations.hpp.

template<typename T , typename OP >

void viennacl::linalg::opencl::element_op | ( | matrix_base< T > & | A,
|  | matrix_expression< const matrix_base< T >, const matrix_base< T >, op_element_unary< OP > > const & | proxy
| ) |  |

Implementation of unary element-wise operations A = OP(B)

Parameters

  A | The result matrix (or -range, or -slice)
  proxy | The proxy object holding B and the operation

Definition at line 583 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::exclusive_scan | ( | vector_base< NumericT > const & | input,
|  | vector_base< NumericT > & | output
| ) |  |

This function implements an exclusive scan using CUDA.

Parameters

  input | Input vector
  output | The output vector. Either idential to input or non-overlapping.

Definition at line 1251 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::extract_L | ( | compressed_matrix< NumericT > const & | A,
|  | compressed_matrix< NumericT > & | L
| ) |  |

Definition at line 51 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::extract_LU | ( | compressed_matrix< NumericT > const & | A,
|  | compressed_matrix< NumericT > & | L,
|  | compressed_matrix< NumericT > & | U
| ) |  |

Definition at line 137 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::givens_next | ( | matrix_base< NumericT > & | matrix,
|  | vector_base< NumericT > & | tmp1,
|  | vector_base< NumericT > & | tmp2,
|  | int | l,
|  | int | m
| ) |  |

Definition at line 922 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::house_update_A_left | ( | matrix_base< NumericT > & | A,
|  | vector_base< NumericT > & | D,
|  | vcl_size_t | start
| ) |  |

Definition at line 797 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::house_update_A_right | ( | matrix_base< NumericT > & | A,
|  | vector_base< NumericT > & | D
| ) |  |

Definition at line 840 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::house_update_QL | ( | matrix_base< NumericT > & | Q,
|  | vector_base< NumericT > & | D,
|  | vcl_size_t | A_size1
| ) |  |

Definition at line 884 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::icc_chow_patel_sweep | ( | compressed_matrix< NumericT > & | L,
|  | vector< NumericT > const & | aij_L
| ) |  |

Performs one nonlinear relaxation step in the Chow-Patel-ILU using OpenCL (cf. Algorithm 2 in paper)

Definition at line 116 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::icc_scale | ( | compressed_matrix< NumericT > const & | A,
|  | compressed_matrix< NumericT > & | L
| ) |  |

Scales the values extracted from A such that A' = DAD has unit diagonal. Updates values from A in L and U accordingly.

Definition at line 93 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::ilu_chow_patel_sweep | ( | compressed_matrix< NumericT > & | L,
|  | vector< NumericT > const & | aij_L,
|  | compressed_matrix< NumericT > & | U_trans,
|  | vector< NumericT > const & | aij_U_trans
| ) |  |

Performs one nonlinear relaxation step in the Chow-Patel-ILU using OpenCL (cf. Algorithm 2 in paper)

Definition at line 213 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::ilu_form_neumann_matrix | ( | compressed_matrix< NumericT > & | R,
|  | vector< NumericT > & | diag_R
| ) |  |

Definition at line 243 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::ilu_scale | ( | compressed_matrix< NumericT > const & | A,
|  | compressed_matrix< NumericT > & | L,
|  | compressed_matrix< NumericT > & | U
| ) |  |

Scales the values extracted from A such that A' = DAD has unit diagonal. Updates values from A in L and U accordingly.

Definition at line 186 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::inclusive_scan | ( | vector_base< NumericT > const & | input,
|  | vector_base< NumericT > & | output
| ) |  |

This function implements an inclusive scan using CUDA.

Parameters

  input | Input vector.
  output | The output vector. Either idential to input or non-overlapping.

Definition at line 1238 of file vector_operations.hpp.

template<typename T >

cl_uint viennacl::linalg::opencl::index_norm_inf | ( | vector_base< T > const & | vec | ) |

Computes the index of the first entry that is equal to the supremum-norm in modulus.

Parameters

  vec | The vector

Returns
  The result. Note that the result must be a CPU scalar (unsigned int), since gpu scalars are floating point types.

Definition at line 930 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::inner_prod_cpu | ( | vector_base< T > const & | vec1,
|  | vector_base< T > const & | vec2,
|  | T & | result
| ) |  |

Computes the inner product of two vectors - implementation. Library users should call inner_prod(vec1, vec2).

Parameters

  vec1 | The first vector
  vec2 | The second vector
  result | The result scalar (on the gpu)

Definition at line 669 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::inner_prod_impl | ( | vector_base< T > const & | vec1,
|  | vector_base< T > const & | vec2,
|  | vector_base< T > & | partial_result
| ) |  |

Computes the partial inner product of two vectors - implementation. Library users should call inner_prod(vec1, vec2).

Parameters

  vec1 | The first vector
  vec2 | The second vector
  partial_result | The results of each group

Definition at line 388 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::inner_prod_impl | ( | vector_base< T > const & | vec1,
|  | vector_base< T > const & | vec2,
|  | scalar< T > & | result
| ) |  |

Computes the inner product of two vectors - implementation. Library users should call inner_prod(vec1, vec2).

Parameters

  vec1 | The first vector
  vec2 | The second vector
  result | The result scalar (on the gpu)

Definition at line 437 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::inner_prod_impl | ( | vector_base< NumericT > const & | x,
|  | vector_tuple< NumericT > const & | vec_tuple,
|  | vector_base< NumericT > & | result
| ) |  |

Computes multiple inner products where one argument is common to all inner products. <x, y1>, <x, y2>, ..., <x, yN>

Parameters

  x | The common vector
  vec_tuple | The tuple of vectors y1, y2, ..., yN
  result | The result vector

Definition at line 488 of file vector_operations.hpp.

template<typename NumericT , typename SolverTagT >

void viennacl::linalg::opencl::inplace_solve | ( | matrix_base< NumericT > const & | A,
|  | matrix_base< NumericT > & | B,
|  | SolverTagT |
| ) |  |

Direct inplace solver for dense triangular systems. Matlab notation: A \ B.

Parameters

  A | The system matrix
  B | The matrix of row vectors, where the solution is directly written to

Definition at line 77 of file direct_solve.hpp.

template<typename NumericT , typename SOLVERTAG >

void viennacl::linalg::opencl::inplace_solve | ( | matrix_base< NumericT > const & | A,
|  | vector_base< NumericT > & | x,
|  | SOLVERTAG |
| ) |  |

Definition at line 126 of file direct_solve.hpp.

template<typename NumericT , unsigned int MAT_AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | compressed_matrix< NumericT, MAT_AlignmentV > const & | L,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::unit_lower_tag |
| ) |  |

Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.

Parameters

  L | The matrix
  x | The vector holding the right hand side. Is overwritten by the solution.

Definition at line 382 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | compressed_matrix< NumericT, AlignmentV > const & | L,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::lower_tag |
| ) |  |

Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions.

Parameters

  L | The matrix
  x | The vector holding the right hand side. Is overwritten by the solution.

Definition at line 405 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | compressed_matrix< NumericT, AlignmentV > const & | U,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::unit_upper_tag |
| ) |  |

Inplace solution of an upper triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.

Parameters

  U | The matrix
  x | The vector holding the right hand side. Is overwritten by the solution.

Definition at line 430 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | compressed_matrix< NumericT, AlignmentV > const & | U,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::upper_tag |
| ) |  |

Inplace solution of an upper triangular compressed_matrix. Typically used for LU substitutions.

Parameters

  U | The matrix
  x | The vector holding the right hand side. Is overwritten by the solution.

Definition at line 453 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const & | proxy_L,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::unit_lower_tag |
| ) |  |

Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.

Parameters

  proxy_L | The transposed matrix proxy
  x | The vector

Definition at line 538 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const & | proxy_L,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::lower_tag |
| ) |  |

Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions.

Parameters

  proxy_L | The transposed matrix proxy
  x | The vector

Definition at line 564 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const & | proxy_U,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::unit_upper_tag |
| ) |  |

Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.

Parameters

  proxy_U | The transposed matrix proxy
  x | The vector

Definition at line 594 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::inplace_solve | ( | matrix_expression< const compressed_matrix< NumericT, AlignmentV >, const compressed_matrix< NumericT, AlignmentV >, op_trans > const & | proxy_U,
|  | vector_base< NumericT > & | x,
|  | viennacl::linalg::upper_tag |
| ) |  |

Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions.

Parameters

  proxy_U | The transposed matrix proxy
  x | The vector

Definition at line 620 of file sparse_matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::matrix_assign | ( | matrix_base< NumericT > & | mat,
|  | NumericT | s,
|  | bool | clear = `false`
| ) |  |

Definition at line 294 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::matrix_column | ( | const matrix_base< NumericT > & | mat,
|  | unsigned int | j,
|  | vector_base< NumericT > & | vec
| ) |  |

Definition at line 486 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::matrix_diag_from_vector | ( | const vector_base< NumericT > & | vec,
|  | int | k,
|  | matrix_base< NumericT > & | mat
| ) |  |

Definition at line 325 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::matrix_diag_to_vector | ( | const matrix_base< NumericT > & | mat,
|  | int | k,
|  | vector_base< NumericT > & | vec
| ) |  |

Definition at line 386 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::matrix_diagonal_assign | ( | matrix_base< NumericT > & | mat,
|  | NumericT | s
| ) |  |

Definition at line 311 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::matrix_row | ( | matrix_base< NumericT > const & | mat,
|  | unsigned int | i,
|  | vector_base< NumericT > & | vec
| ) |  |

Definition at line 443 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::max_cpu | ( | vector_base< NumericT > const & | x,
|  | NumericT & | result
| ) |  |

Computes the maximum value of a vector, where the value is stored in a host value.

Parameters

  x | The vector
  result | The result scalar

Definition at line 1004 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::max_impl | ( | vector_base< NumericT > const & | x,
|  | scalar< NumericT > & | result
| ) |  |

Computes the maximum value of a vector, where the result is stored in an OpenCL buffer.

Parameters

  x | The vector
  result | The result scalar

Definition at line 966 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::min_cpu | ( | vector_base< NumericT > const & | x,
|  | NumericT & | result
| ) |  |

Computes the minimum of a vector, where the result is stored on a CPU scalar.

Parameters

  x | The vector
  result | The result scalar

Definition at line 1083 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::min_impl | ( | vector_base< NumericT > const & | x,
|  | scalar< NumericT > & | result
| ) |  |

Computes the minimum of a vector, where the result is stored in an OpenCL buffer.

Parameters

  x | The vector
  result | The result scalar

Definition at line 1045 of file vector_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::multiply_complex | ( | viennacl::vector< NumericT, AlignmentV > const & | input1,
|  | viennacl::vector< NumericT, AlignmentV > const & | input2,
|  | viennacl::vector< NumericT, AlignmentV > & | output
| ) |  |

Mutiply two complex vectors and store result in output.

Definition at line 246 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::nmf | ( | viennacl::matrix_base< NumericT > const & | V,
|  | viennacl::matrix_base< NumericT > & | W,
|  | viennacl::matrix_base< NumericT > & | H,
|  | viennacl::linalg::nmf_config const & | conf
| ) |  |

The nonnegative matrix factorization (approximation) algorithm as suggested by Lee and Seung. Factorizes a matrix V with nonnegative entries into matrices W and H such that ||V - W*H|| is minimized.

Parameters

  V | Input matrix
  W | First factor
  H | Second factor
  conf | A configuration object holding tolerances and the like

Definition at line 45 of file nmf_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_1_cpu | ( | vector_base< T > const & | vec,
|  | T & | result
| ) |  |

Computes the l^1-norm of a vector with final reduction on CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 770 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_1_impl | ( | vector_base< T > const & | vec,
|  | scalar< T > & | result
| ) |  |

Computes the l^1-norm of a vector.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 737 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_2_cpu | ( | vector_base< T > const & | vec,
|  | T & | result
| ) |  |

Computes the l^1-norm of a vector with final reduction on CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 834 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_2_impl | ( | vector_base< T > const & | vec,
|  | scalar< T > & | result
| ) |  |

Computes the l^2-norm of a vector - implementation using OpenCL summation at second step.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 801 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_inf_cpu | ( | vector_base< T > const & | vec,
|  | T & | result
| ) |  |

Computes the supremum-norm of a vector.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 898 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_inf_impl | ( | vector_base< T > const & | vec,
|  | scalar< T > & | result
| ) |  |

Computes the supremum-norm of a vector.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 865 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::norm_reduction_impl | ( | vector_base< T > const & | vec,
|  | vector_base< T > & | partial_result,
|  | cl_uint | norm_id
| ) |  |

Computes the partial work group results for vector norms.

Parameters

  vec | The vector
  partial_result | The result scalar
  norm_id | Norm selector. 0: norm_inf, 1: norm_1, 2: norm_2

Definition at line 705 of file vector_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::normalize | ( | viennacl::vector< NumericT, AlignmentV > & | input | ) |

Normalize vector on with his own size.

Definition at line 261 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_prod | ( | compressed_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > const & | r0star,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Definition at line 360 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_prod | ( | coordinate_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > const & | r0star,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Definition at line 419 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_prod | ( | ell_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > const & | r0star,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Definition at line 458 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_prod | ( | sliced_ell_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > const & | r0star,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Definition at line 505 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_prod | ( | hyb_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > const & | r0star,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Definition at line 550 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_update_s | ( | vector_base< NumericT > & | s,
|  | vector_base< NumericT > & | r,
|  | vector_base< NumericT > const & | Ap,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Definition at line 295 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_bicgstab_vector_update | ( | vector_base< NumericT > & | result,
|  | NumericT | alpha,
|  | vector_base< NumericT > & | p,
|  | NumericT | omega,
|  | vector_base< NumericT > const & | s,
|  | vector_base< NumericT > & | residual,
|  | vector_base< NumericT > const & | As,
|  | NumericT | beta,
|  | vector_base< NumericT > const & | Ap,
|  | vector_base< NumericT > const & | r0star,
|  | vector_base< NumericT > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size
| ) |  |

Definition at line 326 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_cg_prod | ( | compressed_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > & | inner_prod_buffer
| ) |  |

Definition at line 78 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_cg_prod | ( | coordinate_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > & | inner_prod_buffer
| ) |  |

Definition at line 131 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_cg_prod | ( | ell_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > & | inner_prod_buffer
| ) |  |

Definition at line 165 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_cg_prod | ( | sliced_ell_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > & | inner_prod_buffer
| ) |  |

Definition at line 207 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_cg_prod | ( | hyb_matrix< NumericT > const & | A,
|  | vector_base< NumericT > const & | p,
|  | vector_base< NumericT > & | Ap,
|  | vector_base< NumericT > & | inner_prod_buffer
| ) |  |

Definition at line 247 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::pipelined_cg_vector_update | ( | vector_base< NumericT > & | result,
|  | NumericT | alpha,
|  | vector_base< NumericT > & | p,
|  | vector_base< NumericT > & | r,
|  | vector_base< NumericT > const & | Ap,
|  | NumericT | beta,
|  | vector_base< NumericT > & | inner_prod_buffer
| ) |  |

Definition at line 51 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_gram_schmidt_stage1 | ( | vector_base< T > const & | device_krylov_basis,
|  | vcl_size_t | v_k_size,
|  | vcl_size_t | v_k_internal_size,
|  | vcl_size_t | param_k,
|  | vector_base< T > & | vi_in_vk_buffer,
|  | vcl_size_t | buffer_chunk_size
| ) |  |

Definition at line 642 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_gram_schmidt_stage2 | ( | vector_base< T > & | device_krylov_basis,
|  | vcl_size_t | v_k_size,
|  | vcl_size_t | v_k_internal_size,
|  | vcl_size_t | param_k,
|  | vector_base< T > const & | vi_in_vk_buffer,
|  | vector_base< T > & | R_buffer,
|  | vcl_size_t | krylov_dim,
|  | vector_base< T > & | inner_prod_buffer,
|  | vcl_size_t | buffer_chunk_size
| ) |  |

Definition at line 667 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_normalize_vk | ( | vector_base< T > & | v_k,
|  | vector_base< T > const & | residual,
|  | vector_base< T > & | R_buffer,
|  | vcl_size_t | offset_in_R,
|  | vector_base< T > const & | inner_prod_buffer,
|  | vector_base< T > & | r_dot_vk_buffer,
|  | vcl_size_t | buffer_chunk_size,
|  | vcl_size_t | buffer_chunk_offset
| ) |  |

Performs a vector normalization needed for an efficient pipelined GMRES algorithm.

This routines computes for vectors 'r', 'v_k': Second reduction step for ||v_k|| v_k /= ||v_k|| First reduction step for <r, v_k>

Definition at line 609 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_prod | ( | compressed_matrix< T > const & | A,
|  | vector_base< T > const & | p,
|  | vector_base< T > & | Ap,
|  | vector_base< T > & | inner_prod_buffer
| ) |  |

Definition at line 727 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_prod | ( | coordinate_matrix< T > const & | A,
|  | vector_base< T > const & | p,
|  | vector_base< T > & | Ap,
|  | vector_base< T > & | inner_prod_buffer
| ) |  |

Definition at line 781 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_prod | ( | ell_matrix< T > const & | A,
|  | vector_base< T > const & | p,
|  | vector_base< T > & | Ap,
|  | vector_base< T > & | inner_prod_buffer
| ) |  |

Definition at line 818 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_prod | ( | sliced_ell_matrix< T > const & | A,
|  | vector_base< T > const & | p,
|  | vector_base< T > & | Ap,
|  | vector_base< T > & | inner_prod_buffer
| ) |  |

Definition at line 856 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_prod | ( | hyb_matrix< T > const & | A,
|  | vector_base< T > const & | p,
|  | vector_base< T > & | Ap,
|  | vector_base< T > & | inner_prod_buffer
| ) |  |

Definition at line 898 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::pipelined_gmres_update_result | ( | vector_base< T > & | result,
|  | vector_base< T > const & | residual,
|  | vector_base< T > const & | krylov_basis,
|  | vcl_size_t | v_k_size,
|  | vcl_size_t | v_k_internal_size,
|  | vector_base< T > const & | coefficients,
|  | vcl_size_t | param_k
| ) |  |

Definition at line 699 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::plane_rotation | ( | vector_base< T > & | vec1,
|  | vector_base< T > & | vec2,
|  | T | alpha,
|  | T | beta
| ) |  |

Computes a plane rotation of two vectors.

Computes (x,y) <- (alpha * x + beta * y, -beta * x + alpha * y)

Parameters

  vec1 | The first vector
  vec2 | The second vector
  alpha | The first transformation coefficient
  beta | The second transformation coefficient

Definition at line 1156 of file vector_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::vandermonde_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::vector_base< NumericT > const & | x,
|  | viennacl::vector_base< NumericT > & | y
| ) |  |

Carries out matrix-vector multiplication with a vandermonde_matrix.

Implementation of the convenience expression y = prod(A, x);

Parameters

  A | The Vandermonde matrix
  x | The vector
  y | The result vector

Definition at line 49 of file vandermonde_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | const viennacl::compressed_matrix< NumericT, AlignmentV > & | A,
|  | const viennacl::vector_base< NumericT > & | x,
|  | NumericT | alpha,
|  | viennacl::vector_base< NumericT > & | y,
|  | NumericT | beta
| ) |  |

Carries out matrix-vector multiplication with a compressed_matrix.

Implementation of the convenience expression y = prod(A, x);

Parameters

  A | The matrix
  x | The vector
  y | the result vector

Definition at line 82 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | const viennacl::compressed_matrix< NumericT, AlignmentV > & | sp_A,
|  | const viennacl::matrix_base< NumericT > & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Carries out sparse_matrix-matrix multiplication first matrix being compressed.

Implementation of the convenience expression y = prod(sp_A, d_A);

Parameters

  sp_A | The sparse matrix
  d_A | The dense matrix
  y | The y matrix

Definition at line 191 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::compressed_matrix< NumericT, AlignmentV > const & | sp_A,
|  | viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Carries out matrix-trans(matrix) multiplication first matrix being compressed and the second transposed.

Implementation of the convenience expression y = prod(sp_A, d_A);

Parameters

  sp_A | The sparse matrix
  d_A | The transposed dense matrix
  y | The y matrix

Definition at line 223 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::compressed_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::compressed_matrix< NumericT, AlignmentV > const & | B,
|  | viennacl::compressed_matrix< NumericT, AlignmentV > & | C
| ) |  |

Carries out sparse_matrix-sparse_matrix multiplication for CSR matrices.

Implementation of the convenience expression C = prod(A, B); Based on computing C(i, :) = A(i, :) * B via merging the respective rows of B

Parameters

  A | Left factor
  B | Right factor
  C | Result matrix

Definition at line 257 of file sparse_matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::prod_impl | ( | const matrix_base< NumericT > & | mat,
|  | bool | trans_A,
|  | const vector_base< NumericT > & | vec,
|  | vector_base< NumericT > & | result
| ) |  |

Carries out matrix-vector multiplication.

Implementation of the convenience expression result = prod(mat, vec);

Parameters

  mat | The matrix
  vec | The vector
  result | The result vector

Definition at line 620 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::prod_impl | ( | viennacl::compressed_compressed_matrix< NumericT > const & | A,
|  | viennacl::vector_base< NumericT > const & | x,
|  | NumericT | alpha,
|  | viennacl::vector_base< NumericT > & | y,
|  | NumericT | beta
| ) |  |

Carries out matrix-vector multiplication with a compressed_compressed_matrix.

Implementation of the convenience expression y = prod(A, x);

Parameters

  A | The matrix
  x | The vector
  y | the result vector

Definition at line 658 of file sparse_matrix_operations.hpp.

template<typename NumericT , typename ScalarType >

void viennacl::linalg::opencl::prod_impl | ( | matrix_base< NumericT > const & | A,
|  | bool | A_trans,
|  | matrix_base< NumericT > const & | B,
|  | bool | B_trans,
|  | matrix_base< NumericT > & | C,
|  | ScalarType | alpha,
|  | ScalarType | beta
| ) |  |

Carries out matrix-matrix multiplication.

Implementation of C = prod(A, B);

Definition at line 658 of file matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::coordinate_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::vector_base< NumericT > const & | x,
|  | NumericT | alpha,
|  | viennacl::vector_base< NumericT > & | y,
|  | NumericT | beta
| ) |  |

Carries out matrix-vector multiplication with a coordinate_matrix.

Implementation of the convenience expression y = prod(A, x);

Parameters

  A | The matrix
  x | The vector
  y | the result vector

Definition at line 730 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::coordinate_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::matrix_base< NumericT > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Carries out sparse-matrix-dense-matrix multiplication, where the sparse matrix is a coordinate_matrix.

Implementation of the convenience expression y = prod(A, B); with A being sparse (COO) and B being dense

Parameters

  A | The sparse matrix (COO forA)
  d_A | The dense matrix
  y | the result vector

Definition at line 787 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::coordinate_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Carries out sparse-matrix-dense-matrix multiplication, where the sparse matrix is a coordinate_matrix.

Implementation of the convenience expression y = prod(A, trans(B)); with A being sparse (COO) and B being dense

Parameters

  A | The sparse matrix (COO forA)
  d_A | The dense matrix
  y | the result vector

Definition at line 828 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::ell_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::vector_base< NumericT > const & | x,
|  | NumericT | alpha,
|  | viennacl::vector_base< NumericT > & | y,
|  | NumericT | beta
| ) |  |

Definition at line 868 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::ell_matrix< NumericT, AlignmentV > const & | sp_A,
|  | viennacl::matrix_base< NumericT > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Carries out Sparse Matrix(ELL)-Dense Matrix multiplication.

Implementation of the convenience expression y = prod(sp_A, d_A); sp_mat being in ELL format

Parameters

  sp_A | The sparse matrix (ELL)
  d_A | The dense matrix
  y | The y matrix

Definition at line 948 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::ell_matrix< NumericT, AlignmentV > const & | sp_A,
|  | viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Carries out Sparse Matrix(ELL)-Dense Transposed Matrix multiplication.

Implementation of the convenience expression y = prod(sp_A, trans(d_A)); sp_mat being in ELL format

Parameters

  sp_A | The sparse matrix (ELL)
  d_A | The dense transposed matrix
  y | The y matrix

Definition at line 993 of file sparse_matrix_operations.hpp.

template<typename ScalarT , typename IndexT >

void viennacl::linalg::opencl::prod_impl | ( | viennacl::sliced_ell_matrix< ScalarT, IndexT > const & | A,
|  | viennacl::vector_base< ScalarT > const & | x,
|  | ScalarT | alpha,
|  | viennacl::vector_base< ScalarT > & | y,
|  | ScalarT | beta
| ) |  |

Definition at line 1035 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::hyb_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::vector_base< NumericT > const & | x,
|  | NumericT | alpha,
|  | viennacl::vector_base< NumericT > & | y,
|  | NumericT | beta
| ) |  |

Definition at line 1106 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::hyb_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::matrix_base< NumericT > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Definition at line 1171 of file sparse_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::prod_impl | ( | viennacl::hyb_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::matrix_expression< const viennacl::matrix_base< NumericT >, const viennacl::matrix_base< NumericT >, viennacl::op_trans > const & | d_A,
|  | viennacl::matrix_base< NumericT > & | y
| ) |  |

Definition at line 1204 of file sparse_matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::radix2 | ( | viennacl::ocl::handle< cl_mem > const & | in,
|  | vcl_size_t | size,
|  | vcl_size_t | stride,
|  | vcl_size_t | batch_num,
|  | NumericT | sign = `NumericT(-1)`,
|  | viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::DATA_ORDER | data_order = `viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::ROW_MAJOR`
| ) |  |

Radix-2 algorithm for computing Fourier transformation.

Works only on power-of-two sizes of data. Serial implementation has o(n * lg n) complexity. This is a Cooley-Tukey algorithm

Definition at line 161 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::real_to_complex | ( | viennacl::vector_base< NumericT > const & | in,
|  | viennacl::vector_base< NumericT > & | out,
|  | vcl_size_t | size
| ) |  |

Create complex vector from real vector (even elements(2*k) = real part, odd elements(2*k+1) = imaginary part)

Definition at line 306 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::reorder | ( | viennacl::ocl::handle< cl_mem > const & | in,
|  | vcl_size_t | size,
|  | vcl_size_t | stride,
|  | vcl_size_t | bits_datasize,
|  | vcl_size_t | batch_num,
|  | viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::DATA_ORDER | data_order = `viennacl::linalg::host_based::detail::fft::FFT_DATA_ORDER::ROW_MAJOR`
| ) |  |

Definition at line 130 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::reverse | ( | viennacl::vector_base< NumericT > & | in | ) |

Reverse vector to oposite order and save it in input vector.

Definition at line 334 of file fft_operations.hpp.

template<typename NumericT , typename ScalarT1 >

void viennacl::linalg::opencl::scaled_rank_1_update | ( | matrix_base< NumericT > & | A,
|  | ScalarT1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha,
|  | const vector_base< NumericT > & | vec1,
|  | const vector_base< NumericT > & | vec2
| ) |  |

The implementation of the operation mat += alpha * vec1 * vec2^T, i.e. a scaled rank 1 update.

Implementation of the convenience expression result += alpha * outer_prod(vec1, vec2);

Parameters

  A | The matrix to be updated
  alpha | The scaling factor (either a viennacl::scalar<>, float, or double)
  len_alpha | Length of the buffer for an eventual final reduction step (currently always '1')
  reciprocal_alpha | Use 1/alpha instead of alpha
  flip_sign_alpha | Use -alpha instead of alpha
  vec1 | The first vector
  vec2 | The second vector

Definition at line 696 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::sum_cpu | ( | vector_base< NumericT > const & | x,
|  | NumericT & | result
| ) |  |

Computes the sum over all entries of a vector.

Parameters

  x | The vector
  result | The result scalar

Definition at line 1137 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::opencl::sum_impl | ( | vector_base< NumericT > const & | x,
|  | scalar< NumericT > & | result
| ) |  |

Computes the sum over all entries of a vector.

Parameters

  x | The vector
  result | The result scalar

Definition at line 1122 of file vector_operations.hpp.

template<typename ScalarT1 , typename ScalarT2 >

viennacl::enable_if< viennacl::is_scalar<ScalarT1>::value && viennacl::is_scalar<ScalarT2>::value >::type viennacl::linalg::opencl::swap | ( | ScalarT1 & | s1,
|  | ScalarT2 & | s2
| ) |  |

Swaps the contents of two scalars, data is copied.

Parameters

  s1 | The first scalar
  s2 | The second scalar

Definition at line 182 of file scalar_operations.hpp.

template<typename NumericT , typename SizeT , typename DistanceT >

void viennacl::linalg::opencl::trans | ( | const matrix_expression< const matrix_base< NumericT, SizeT, DistanceT >, const matrix_base< NumericT, SizeT, DistanceT >, op_trans > & | proxy,
|  | matrix_base< NumericT > & | temp_trans
| ) |  |

Definition at line 276 of file matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::transpose | ( | viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > & | input | ) |

Inplace_transpose matrix.

Definition at line 277 of file fft_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::opencl::transpose | ( | viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > const & | input,
|  | viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > & | output
| ) |  |

Transpose matrix.

Definition at line 291 of file fft_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::vector_assign | ( | vector_base< T > & | vec1,
|  | const T & | alpha,
|  | bool | up_to_internal_size = `false`
| ) |  |

Assign a constant value to a vector (-range/-slice)

Parameters

  vec1 | The vector to which the value should be assigned
  alpha | The value to be assigned
  up_to_internal_size | Specifies whether alpha should also be written to padded memory (mostly used for clearing the whole buffer).

Definition at line 246 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::opencl::vector_swap | ( | vector_base< T > & | vec1,
|  | vector_base< T > & | vec2
| ) |  |

Swaps the contents of two vectors, data is copied.

Parameters

  vec1 | The first vector (or -range, or -slice)
  vec2 | The second vector (or -range, or -slice)

Definition at line 272 of file vector_operations.hpp.

## Variable Documentation

const std::string viennacl::linalg::opencl::BISECT_KERNEL_LARGE = "bisectKernelLarge"

Definition at line 44 of file bisect_kernel_calls.hpp.

const std::string viennacl::linalg::opencl::BISECT_KERNEL_LARGE_MULT_INTERVALS = "bisectKernelLarge_MultIntervals"

Definition at line 46 of file bisect_kernel_calls.hpp.

const std::string viennacl::linalg::opencl::BISECT_KERNEL_LARGE_ONE_INTERVALS = "bisectKernelLarge_OneIntervals"

Definition at line 45 of file bisect_kernel_calls.hpp.

const std::string viennacl::linalg::opencl::BISECT_KERNEL_SMALL = "bisectKernelSmall"

Definition at line 43 of file bisect_kernel_calls.hpp.

const std::string viennacl::linalg::opencl::SVD_BIDIAG_PACK_KERNEL = "bidiag_pack"

Definition at line 125 of file matrix_operations.hpp.

const std::string viennacl::linalg::opencl::SVD_COPY_COL_KERNEL = "copy_col"

Definition at line 130 of file matrix_operations.hpp.

const std::string viennacl::linalg::opencl::SVD_COPY_ROW_KERNEL = "copy_row"

Definition at line 131 of file matrix_operations.hpp.

const std::string viennacl::linalg::opencl::SVD_GIVENS_NEXT_KERNEL = "givens_next"

Definition at line 129 of file matrix_operations.hpp.

const std::string viennacl::linalg::opencl::SVD_HOUSEHOLDER_UPDATE_A_LEFT_KERNEL = "house_update_A_left"

Definition at line 126 of file matrix_operations.hpp.

const std::string viennacl::linalg::opencl::SVD_HOUSEHOLDER_UPDATE_A_RIGHT_KERNEL = "house_update_A_right"

Definition at line 127 of file matrix_operations.hpp.

const std::string viennacl::linalg::opencl::SVD_HOUSEHOLDER_UPDATE_QL_KERNEL = "house_update_QL"

Definition at line 128 of file matrix_operations.hpp.