ViennaCL - The Vienna Computing Library  1.5.0
Namespaces | Functions
viennacl::linalg::opencl Namespace Reference

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

Namespaces

namespace  detail
 

Helper functions for OpenCL-accelerated linear algebra operations.


namespace  kernels
 

Contains the OpenCL kernel generation functions for a predefined set of functionality.


Functions

template<typename NumericT , typename F1 , typename F2 , typename SOLVERTAG >
void inplace_solve (const matrix_base< NumericT, F1 > &A, matrix_base< NumericT, F2 > &B, SOLVERTAG)
 Direct inplace solver for dense triangular systems. Matlab notation: A \ B.
template<typename NumericT , typename F1 , typename F2 , typename SOLVERTAG >
void inplace_solve (const matrix_base< NumericT, F1 > &A, matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans > proxy_B, SOLVERTAG)
 Direct inplace solver for dense triangular systems with transposed right hand side.
template<typename NumericT , typename F1 , typename F2 , typename SOLVERTAG >
void inplace_solve (const matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &proxy_A, matrix_base< NumericT, F2 > &B, SOLVERTAG)
 Direct inplace solver for dense triangular systems that stem from transposed triangular systems.
template<typename NumericT , typename F1 , typename F2 , typename SOLVERTAG >
void inplace_solve (const matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &proxy_A, matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans > proxy_B, SOLVERTAG)
 Direct inplace solver for dense transposed triangular systems with transposed right hand side. Matlab notation: A' \ B'.
template<typename NumericT , typename F , typename SOLVERTAG >
void inplace_solve (const matrix_base< NumericT, F > &mat, vector_base< NumericT > &vec, SOLVERTAG)
template<typename NumericT , typename F , typename SOLVERTAG >
void inplace_solve (const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans > &proxy, vector_base< NumericT > &vec, SOLVERTAG)
 Direct inplace solver for dense upper triangular systems that stem from transposed lower triangular systems.
template<typename NumericT , typename F , typename ScalarType1 >
void am (matrix_base< NumericT, F > &mat1, matrix_base< NumericT, F > const &mat2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
template<typename NumericT , typename F , typename ScalarType1 , typename ScalarType2 >
void ambm (matrix_base< NumericT, F > &mat1, matrix_base< NumericT, F > const &mat2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, matrix_base< NumericT, F > const &mat3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename NumericT , typename F , typename ScalarType1 , typename ScalarType2 >
void ambm_m (matrix_base< NumericT, F > &mat1, matrix_base< NumericT, F > const &mat2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, matrix_base< NumericT, F > const &mat3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename NumericT , typename F >
void matrix_assign (matrix_base< NumericT, F > &mat, NumericT s, bool clear=false)
template<typename NumericT , typename F >
void matrix_diagonal_assign (matrix_base< NumericT, F > &mat, NumericT s)
template<typename NumericT , typename F >
void matrix_diag_from_vector (const vector_base< NumericT > &vec, int k, matrix_base< NumericT, F > &mat)
template<typename NumericT , typename F >
void matrix_diag_to_vector (const matrix_base< NumericT, F > &mat, int k, vector_base< NumericT > &vec)
template<typename NumericT , typename F >
void matrix_row (const matrix_base< NumericT, F > &mat, unsigned int i, vector_base< NumericT > &vec)
template<typename NumericT , typename F >
void matrix_column (const matrix_base< NumericT, F > &mat, unsigned int j, vector_base< NumericT > &vec)
template<typename T , typename F , typename OP >
void element_op (matrix_base< T, F > &A, matrix_expression< const matrix_base< T, F >, const matrix_base< T, F >, op_element_binary< OP > > const &proxy)
 Implementation of binary element-wise operations A = OP(B,C)
template<typename T , typename F , typename OP >
void element_op (matrix_base< T, F > &A, matrix_expression< const matrix_base< T, F >, const matrix_base< T, F >, op_element_unary< OP > > const &proxy)
 Implementation of unary element-wise operations A = OP(B)
template<typename NumericT , typename F >
void prod_impl (const matrix_base< NumericT, F > &mat, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
 Carries out matrix-vector multiplication.
template<typename NumericT , typename F >
void prod_impl (const viennacl::matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans > &mat_trans, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
 Carries out matrix-vector multiplication with a transposed matrix.
template<typename NumericT , typename F1 , typename F2 , typename F3 , typename ScalarType >
void prod_impl (const matrix_base< NumericT, F1 > &A, const matrix_base< NumericT, F2 > &B, matrix_base< NumericT, F3 > &C, ScalarType alpha, ScalarType beta)
 Carries out matrix-matrix multiplication.
template<typename NumericT , typename F1 , typename F2 , typename F3 , typename ScalarType >
void prod_impl (const viennacl::matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &A, const matrix_base< NumericT, F2 > &B, matrix_base< NumericT, F3 > &C, ScalarType alpha, ScalarType beta)
 Carries out matrix-matrix multiplication.
template<typename NumericT , typename F1 , typename F2 , typename F3 , typename ScalarType >
void prod_impl (const matrix_base< NumericT, F1 > &A, const viennacl::matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans > &B, matrix_base< NumericT, F3 > &C, ScalarType alpha, ScalarType beta)
 Carries out matrix-matrix multiplication.
template<typename NumericT , typename F1 , typename F2 , typename F3 , typename ScalarType >
void prod_impl (const viennacl::matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &A, const viennacl::matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans > &B, matrix_base< NumericT, F3 > &C, ScalarType alpha, ScalarType beta)
 Carries out matrix-matrix multiplication.
template<typename NumericT , typename F , typename S1 >
void scaled_rank_1_update (matrix_base< NumericT, F > &mat1, S1 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.
template<typename S1 , typename S2 , typename ScalarType1 >
viennacl::enable_if
< viennacl::is_scalar< S1 >
::value &&viennacl::is_scalar
< S2 >::value
&&viennacl::is_any_scalar
< ScalarType1 >::value >::type 
as (S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
template<typename S1 , typename S2 , typename ScalarType1 , typename S3 , typename ScalarType2 >
viennacl::enable_if
< viennacl::is_scalar< S1 >
::value &&viennacl::is_scalar
< S2 >::value
&&viennacl::is_scalar< S3 >
::value
&&viennacl::is_any_scalar
< ScalarType1 >::value
&&viennacl::is_any_scalar
< ScalarType2 >::value >::type 
asbs (S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename S1 , typename S2 , typename ScalarType1 , typename S3 , typename ScalarType2 >
viennacl::enable_if
< viennacl::is_scalar< S1 >
::value &&viennacl::is_scalar
< S2 >::value
&&viennacl::is_scalar< S3 >
::value
&&viennacl::is_any_scalar
< ScalarType1 >::value
&&viennacl::is_any_scalar
< ScalarType2 >::value >::type 
asbs_s (S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename S1 , typename S2 >
viennacl::enable_if
< viennacl::is_scalar< S1 >
::value &&viennacl::is_scalar
< S2 >::value >::type 
swap (S1 &s1, S2 &s2)
 Swaps the contents of two scalars, data is copied.
template<class TYPE , unsigned int ALIGNMENT>
void prod_impl (const viennacl::compressed_matrix< TYPE, ALIGNMENT > &mat, const viennacl::vector_base< TYPE > &vec, viennacl::vector_base< TYPE > &result)
 Carries out matrix-vector multiplication with a compressed_matrix.
template<typename TYPE , unsigned int ALIGNMENT, typename F1 , typename F2 >
void prod_impl (const viennacl::compressed_matrix< TYPE, ALIGNMENT > &sp_mat, const viennacl::matrix_base< TYPE, F1 > &d_mat, viennacl::matrix_base< TYPE, F2 > &result)
 Carries out sparse_matrix-matrix multiplication first matrix being compressed.
template<typename TYPE , unsigned int ALIGNMENT, typename F1 , typename F2 >
void prod_impl (const viennacl::compressed_matrix< TYPE, ALIGNMENT > &sp_mat, const viennacl::matrix_expression< const viennacl::matrix_base< TYPE, F1 >, const viennacl::matrix_base< TYPE, F1 >, viennacl::op_trans > &d_mat, viennacl::matrix_base< TYPE, F2 > &result)
 Carries out matrix-trans(matrix) multiplication first matrix being compressed and the second transposed.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &L, vector_base< SCALARTYPE > &vec, viennacl::linalg::unit_lower_tag)
 Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &L, vector_base< SCALARTYPE > &vec, viennacl::linalg::lower_tag)
 Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &U, vector_base< SCALARTYPE > &vec, viennacl::linalg::unit_upper_tag)
 Inplace solution of an upper triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &U, vector_base< SCALARTYPE > &vec, viennacl::linalg::upper_tag)
 Inplace solution of an upper triangular compressed_matrix. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &proxy_L, vector_base< SCALARTYPE > &vec, viennacl::linalg::unit_lower_tag)
 Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &proxy_L, vector_base< SCALARTYPE > &vec, viennacl::linalg::lower_tag)
 Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &proxy_U, vector_base< SCALARTYPE > &vec, viennacl::linalg::unit_upper_tag)
 Inplace solution of a lower triangular compressed_matrix with unit diagonal. Typically used for LU substitutions.
template<typename SCALARTYPE , unsigned int MAT_ALIGNMENT>
void inplace_solve (matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &proxy_U, vector_base< SCALARTYPE > &vec, viennacl::linalg::upper_tag)
 Inplace solution of a lower triangular compressed_matrix. Typically used for LU substitutions.
template<class TYPE >
void prod_impl (const viennacl::compressed_compressed_matrix< TYPE > &mat, const viennacl::vector_base< TYPE > &vec, viennacl::vector_base< TYPE > &result)
 Carries out matrix-vector multiplication with a compressed_compressed_matrix.
template<class SCALARTYPE , unsigned int ALIGNMENT>
void prod_impl (const viennacl::coordinate_matrix< SCALARTYPE, ALIGNMENT > &mat, const viennacl::vector_base< SCALARTYPE > &vec, viennacl::vector_base< SCALARTYPE > &result)
 Carries out matrix-vector multiplication with a coordinate_matrix.
template<typename NumericT , unsigned int ALIGNMENT, typename F1 , typename F2 >
void prod_impl (const viennacl::coordinate_matrix< NumericT, ALIGNMENT > &mat, const viennacl::matrix_base< NumericT, F1 > &d_mat, viennacl::matrix_base< NumericT, F2 > &result)
 Carries out sparse-matrix-dense-matrix multiplication, where the sparse matrix is a coordinate_matrix.
template<typename NumericT , unsigned int ALIGNMENT, typename F1 , typename F2 >
void prod_impl (const viennacl::coordinate_matrix< NumericT, ALIGNMENT > &mat, const viennacl::matrix_expression< const viennacl::matrix_base< NumericT, F1 >, const viennacl::matrix_base< NumericT, F1 >, viennacl::op_trans > &d_mat, viennacl::matrix_base< NumericT, F2 > &result)
 Carries out sparse-matrix-dense-matrix multiplication, where the sparse matrix is a coordinate_matrix.
template<class TYPE , unsigned int ALIGNMENT>
void prod_impl (const viennacl::ell_matrix< TYPE, ALIGNMENT > &mat, const viennacl::vector_base< TYPE > &vec, viennacl::vector_base< TYPE > &result)
template<class ScalarType , unsigned int ALIGNMENT, class NumericT , typename F1 , typename F2 >
void prod_impl (const viennacl::ell_matrix< ScalarType, ALIGNMENT > &sp_mat, const viennacl::matrix_base< NumericT, F1 > &d_mat, viennacl::matrix_base< NumericT, F2 > &result)
 Carries out Sparse Matrix(ELL)-Dense Matrix multiplication.
template<class ScalarType , unsigned int ALIGNMENT, class NumericT , typename F1 , typename F2 >
void prod_impl (const viennacl::ell_matrix< ScalarType, ALIGNMENT > &sp_mat, const viennacl::matrix_expression< const viennacl::matrix_base< NumericT, F1 >, const viennacl::matrix_base< NumericT, F1 >, viennacl::op_trans > &d_mat, viennacl::matrix_base< NumericT, F2 > &result)
 Carries out Sparse Matrix(ELL)-Dense Transposed Matrix multiplication.
template<class TYPE , unsigned int ALIGNMENT>
void prod_impl (const viennacl::hyb_matrix< TYPE, ALIGNMENT > &mat, const viennacl::vector_base< TYPE > &vec, viennacl::vector_base< TYPE > &result)
template<typename NumericT , unsigned int ALIGNMENT, typename F1 , typename F2 >
void prod_impl (const viennacl::hyb_matrix< NumericT, ALIGNMENT > &mat, const viennacl::matrix_base< NumericT, F1 > &d_mat, viennacl::matrix_base< NumericT, F2 > &result)
template<typename NumericT , unsigned int ALIGNMENT, typename F1 , typename F2 >
void prod_impl (const viennacl::hyb_matrix< NumericT, ALIGNMENT > &mat, const viennacl::matrix_expression< const viennacl::matrix_base< NumericT, F1 >, const viennacl::matrix_base< NumericT, F1 >, viennacl::op_trans > &d_mat, viennacl::matrix_base< NumericT, F2 > &result)
template<class SCALARTYPE , unsigned int ALIGNMENT>
void prod_impl (const viennacl::vandermonde_matrix< SCALARTYPE, ALIGNMENT > &mat, const viennacl::vector_base< SCALARTYPE > &vec, viennacl::vector_base< SCALARTYPE > &result)
 Carries out matrix-vector multiplication with a vandermonde_matrix.
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)
template<typename T >
void vector_swap (vector_base< T > &vec1, vector_base< T > &vec2)
 Swaps the contents of two vectors, data is copied.
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)
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)
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).
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).
template<typename T >
void inner_prod_impl (vector_base< T > const &x, vector_tuple< T > const &vec_tuple, vector_base< T > &result)
 Computes multiple inner products where one argument is common to all inner products. <x, y1>, <x, y2>, ..., <x, yN>
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).
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.
template<typename T >
void norm_1_impl (vector_base< T > const &vec, scalar< T > &result)
 Computes the l^1-norm of a vector.
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.
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.
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.
template<typename T >
void norm_inf_impl (vector_base< T > const &vec, scalar< T > &result)
 Computes the supremum-norm of a vector.
template<typename T >
void norm_inf_cpu (vector_base< T > const &vec, T &result)
 Computes the supremum-norm of a vector.
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.
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.

Detailed Description

Holds all routines providing OpenCL linear algebra operations.


Function Documentation

void viennacl::linalg::opencl::am ( matrix_base< NumericT, F > &  mat1,
matrix_base< NumericT, F > const &  mat2,
ScalarType1 const &  alpha,
vcl_size_t  len_alpha,
bool  reciprocal_alpha,
bool  flip_sign_alpha 
)
void viennacl::linalg::opencl::ambm ( matrix_base< NumericT, F > &  mat1,
matrix_base< NumericT, F > const &  mat2,
ScalarType1 const &  alpha,
vcl_size_t  len_alpha,
bool  reciprocal_alpha,
bool  flip_sign_alpha,
matrix_base< NumericT, F > const &  mat3,
ScalarType2 const &  beta,
vcl_size_t  len_beta,
bool  reciprocal_beta,
bool  flip_sign_beta 
)
void viennacl::linalg::opencl::ambm_m ( matrix_base< NumericT, F > &  mat1,
matrix_base< NumericT, F > const &  mat2,
ScalarType1 const &  alpha,
vcl_size_t  len_alpha,
bool  reciprocal_alpha,
bool  flip_sign_alpha,
matrix_base< NumericT, F > const &  mat3,
ScalarType2 const &  beta,
vcl_size_t  len_beta,
bool  reciprocal_beta,
bool  flip_sign_beta 
)
viennacl::enable_if< viennacl::is_scalar<S1>::value && viennacl::is_scalar<S2>::value && viennacl::is_any_scalar<ScalarType1>::value >::type viennacl::linalg::opencl::as ( S1 &  s1,
S2 const &  s2,
ScalarType1 const &  alpha,
vcl_size_t  len_alpha,
bool  reciprocal_alpha,
bool  flip_sign_alpha 
)
viennacl::enable_if< viennacl::is_scalar<S1>::value && viennacl::is_scalar<S2>::value && viennacl::is_scalar<S3>::value && viennacl::is_any_scalar<ScalarType1>::value && viennacl::is_any_scalar<ScalarType2>::value >::type viennacl::linalg::opencl::asbs ( S1 &  s1,
S2 const &  s2,
ScalarType1 const &  alpha,
vcl_size_t  len_alpha,
bool  reciprocal_alpha,
bool  flip_sign_alpha,
S3 const &  s3,
ScalarType2 const &  beta,
vcl_size_t  len_beta,
bool  reciprocal_beta,
bool  flip_sign_beta 
)
viennacl::enable_if< viennacl::is_scalar<S1>::value && viennacl::is_scalar<S2>::value && viennacl::is_scalar<S3>::value && viennacl::is_any_scalar<ScalarType1>::value && viennacl::is_any_scalar<ScalarType2>::value >::type viennacl::linalg::opencl::asbs_s ( S1 &  s1,
S2 const &  s2,
ScalarType1 const &  alpha,
vcl_size_t  len_alpha,
bool  reciprocal_alpha,
bool  flip_sign_alpha,
S3 const &  s3,
ScalarType2 const &  beta,
vcl_size_t  len_beta,
bool  reciprocal_beta,
bool  flip_sign_beta 
)
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 
)
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 
)
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 
)
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:
vec1The result vector (or -range, or -slice)
proxyThe proxy object holding v2, v3 and the operation
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:
vec1The result vector (or -range, or -slice)
proxyThe proxy object holding v2 and the operation
void viennacl::linalg::opencl::element_op ( matrix_base< T, F > &  A,
matrix_expression< const matrix_base< T, F >, const matrix_base< T, F >, op_element_binary< OP > > const &  proxy 
)

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

Parameters:
AThe result matrix (or -range, or -slice)
proxyThe proxy object holding B, C, and the operation
void viennacl::linalg::opencl::element_op ( matrix_base< T, F > &  A,
matrix_expression< const matrix_base< T, F >, const matrix_base< T, F >, op_element_unary< OP > > const &  proxy 
)

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

Parameters:
AThe result matrix (or -range, or -slice)
proxyThe proxy object holding B and the operation
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:
vecThe vector
Returns:
The result. Note that the result must be a CPU scalar (unsigned int), since gpu scalars are floating point types.
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:
vec1The first vector
vec2The second vector
resultThe result scalar (on the gpu)
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:
vec1The first vector
vec2The second vector
partial_resultThe results of each group
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:
vec1The first vector
vec2The second vector
resultThe result scalar (on the gpu)
void viennacl::linalg::opencl::inner_prod_impl ( vector_base< T > const &  x,
vector_tuple< T > const &  vec_tuple,
vector_base< T > &  result 
)

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

Parameters:
xThe common vector
vec_tupleThe tuple of vectors y1, y2, ..., yN
resultThe result vector
void viennacl::linalg::opencl::inplace_solve ( const matrix_base< NumericT, F1 > &  A,
matrix_base< NumericT, F2 > &  B,
SOLVERTAG   
)

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

Parameters:
AThe system matrix
BThe matrix of row vectors, where the solution is directly written to
void viennacl::linalg::opencl::inplace_solve ( const matrix_base< NumericT, F1 > &  A,
matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >  proxy_B,
SOLVERTAG   
)

Direct inplace solver for dense triangular systems with transposed right hand side.

Parameters:
AThe system matrix
proxy_BThe transposed matrix of row vectors, where the solution is directly written to
void viennacl::linalg::opencl::inplace_solve ( const matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &  proxy_A,
matrix_base< NumericT, F2 > &  B,
SOLVERTAG   
)

Direct inplace solver for dense triangular systems that stem from transposed triangular systems.

Parameters:
proxy_AThe system matrix proxy
BThe matrix holding the load vectors, where the solution is directly written to
void viennacl::linalg::opencl::inplace_solve ( const matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &  proxy_A,
matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans >  proxy_B,
SOLVERTAG   
)

Direct inplace solver for dense transposed triangular systems with transposed right hand side. Matlab notation: A' \ B'.

Parameters:
proxy_AThe system matrix proxy
proxy_BThe matrix holding the load vectors, where the solution is directly written to
void viennacl::linalg::opencl::inplace_solve ( const matrix_base< NumericT, F > &  mat,
vector_base< NumericT > &  vec,
SOLVERTAG   
)
void viennacl::linalg::opencl::inplace_solve ( compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &  L,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::unit_lower_tag   
)

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

Parameters:
LThe matrix
vecThe vector holding the right hand side. Is overwritten by the solution.
void viennacl::linalg::opencl::inplace_solve ( const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans > &  proxy,
vector_base< NumericT > &  vec,
SOLVERTAG   
)

Direct inplace solver for dense upper triangular systems that stem from transposed lower triangular systems.

Parameters:
proxyThe system matrix proxy
vecThe load vector, where the solution is directly written to
void viennacl::linalg::opencl::inplace_solve ( compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &  L,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::lower_tag   
)

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

Parameters:
LThe matrix
vecThe vector holding the right hand side. Is overwritten by the solution.
void viennacl::linalg::opencl::inplace_solve ( compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &  U,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::unit_upper_tag   
)

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

Parameters:
UThe matrix
vecThe vector holding the right hand side. Is overwritten by the solution.
void viennacl::linalg::opencl::inplace_solve ( compressed_matrix< SCALARTYPE, MAT_ALIGNMENT > const &  U,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::upper_tag   
)

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

Parameters:
UThe matrix
vecThe vector holding the right hand side. Is overwritten by the solution.
void viennacl::linalg::opencl::inplace_solve ( matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &  proxy_L,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::unit_lower_tag   
)

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

Parameters:
proxy_LThe transposed matrix proxy
vecThe vector
void viennacl::linalg::opencl::inplace_solve ( matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &  proxy_L,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::lower_tag   
)

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

Parameters:
proxy_LThe transposed matrix proxy
vecThe vector
void viennacl::linalg::opencl::inplace_solve ( matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &  proxy_U,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::unit_upper_tag   
)

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

Parameters:
proxy_UThe transposed matrix proxy
vecThe vector
void viennacl::linalg::opencl::inplace_solve ( matrix_expression< const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, const compressed_matrix< SCALARTYPE, MAT_ALIGNMENT >, op_trans > const &  proxy_U,
vector_base< SCALARTYPE > &  vec,
viennacl::linalg::upper_tag   
)

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

Parameters:
proxy_UThe transposed matrix proxy
vecThe vector
void viennacl::linalg::opencl::matrix_assign ( matrix_base< NumericT, F > &  mat,
NumericT  s,
bool  clear = false 
)
void viennacl::linalg::opencl::matrix_column ( const matrix_base< NumericT, F > &  mat,
unsigned int  j,
vector_base< NumericT > &  vec 
)
void viennacl::linalg::opencl::matrix_diag_from_vector ( const vector_base< NumericT > &  vec,
int  k,
matrix_base< NumericT, F > &  mat 
)
void viennacl::linalg::opencl::matrix_diag_to_vector ( const matrix_base< NumericT, F > &  mat,
int  k,
vector_base< NumericT > &  vec 
)
void viennacl::linalg::opencl::matrix_diagonal_assign ( matrix_base< NumericT, F > &  mat,
NumericT  s 
)
void viennacl::linalg::opencl::matrix_row ( const matrix_base< NumericT, F > &  mat,
unsigned int  i,
vector_base< NumericT > &  vec 
)
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:
vecThe vector
resultThe result scalar
void viennacl::linalg::opencl::norm_1_impl ( vector_base< T > const &  vec,
scalar< T > &  result 
)

Computes the l^1-norm of a vector.

Parameters:
vecThe vector
resultThe result scalar
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:
vecThe vector
resultThe result scalar
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:
vecThe vector
resultThe result scalar
void viennacl::linalg::opencl::norm_inf_cpu ( vector_base< T > const &  vec,
T &  result 
)

Computes the supremum-norm of a vector.

Parameters:
vecThe vector
resultThe result scalar
void viennacl::linalg::opencl::norm_inf_impl ( vector_base< T > const &  vec,
scalar< T > &  result 
)

Computes the supremum-norm of a vector.

Parameters:
vecThe vector
resultThe result scalar
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:
vecThe vector
partial_resultThe result scalar
norm_idNorm selector. 0: norm_inf, 1: norm_1, 2: norm_2
void viennacl::linalg::opencl::plane_rotation ( vector_base< T > &  vec1,
vector_base< T > &  vec2,
alpha,
beta 
)

Computes a plane rotation of two vectors.

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

Parameters:
vec1The first vector
vec2The second vector
alphaThe first transformation coefficient
betaThe second transformation coefficient
void viennacl::linalg::opencl::prod_impl ( const viennacl::vandermonde_matrix< SCALARTYPE, ALIGNMENT > &  mat,
const viennacl::vector_base< SCALARTYPE > &  vec,
viennacl::vector_base< SCALARTYPE > &  result 
)

Carries out matrix-vector multiplication with a vandermonde_matrix.

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

Parameters:
matThe matrix
vecThe vector
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::compressed_matrix< TYPE, ALIGNMENT > &  mat,
const viennacl::vector_base< TYPE > &  vec,
viennacl::vector_base< TYPE > &  result 
)

Carries out matrix-vector multiplication with a compressed_matrix.

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

Parameters:
matThe matrix
vecThe vector
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::compressed_matrix< TYPE, ALIGNMENT > &  sp_mat,
const viennacl::matrix_base< TYPE, F1 > &  d_mat,
viennacl::matrix_base< TYPE, F2 > &  result 
)

Carries out sparse_matrix-matrix multiplication first matrix being compressed.

Implementation of the convenience expression result = prod(sp_mat, d_mat);

Parameters:
sp_matThe sparse matrix
d_matThe dense matrix
resultThe result matrix
void viennacl::linalg::opencl::prod_impl ( const viennacl::compressed_matrix< TYPE, ALIGNMENT > &  sp_mat,
const viennacl::matrix_expression< const viennacl::matrix_base< TYPE, F1 >, const viennacl::matrix_base< TYPE, F1 >, viennacl::op_trans > &  d_mat,
viennacl::matrix_base< TYPE, F2 > &  result 
)

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

Implementation of the convenience expression result = prod(sp_mat, d_mat);

Parameters:
sp_matThe sparse matrix
d_matThe transposed dense matrix
resultThe result matrix
void viennacl::linalg::opencl::prod_impl ( const viennacl::compressed_compressed_matrix< TYPE > &  mat,
const viennacl::vector_base< TYPE > &  vec,
viennacl::vector_base< TYPE > &  result 
)

Carries out matrix-vector multiplication with a compressed_compressed_matrix.

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

Parameters:
matThe matrix
vecThe vector
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::coordinate_matrix< SCALARTYPE, ALIGNMENT > &  mat,
const viennacl::vector_base< SCALARTYPE > &  vec,
viennacl::vector_base< SCALARTYPE > &  result 
)

Carries out matrix-vector multiplication with a coordinate_matrix.

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

Parameters:
matThe matrix
vecThe vector
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const matrix_base< NumericT, F > &  mat,
const vector_base< NumericT > &  vec,
vector_base< NumericT > &  result 
)

Carries out matrix-vector multiplication.

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

Parameters:
matThe matrix
vecThe vector
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::coordinate_matrix< NumericT, ALIGNMENT > &  mat,
const viennacl::matrix_base< NumericT, F1 > &  d_mat,
viennacl::matrix_base< NumericT, F2 > &  result 
)

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

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

Parameters:
matThe sparse matrix (COO format)
d_matThe dense matrix
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans > &  mat_trans,
const vector_base< NumericT > &  vec,
vector_base< NumericT > &  result 
)

Carries out matrix-vector multiplication with a transposed matrix.

Implementation of the convenience expression result = trans(mat) * vec;

Parameters:
mat_transThe transposed matrix proxy
vecThe vector
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::coordinate_matrix< NumericT, ALIGNMENT > &  mat,
const viennacl::matrix_expression< const viennacl::matrix_base< NumericT, F1 >, const viennacl::matrix_base< NumericT, F1 >, viennacl::op_trans > &  d_mat,
viennacl::matrix_base< NumericT, F2 > &  result 
)

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

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

Parameters:
matThe sparse matrix (COO format)
d_matThe dense matrix
resultThe result vector
void viennacl::linalg::opencl::prod_impl ( const viennacl::ell_matrix< TYPE, ALIGNMENT > &  mat,
const viennacl::vector_base< TYPE > &  vec,
viennacl::vector_base< TYPE > &  result 
)
void viennacl::linalg::opencl::prod_impl ( const viennacl::ell_matrix< ScalarType, ALIGNMENT > &  sp_mat,
const viennacl::matrix_base< NumericT, F1 > &  d_mat,
viennacl::matrix_base< NumericT, F2 > &  result 
)

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

Implementation of the convenience expression result = prod(sp_mat, d_mat); sp_mat being in ELL format

Parameters:
sp_matThe sparse matrix (ELL)
d_matThe dense matrix
resultThe result matrix
void viennacl::linalg::opencl::prod_impl ( const viennacl::ell_matrix< ScalarType, ALIGNMENT > &  sp_mat,
const viennacl::matrix_expression< const viennacl::matrix_base< NumericT, F1 >, const viennacl::matrix_base< NumericT, F1 >, viennacl::op_trans > &  d_mat,
viennacl::matrix_base< NumericT, F2 > &  result 
)

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

Implementation of the convenience expression result = prod(sp_mat, trans(d_mat)); sp_mat being in ELL format

Parameters:
sp_matThe sparse matrix (ELL)
d_matThe dense transposed matrix
resultThe result matrix
void viennacl::linalg::opencl::prod_impl ( const matrix_base< NumericT, F1 > &  A,
const matrix_base< NumericT, F2 > &  B,
matrix_base< NumericT, F3 > &  C,
ScalarType  alpha,
ScalarType  beta 
)

Carries out matrix-matrix multiplication.

Implementation of C = prod(A, B);

void viennacl::linalg::opencl::prod_impl ( const viennacl::hyb_matrix< TYPE, ALIGNMENT > &  mat,
const viennacl::vector_base< TYPE > &  vec,
viennacl::vector_base< TYPE > &  result 
)
void viennacl::linalg::opencl::prod_impl ( const viennacl::matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &  A,
const matrix_base< NumericT, F2 > &  B,
matrix_base< NumericT, F3 > &  C,
ScalarType  alpha,
ScalarType  beta 
)

Carries out matrix-matrix multiplication.

Implementation of C = prod(trans(A), B);

void viennacl::linalg::opencl::prod_impl ( const viennacl::hyb_matrix< NumericT, ALIGNMENT > &  mat,
const viennacl::matrix_base< NumericT, F1 > &  d_mat,
viennacl::matrix_base< NumericT, F2 > &  result 
)
void viennacl::linalg::opencl::prod_impl ( const matrix_base< NumericT, F1 > &  A,
const viennacl::matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans > &  B,
matrix_base< NumericT, F3 > &  C,
ScalarType  alpha,
ScalarType  beta 
)

Carries out matrix-matrix multiplication.

Implementation of C = prod(A, trans(B));

void viennacl::linalg::opencl::prod_impl ( const viennacl::hyb_matrix< NumericT, ALIGNMENT > &  mat,
const viennacl::matrix_expression< const viennacl::matrix_base< NumericT, F1 >, const viennacl::matrix_base< NumericT, F1 >, viennacl::op_trans > &  d_mat,
viennacl::matrix_base< NumericT, F2 > &  result 
)
void viennacl::linalg::opencl::prod_impl ( const viennacl::matrix_expression< const matrix_base< NumericT, F1 >, const matrix_base< NumericT, F1 >, op_trans > &  A,
const viennacl::matrix_expression< const matrix_base< NumericT, F2 >, const matrix_base< NumericT, F2 >, op_trans > &  B,
matrix_base< NumericT, F3 > &  C,
ScalarType  alpha,
ScalarType  beta 
)

Carries out matrix-matrix multiplication.

Implementation of C = prod(trans(A), trans(B));

void viennacl::linalg::opencl::scaled_rank_1_update ( matrix_base< NumericT, F > &  mat1,
S1 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:
mat1The matrix to be updated
alphaThe scaling factor (either a viennacl::scalar<>, float, or double)
len_alphaLength of the buffer for an eventual final reduction step (currently always '1')
reciprocal_alphaUse 1/alpha instead of alpha
flip_sign_alphaUse -alpha instead of alpha
vec1The first vector
vec2The second vector
viennacl::enable_if< viennacl::is_scalar<S1>::value && viennacl::is_scalar<S2>::value >::type viennacl::linalg::opencl::swap ( S1 &  s1,
S2 &  s2 
)

Swaps the contents of two scalars, data is copied.

Parameters:
s1The first scalar
s2The second scalar
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:
vec1The vector to which the value should be assigned
alphaThe value to be assigned
up_to_internal_sizeSpecifies whether alpha should also be written to padded memory (mostly used for clearing the whole buffer).
void viennacl::linalg::opencl::vector_swap ( vector_base< T > &  vec1,
vector_base< T > &  vec2 
)

Swaps the contents of two vectors, data is copied.

Parameters:
vec1The first vector (or -range, or -slice)
vec2The second vector (or -range, or -slice)