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

Provides all linear algebra operations which are not covered by operator overloads. More...

## Namespaces

| cuda
| Holds all CUDA compute kernels used by ViennaCL.
| detail
| Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user.
| host_based
| Holds all compute kernels with conventional host-based execution (buffers in CPU RAM).
| kernels
| Namespace containing the OpenCL kernels. Deprecated, will be moved to viennacl::linalg::opencl in future releases.
| opencl
| Holds all routines providing OpenCL linear algebra operations.

## Classes

class | amg_coarse_problem_too_large_exception
class | amg_precond
| AMG preconditioner class, can be supplied to solve()-routines. More...
class | amg_precond< compressed_matrix< NumericT, AlignmentV > >
| AMG preconditioner class, can be supplied to solve()-routines. More...
class | amg_tag
| A tag for algebraic multigrid (AMG). Used to transport information from the user to the implementation. More...
class | bicgstab_solver
class | bicgstab_tag
| A tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function. More...
class | block_ilu_precond
| A block ILU preconditioner class, can be supplied to solve()-routines. More...
class | block_ilu_precond< compressed_matrix< NumericT, AlignmentV >, ILUTagT >
| ILUT preconditioner class, can be supplied to solve()-routines. More...
class | cg_solver
class | cg_tag
| A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function. More...
class | chow_patel_icc_precond
| Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines. More...
class | chow_patel_icc_precond< viennacl::compressed_matrix< NumericT, AlignmentV > >
| Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines. More...
class | chow_patel_ilu_precond
| Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines. More...
class | chow_patel_ilu_precond< viennacl::compressed_matrix< NumericT, AlignmentV > >
| Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines. More...
class | chow_patel_tag
| A tag for incomplete LU and incomplete Cholesky factorization with static pattern (Parallel-ILU0, Parallel ICC0) More...
class | fspai_precond
| Implementation of the Factored SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type. More...
class | fspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >
| Implementation of the Factored SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix. More...
class | gmres_solver
class | gmres_tag
| A tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function. More...
class | ichol0_precond
| Incomplete Cholesky preconditioner class with static pattern (ICHOL0), can be supplied to solve()-routines. More...
class | ichol0_precond< compressed_matrix< NumericT, AlignmentV > >
| ILU0 preconditioner class, can be supplied to solve()-routines. More...
class | ichol0_tag
| A tag for incomplete Cholesky factorization with static pattern (ILU0) More...
class | ilu0_precond
| ILU0 preconditioner class, can be supplied to solve()-routines. More...
class | ilu0_precond< viennacl::compressed_matrix< NumericT, AlignmentV > >
| ILU0 preconditioner class, can be supplied to solve()-routines. More...
class | ilu0_tag
| A tag for incomplete LU factorization with static pattern (ILU0) More...
class | ilut_precond
| ILUT preconditioner class, can be supplied to solve()-routines. More...
class | ilut_precond< viennacl::compressed_matrix< NumericT, AlignmentV > >
| ILUT preconditioner class, can be supplied to solve()-routines. More...
class | ilut_tag
| A tag for incomplete LU factorization with threshold (ILUT) More...
class | jacobi_precond
| Jacobi preconditioner class, can be supplied to solve()-routines. Generic version for non-ViennaCL matrices. More...
class | jacobi_precond< MatrixT, true >
| Jacobi preconditioner class, can be supplied to solve()-routines. More...
class | jacobi_tag
| A tag for a jacobi preconditioner. More...
class | lanczos_tag
| A tag for the lanczos algorithm. More...
struct | lower_tag
| A tag class representing a lower triangular matrix. More...
class | mixed_precision_cg_tag
| A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function. More...
class | nmf_config
| Configuration class for the nonnegative-matrix-factorization algorithm. Specify tolerances, maximum iteration counts, etc., here. More...
class | no_precond
| A tag class representing the use of no preconditioner. More...
class | power_iter_tag
| A tag for the power iteration algorithm. More...
class | row_scaling
| Jacobi-type preconditioner class, can be supplied to solve()-routines. This is a diagonal preconditioner with the diagonal entries being (configurable) row norms of the matrix. More...
class | row_scaling< MatrixType, true >
| Jacobi preconditioner class, can be supplied to solve()-routines. More...
class | row_scaling_tag
| A tag for a row scaling preconditioner which merely normalizes the equation system such that each row of the system matrix has unit norm. More...
class | spai_precond
| Implementation of the SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type. More...
class | spai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >
| Implementation of the SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix. More...
struct | unit_lower_tag
| A tag class representing a lower triangular matrix with unit diagonal. More...
struct | unit_upper_tag
| A tag class representing an upper triangular matrix with unit diagonal. More...
struct | upper_tag
| A tag class representing an upper triangular matrix. More...

## Typedefs

typedef viennacl::linalg::detail::spai::spai_tag | spai_tag
typedef viennacl::linalg::detail::spai::fspai_tag | fspai_tag

## Enumerations

enum | amg_coarsening_method { AMG_COARSENING_METHOD_ONEPASS = 1, AMG_COARSENING_METHOD_AGGREGATION, AMG_COARSENING_METHOD_MIS2_AGGREGATION }
| Enumeration of coarsening methods for algebraic multigrid. More...
enum | amg_interpolation_method { AMG_INTERPOLATION_METHOD_DIRECT = 1, AMG_INTERPOLATION_METHOD_AGGREGATION, AMG_INTERPOLATION_METHOD_SMOOTHED_AGGREGATION }
| Enumeration of interpolation methods for algebraic multigrid. More...

## Functions

template<class SCALARTYPE , unsigned int ALIGNMENT>
void | convolve_i (viennacl::vector< SCALARTYPE, ALIGNMENT > &input1, viennacl::vector< SCALARTYPE, ALIGNMENT > &input2, viennacl::vector< SCALARTYPE, ALIGNMENT > &output)
template<typename T >
viennacl::vector_expression < const vector_base< T > , const vector_base< T > , op_element_binary< op_prod > > | element_prod (vector_base< T > const &v1, vector_base< T > const &v2)
template<typename T >
viennacl::vector_expression < const vector_base< T > , const vector_base< T > , op_element_binary< op_div > > | element_div (vector_base< T > const &v1, vector_base< T > const &v2)
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 - dispatcher interface. More...
template<typename LHS , typename RHS , typename OP , typename T >
void | inner_prod_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec1, vector_base< T > const &vec2, scalar< T > &result)
template<typename T , typename LHS , typename RHS , typename OP >
void | inner_prod_impl (vector_base< T > const &vec1, viennacl::vector_expression< LHS, RHS, OP > const &vec2, scalar< T > &result)
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 , typename T >
void | inner_prod_impl (viennacl::vector_expression< LHS1, RHS1, OP1 > const &vec1, viennacl::vector_expression< LHS2, RHS2, OP2 > const &vec2, scalar< T > &result)
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 with the final reduction step on the CPU - dispatcher interface. More...
template<typename LHS , typename RHS , typename OP , typename T >
void | inner_prod_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec1, vector_base< T > const &vec2, T &result)
template<typename T , typename LHS , typename RHS , typename OP >
void | inner_prod_cpu (vector_base< T > const &vec1, viennacl::vector_expression< LHS, RHS, OP > const &vec2, T &result)
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 , typename S3 >
void | inner_prod_cpu (viennacl::vector_expression< LHS1, RHS1, OP1 > const &vec1, viennacl::vector_expression< LHS2, RHS2, OP2 > const &vec2, S3 &result)
template<typename T >
void | norm_1_impl (vector_base< T > const &vec, scalar< T > &result)
| Computes the l^1-norm of a vector - dispatcher interface. More...
template<typename LHS , typename RHS , typename OP , typename T >
void | norm_1_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, scalar< T > &result)
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 the CPU. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | norm_1_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the l^1-norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | norm_2_impl (vector_base< T > const &vec, scalar< T > &result)
| Computes the l^2-norm of a vector - dispatcher interface. More...
template<typename LHS , typename RHS , typename OP , typename T >
void | norm_2_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, scalar< T > &result)
| Computes the l^2-norm of a vector - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | norm_2_cpu (vector_base< T > const &vec, T &result)
| Computes the l^2-norm of a vector with final reduction on the CPU - dispatcher interface. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | norm_2_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the l^2-norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. 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 LHS , typename RHS , typename OP , typename T >
void | norm_inf_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, scalar< T > &result)
| Computes the supremum norm of a vector - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | norm_inf_cpu (vector_base< T > const &vec, T &result)
| Computes the supremum-norm of a vector with final reduction on the CPU. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | norm_inf_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | max_impl (vector_base< T > const &vec, scalar< T > &result)
template<typename LHS , typename RHS , typename OP , typename T >
void | max_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, scalar< T > &result)
template<typename T >
void | max_cpu (vector_base< T > const &vec, T &result)
| Computes the maximum of a vector with final reduction on the CPU. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | max_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | min_impl (vector_base< T > const &vec, scalar< T > &result)
template<typename LHS , typename RHS , typename OP , typename T >
void | min_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, scalar< T > &result)
template<typename T >
void | min_cpu (vector_base< T > const &vec, T &result)
| Computes the minimum of a vector with final reduction on the CPU. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | min_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | sum_impl (vector_base< T > const &vec, scalar< T > &result)
template<typename LHS , typename RHS , typename OP , typename T >
void | sum_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, scalar< T > &result)
template<typename T >
void | sum_cpu (vector_base< T > const &vec, T &result)
| Computes the sum of a vector with final reduction on the CPU. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | sum_cpu (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the sum of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename T >
void | norm_frobenius_impl (matrix_base< T > const &A, scalar< T > &result)
| Computes the Frobenius norm of a matrix - dispatcher interface. More...
template<typename T >
void | norm_frobenius_cpu (matrix_base< T > const &A, T &result)
| Computes the Frobenius norm of a vector with final reduction on the CPU. More...
template<typename T >
vcl_size_t | 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 LHS , typename RHS , typename OP >
vcl_size_t | index_norm_inf (viennacl::vector_expression< LHS, RHS, OP > const &vec)
| Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename NumericT >
void | prod_impl (const matrix_base< NumericT > &mat, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
| Carries out matrix-vector multiplication. More...
template<typename NumericT >
void | prod_impl (const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &mat_trans, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
| Carries out matrix-vector multiplication with a transposed matrix. More...
template<typename SparseMatrixType , class SCALARTYPE , unsigned int ALIGNMENT>
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value, vector_expression< const SparseMatrixType, const vector < SCALARTYPE, ALIGNMENT > , op_prod > >::type | prod_impl (const SparseMatrixType &mat, const vector< SCALARTYPE, ALIGNMENT > &vec)
template<typename NumericT >
void | row_sum_impl (const matrix_base< NumericT > &A, vector_base< NumericT > &result)
template<typename NumericT >
void | column_sum_impl (const matrix_base< NumericT > &A, vector_base< NumericT > &result)
template<typename MatrixT , typename VectorT , typename PreconditionerT >
VectorT | solve (MatrixT const &matrix, VectorT const &rhs, bicgstab_tag const &tag, PreconditionerT const &precond)
template<typename IndexT , typename NumericT , typename PreconditionerT >
std::vector< NumericT > | solve (std::vector< std::map< IndexT, NumericT > > const &A, std::vector< NumericT > const &rhs, bicgstab_tag const &tag, PreconditionerT const &precond)
| Convenience overload for calling the preconditioned BiCGStab solver using types from the C++ STL. More...
template<typename MatrixT , typename VectorT >
VectorT | solve (MatrixT const &matrix, VectorT const &rhs, bicgstab_tag const &tag)
| Entry point for the unpreconditioned BiCGStab method. More...
template<typename VectorT >
std::vector< typename viennacl::result_of::cpu_value_type < typename VectorT::value_type > ::type > | bisect (VectorT const &alphas, VectorT const &betas)
| Implementation of the bisect-algorithm for the calculation of the eigenvalues of a tridiagonal matrix. Experimental - interface might change. More...
template<typename NumericT >
bool | bisect (const std::vector< NumericT > &diagonal, const std::vector< NumericT > &superdiagonal, std::vector< NumericT > &eigenvalues)
| bisect The bisection algorithm computes the eigevalues of a symmetric tridiagonal matrix. More...
template<typename NumericT >
bool | bisect (const viennacl::vector< NumericT > &diagonal, const viennacl::vector< NumericT > &superdiagonal, viennacl::vector< NumericT > &eigenvalues)
| bisect The bisection algorithm computes the eigevalues of a symmetric tridiagonal matrix. More...
template<typename MatrixT , typename VectorT , typename PreconditionerT >
VectorT | solve (MatrixT const &matrix, VectorT const &rhs, cg_tag const &tag, PreconditionerT const &precond)
| Implementation of the preconditioned conjugate gradient solver, generic implementation for non-ViennaCL types. More...
template<typename IndexT , typename NumericT , typename PreconditionerT >
std::vector< NumericT > | solve (std::vector< std::map< IndexT, NumericT > > const &A, std::vector< NumericT > const &rhs, cg_tag const &tag, PreconditionerT const &precond)
| Convenience overload for calling the CG solver using types from the C++ STL. More...
template<typename MatrixT , typename VectorT >
VectorT | solve (MatrixT const &matrix, VectorT const &rhs, cg_tag const &tag)
| Entry point for the unpreconditioned CG method. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::circulant_matrix< NumericT, AlignmentV > const &mat, viennacl::vector_base< NumericT > const &vec, viennacl::vector_base< NumericT > &result)
| Carries out matrix-vector multiplication with a circulant_matrix. More...
template<typename NumericT >
void | precondition (viennacl::compressed_matrix< NumericT > &A, ilu0_tag const &)
| Implementation of a ILU-preconditioner with static pattern. Optimized version for CSR matrices. More...
template<typename NumericT >
void | precondition (viennacl::compressed_matrix< NumericT > const &A, viennacl::compressed_matrix< NumericT > &L, viennacl::compressed_matrix< NumericT > &U, ilut_tag const &tag)
| Implementation of a ILU-preconditioner with threshold. Optimized implementation for compressed_matrix. More...
template<typename NumericT , typename SolverTagT >
void | inplace_solve (const matrix_base< NumericT > &A, matrix_base< NumericT > &B, SolverTagT)
| Direct inplace solver for triangular systems with multiple right hand sides, i.e. A \ B (MATLAB notation) More...
template<typename NumericT , typename SolverTagT >
void | inplace_solve (const matrix_base< NumericT > &A, matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > proxy_B, SolverTagT)
| Direct inplace solver for triangular systems with multiple transposed right hand sides, i.e. A \ B^T (MATLAB notation) More...
template<typename NumericT , typename SolverTagT >
void | inplace_solve (const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &proxy_A, matrix_base< NumericT > &B, SolverTagT)
| Direct inplace solver for transposed triangular systems with multiple right hand sides, i.e. A^T \ B (MATLAB notation) More...
template<typename NumericT , typename SolverTagT >
void | inplace_solve (matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > const &proxy_A, matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > proxy_B, SolverTagT)
| Direct inplace solver for transposed triangular systems with multiple transposed right hand sides, i.e. A^T \ B^T (MATLAB notation) More...
template<typename NumericT , typename SolverTagT >
matrix_base< NumericT > | solve (const matrix_base< NumericT > &A, const matrix_base< NumericT > &B, SolverTagT tag)
| Convenience functions for C = solve(A, B, some_tag()); Creates a temporary result matrix and forwards the request to inplace_solve() More...
template<typename NumericT , typename SolverTagT >
matrix_base< NumericT > | solve (const matrix_base< NumericT > &A, const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &proxy, SolverTagT tag)
| Convenience functions for C = solve(A, B^T, some_tag()); Creates a temporary result matrix and forwards the request to inplace_solve() More...
template<typename NumericT , typename SolverTagT >
matrix_base< NumericT > | solve (const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &proxy, const matrix_base< NumericT > &B, SolverTagT tag)
| Convenience functions for result = solve(trans(mat), B, some_tag()); Creates a temporary result matrix and forwards the request to inplace_solve() More...
template<typename NumericT , typename SolverTagT >
matrix_base< NumericT > | solve (const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &proxy_A, const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &proxy_B, SolverTagT tag)
| Convenience functions for result = solve(trans(mat), vec, some_tag()); Creates a temporary result vector and forwards the request to inplace_solve() More...
template<typename NumericT , typename SolverTagT >
void | inplace_solve (const matrix_base< NumericT > &mat, vector_base< NumericT > &vec, SolverTagT const &tag)
| Inplace solution of a triangular system. Matlab notation A \ b. More...
template<typename NumericT , typename SolverTagT >
void | inplace_solve (matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > const &proxy, vector_base< NumericT > &vec, SolverTagT const &tag)
| Inplace solution of a triangular system with transposed system matrix.. Matlab notation A' \ b. More...
template<typename NumericT >
vector< NumericT > | solve (const matrix_base< NumericT > &mat, const vector_base< NumericT > &vec, viennacl::linalg::upper_tag const &tag)
| Convenience function for result = solve(mat, vec, upper_tag()); for an upper triangular solve. More...
template<typename NumericT >
vector< NumericT > | solve (const matrix_base< NumericT > &mat, const vector_base< NumericT > &vec, viennacl::linalg::unit_upper_tag const &tag)
| Convenience function for result = solve(mat, vec, upper_tag()); for an upper triangular solve with unit diagonal. More...
template<typename NumericT >
vector< NumericT > | solve (const matrix_base< NumericT > &mat, const vector_base< NumericT > &vec, viennacl::linalg::lower_tag const &tag)
| Convenience function for result = solve(mat, vec, upper_tag()); for a lower triangular solve. More...
template<typename NumericT >
vector< NumericT > | solve (const matrix_base< NumericT > &mat, const vector_base< NumericT > &vec, viennacl::linalg::unit_lower_tag const &tag)
| Convenience function for result = solve(mat, vec, upper_tag()); for a lower triangular solve with unit diagonal. More...
template<typename NumericT , typename SolverTagT >
vector< NumericT > | solve (const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &proxy, const vector_base< NumericT > &vec, SolverTagT const &tag)
| Convenience functions for result = solve(trans(mat), vec, some_tag()); Creates a temporary result vector and forwards the request to inplace_solve() More...
template<typename NumericT , unsigned int AlignmentV>
void | direct (viennacl::vector< NumericT, AlignmentV > const &in, viennacl::vector< NumericT, AlignmentV > &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 1D algorithm for computing Fourier transformation. More...
template<typename NumericT , unsigned int AlignmentV>
void | direct (viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > const &in, viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > &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 2D algorithm for computing Fourier transformation. More...
template<typename NumericT , unsigned int AlignmentV>
void | reorder (viennacl::vector< NumericT, AlignmentV > &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 , unsigned int AlignmentV>
void | radix2 (viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > &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 1D algorithm for computing Fourier transformation. More...
template<typename NumericT , unsigned int AlignmentV>
void | radix2 (viennacl::vector< NumericT, AlignmentV > &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 2D 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 MatrixT , typename VectorT , typename PreconditionerT >
VectorT | solve (MatrixT const &matrix, VectorT const &rhs, gmres_tag const &tag, PreconditionerT const &precond)
template<typename IndexT , typename NumericT , typename PreconditionerT >
std::vector< NumericT > | solve (std::vector< std::map< IndexT, NumericT > > const &A, std::vector< NumericT > const &rhs, gmres_tag const &tag, PreconditionerT const &precond)
| Convenience overload for calling the preconditioned BiCGStab solver using types from the C++ STL. More...
template<typename MatrixT , typename VectorT >
VectorT | solve (MatrixT const &A, VectorT const &rhs, gmres_tag const &tag)
| Entry point for the unpreconditioned GMRES method. More...
template<typename NumericT , unsigned int AlignmentV>
void | prod_impl (viennacl::hankel_matrix< NumericT, AlignmentV > const &A, viennacl::vector_base< NumericT > const &vec, viennacl::vector_base< NumericT > &result)
| Carries out matrix-vector multiplication with a hankel_matrix. More...
template<typename NumericT >
void | precondition (viennacl::compressed_matrix< NumericT > &A, ichol0_tag const &)
| Implementation of a ILU-preconditioner with static pattern. Optimized version for CSR matrices. More...
template<typename NumericT >
void | extract_L (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &L)
| Extracts the lower triangular part L from A. More...
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 accordingly. More...
template<typename NumericT >
void | icc_chow_patel_sweep (compressed_matrix< NumericT > &L, vector< NumericT > &aij_L)
| Performs one nonlinear relaxation step in the Chow-Patel-ICC (cf. Algorithm 3 in paper, but for L rather than U) More...
template<typename NumericT >
void | extract_LU (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &L, compressed_matrix< NumericT > &U)
| Extracts the lower triangular part L and the upper triangular part U from A. More...
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_transpose (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > &B)
| Transposition B <- A^T, where the aij-vector is permuted in the same way as the value array in A when assigned to B. 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 (cf. Algorithm 2 in paper) More...
template<typename NumericT >
void | ilu_form_neumann_matrix (compressed_matrix< NumericT > &R, vector< NumericT > &diag_R)
| Extracts the lower triangular part L and the upper triangular part U from A. More...
template<typename VectorT1 , typename VectorT2 >
viennacl::enable_if < viennacl::is_stl< typename viennacl::traits::tag_of < VectorT1 >::type >::value, typename VectorT1::value_type > ::type | inner_prod (VectorT1 const &v1, VectorT2 const &v2)
template<typename NumericT >
viennacl::scalar_expression < const vector_base< NumericT > , const vector_base< NumericT > , viennacl::op_inner_prod > | inner_prod (vector_base< NumericT > const &vector1, vector_base< NumericT > const &vector2)
template<typename LHS , typename RHS , typename OP , typename NumericT >
viennacl::scalar_expression < const viennacl::vector_expression < LHS, RHS, OP >, const vector_base< NumericT > , viennacl::op_inner_prod > | inner_prod (viennacl::vector_expression< LHS, RHS, OP > const &vector1, vector_base< NumericT > const &vector2)
template<typename NumericT , typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const vector_base< NumericT > , const viennacl::vector_expression < LHS, RHS, OP > , viennacl::op_inner_prod > | inner_prod (vector_base< NumericT > const &vector1, viennacl::vector_expression< LHS, RHS, OP > const &vector2)
template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >
viennacl::scalar_expression < const viennacl::vector_expression < LHS1, RHS1, OP1 >, const viennacl::vector_expression < LHS2, RHS2, OP2 > , viennacl::op_inner_prod > | inner_prod (viennacl::vector_expression< LHS1, RHS1, OP1 > const &vector1, viennacl::vector_expression< LHS2, RHS2, OP2 > const &vector2)
template<typename NumericT >
viennacl::vector_expression < const vector_base< NumericT > , const vector_tuple< NumericT > , viennacl::op_inner_prod > | inner_prod (vector_base< NumericT > const &x, vector_tuple< NumericT > const &y_tuple)
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)
| Performs a joint vector update operation needed for an efficient pipelined CG algorithm. More...
template<typename MatrixT , typename NumericT >
void | pipelined_cg_prod (MatrixT const &A, vector_base< NumericT > const &p, vector_base< NumericT > &Ap, vector_base< NumericT > &inner_prod_buffer)
| Performs a joint vector update operation needed for an efficient pipelined CG algorithm. More...
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)
| Performs a joint vector update operation needed for an efficient pipelined CG algorithm. More...
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)
| Performs a joint vector update operation needed for an efficient pipelined BiCGStab algorithm. More...
template<typename MatrixT , typename NumericT >
void | pipelined_bicgstab_prod (MatrixT 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)
| Performs a joint vector update operation needed for an efficient pipelined CG algorithm. More...
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 k, vector_base< T > &vi_in_vk_buffer, vcl_size_t buffer_chunk_size)
| Computes the first reduction stage for multiple inner products <v_i, v_k>, i=0..k-1. More...
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 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)
| Computes the second reduction stage for multiple inner products <v_i, v_k>, i=0..k-1, then updates v_k -= <v_i, v_k> v_i and computes the first reduction stage for ||v_k||. More...
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 k)
| Computes x += eta_0 r + sum_{i=1}^{k-1} eta_i v_{i-1}. More...
template<typename MatrixType , typename T >
void | pipelined_gmres_prod (MatrixType const &A, vector_base< T > const &p, vector_base< T > &Ap, vector_base< T > &inner_prod_buffer)
| Performs a joint vector update operation needed for an efficient pipelined GMRES algorithm. More...
template<typename MatrixT , typename DenseMatrixT >
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type > | eig (MatrixT const &matrix, DenseMatrixT &eigenvectors_A, lanczos_tag const &tag, bool compute_eigenvectors=true)
| Implementation of the calculation of eigenvalues using lanczos (with and without reorthogonalization). More...
template<typename MatrixT >
std::vector< typename viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type > | eig (MatrixT const &matrix, lanczos_tag const &tag)
| Implementation of the calculation of eigenvalues using lanczos (with and without reorthogonalization). More...
template<typename NumericT >
void | lu_factorize (matrix< NumericT, viennacl::row_major > &A)
| LU factorization of a row-major dense matrix. More...
template<typename NumericT >
void | lu_factorize (matrix< NumericT, viennacl::column_major > &A)
| LU factorization of a column-major dense matrix. More...
template<typename NumericT , typename F1 , typename F2 , unsigned int AlignmentV1, unsigned int AlignmentV2>
void | lu_substitute (matrix< NumericT, F1, AlignmentV1 > const &A, matrix< NumericT, F2, AlignmentV2 > &B)
| LU substitution for the system LU = rhs. More...
template<typename NumericT , typename F , unsigned int MatAlignmentV, unsigned int VecAlignmentV>
void | lu_substitute (matrix< NumericT, F, MatAlignmentV > const &A, vector< NumericT, VecAlignmentV > &vec)
| LU substitution for the system LU = rhs. More...
template<typename DestNumericT , typename SrcNumericT >
void | convert (matrix_base< DestNumericT > &dest, matrix_base< SrcNumericT > const &src)
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 , typename ScalarType1 >
void | am (matrix_base< NumericT > &mat1, matrix_base< NumericT > const &mat2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
template<typename NumericT , typename ScalarType1 , typename ScalarType2 >
void | ambm (matrix_base< NumericT > &mat1, matrix_base< NumericT > const &mat2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, matrix_base< NumericT > const &mat3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
template<typename NumericT , typename ScalarType1 , typename ScalarType2 >
void | ambm_m (matrix_base< NumericT > &mat1, matrix_base< NumericT > const &mat2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, matrix_base< NumericT > const &mat3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
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 > &v, int k, matrix_base< NumericT > &A)
| Dispatcher interface for A = diag(v, k) More...
template<typename NumericT >
void | matrix_diag_to_vector (const matrix_base< NumericT > &A, int k, vector_base< NumericT > &v)
| Dispatcher interface for v = diag(A, k) More...
template<typename NumericT >
void | matrix_row (const matrix_base< NumericT > &A, unsigned int i, vector_base< NumericT > &v)
template<typename NumericT >
void | matrix_column (const matrix_base< NumericT > &A, unsigned int j, vector_base< NumericT > &v)
template<typename NumericT , typename ScalarType >
void | prod_impl (const matrix_base< NumericT > &A, const matrix_base< NumericT > &B, matrix_base< NumericT > &C, ScalarType alpha, ScalarType beta)
| Carries out matrix-matrix multiplication. More...
template<typename NumericT , typename ScalarType >
void | prod_impl (const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &A, const matrix_base< NumericT > &B, matrix_base< NumericT > &C, ScalarType alpha, ScalarType beta)
| Carries out matrix-matrix multiplication. More...
template<typename NumericT , typename ScalarType >
void | prod_impl (const matrix_base< NumericT > &A, const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &B, matrix_base< NumericT > &C, ScalarType alpha, ScalarType beta)
| Carries out matrix-matrix multiplication. More...
template<typename NumericT , typename ScalarType >
void | prod_impl (const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &A, const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > &B, matrix_base< NumericT > &C, ScalarType alpha, ScalarType beta)
| Carries out matrix-matrix multiplication. More...
template<typename T , typename OP >
void | element_op (matrix_base< T > &A, matrix_expression< const matrix_base< T >, const matrix_base< T >, OP > const &proxy)
| Implementation of the element-wise operation A = B .* C and A = B ./ C for matrices (using MATLAB syntax). Don't use this function directly, use element_prod() and element_div(). More...
template<typename NumericT >
viennacl::matrix_expression < const vector_base< NumericT > , const vector_base< NumericT > , op_prod > | outer_prod (const vector_base< NumericT > &vec1, const vector_base< NumericT > &vec2)
| Returns a proxy class for the operation mat += vec1 * vec2^T, i.e. a rank 1 update. More...
template<typename NumericT , typename S1 >
void | scaled_rank_1_update (matrix_base< NumericT > &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. More...
template<typename NumericT , typename VectorType >
void | bidiag_pack (matrix_base< NumericT > &A, VectorType &dh, VectorType &sh)
| This function stores the diagonal and the superdiagonal of a matrix in two vectors. More...
template<typename SCALARTYPE >
void | copy_vec (matrix_base< SCALARTYPE > &A, vector_base< SCALARTYPE > &V, vcl_size_t row_start, vcl_size_t col_start, bool copy_col)
| This function copies a row or a column from a matrix to a vector. More...
template<typename NumericT >
void | house_update_A_left (matrix_base< NumericT > &A, vector_base< NumericT > &D, vcl_size_t start)
| This function applies a householder transformation to a matrix. A <- P * A with a householder reflection P. More...
template<typename NumericT >
void | house_update_A_right (matrix_base< NumericT > &A, vector_base< NumericT > &D)
| This function applies a householder transformation to a matrix: A <- A * P with a householder reflection P. More...
template<typename NumericT >
void | house_update_QL (matrix_base< NumericT > &Q, vector_base< NumericT > &D, vcl_size_t A_size1)
| This function updates the matrix Q, which is needed for the computation of the eigenvectors. More...
template<typename NumericT >
void | givens_next (matrix_base< NumericT > &Q, vector_base< NumericT > &tmp1, vector_base< NumericT > &tmp2, int l, int m)
| This function updates the matrix Q. It is part of the tql2 algorithm. More...
template<typename NumericT >
NumericT | max (std::vector< NumericT > const &v1)
template<typename ScalarType >
viennacl::scalar_expression < const viennacl::vector_base < ScalarType >, const viennacl::vector_base < ScalarType > , viennacl::op_max > | max (viennacl::vector_base< ScalarType > const &v1)
template<typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const viennacl::vector_expression < const LHS, const RHS, OP > , const viennacl::vector_expression < const LHS, const RHS, OP > , viennacl::op_max > | max (viennacl::vector_expression< const LHS, const RHS, OP > const &vector)
template<typename NumericT >
NumericT | min (std::vector< NumericT > const &v1)
template<typename ScalarType >
viennacl::scalar_expression < const viennacl::vector_base < ScalarType >, const viennacl::vector_base < ScalarType > , viennacl::op_min > | min (viennacl::vector_base< ScalarType > const &v1)
template<typename ScalarType >
viennacl::scalar_expression < const viennacl::vector_base < ScalarType >, const viennacl::vector_base < ScalarType > , viennacl::op_min > | min (viennacl::vector< ScalarType > const &v1)
template<typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const viennacl::vector_expression < const LHS, const RHS, OP > , const viennacl::vector_expression < const LHS, const RHS, OP > , viennacl::op_min > | min (viennacl::vector_expression< const LHS, const RHS, OP > const &vector)
template<typename MatrixType , typename VectorType >
VectorType | solve (const MatrixType &matrix, VectorType const &rhs, mixed_precision_cg_tag const &tag)
| Implementation of the conjugate gradient solver without preconditioner. More...
template<typename MatrixType , typename VectorType >
VectorType | solve (const MatrixType &matrix, VectorType const &rhs, mixed_precision_cg_tag const &tag, viennacl::linalg::no_precond)
template<typename ScalarType >
void | nmf (viennacl::matrix_base< ScalarType > const &V, viennacl::matrix_base< ScalarType > &W, viennacl::matrix_base< ScalarType > &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 T , typename A >
T | norm_1 (std::vector< T, A > const &v1)
template<typename ScalarType >
viennacl::scalar_expression < const viennacl::vector_base < ScalarType >, const viennacl::vector_base < ScalarType > , viennacl::op_norm_1 > | norm_1 (viennacl::vector_base< ScalarType > const &vector)
template<typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const viennacl::vector_expression < const LHS, const RHS, OP > , const viennacl::vector_expression < const LHS, const RHS, OP > , viennacl::op_norm_1 > | norm_1 (viennacl::vector_expression< const LHS, const RHS, OP > const &vector)
template<typename T , typename A >
T | norm_2 (std::vector< T, A > const &v1)
template<typename ScalarType >
viennacl::scalar_expression < const viennacl::vector_base < ScalarType >, const viennacl::vector_base < ScalarType > , viennacl::op_norm_2 > | norm_2 (viennacl::vector_base< ScalarType > const &v)
template<typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const viennacl::vector_expression < const LHS, const RHS, OP > , const viennacl::vector_expression < const LHS, const RHS, OP > , viennacl::op_norm_2 > | norm_2 (viennacl::vector_expression< const LHS, const RHS, OP > const &vector)
template<typename NumericT >
scalar_expression< const matrix_base< NumericT >, const matrix_base< NumericT > , op_norm_frobenius > | norm_frobenius (const matrix_base< NumericT > &A)
template<typename T , typename A >
T | norm_inf (std::vector< T, A > const &v1)
template<typename ScalarType >
viennacl::scalar_expression < const viennacl::vector_base < ScalarType >, const viennacl::vector_base < ScalarType > , viennacl::op_norm_inf > | norm_inf (viennacl::vector_base< ScalarType > const &v1)
template<typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const viennacl::vector_expression < const LHS, const RHS, OP > , const viennacl::vector_expression < const LHS, const RHS, OP > , viennacl::op_norm_inf > | norm_inf (viennacl::vector_expression< const LHS, const RHS, OP > const &vector)
template<typename MatrixT , typename VectorT >
viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type | eig (MatrixT const &A, power_iter_tag const &tag, VectorT &eigenvec)
| Implementation of the calculation of the largest eigenvalue (in modulus) and the associated eigenvector using power iteration. More...
template<typename MatrixT >
viennacl::result_of::cpu_value_type < typename MatrixT::value_type > ::type | eig (MatrixT const &A, power_iter_tag const &tag)
| Implementation of the calculation of eigenvalues using power iteration. Does not return the eigenvector. More...
template<typename T , typename A1 , typename A2 , typename VectorT >
VectorT | prod (std::vector< std::vector< T, A1 >, A2 > const &matrix, VectorT const &vector)
template<typename KEY , typename DATA , typename COMPARE , typename AMAP , typename AVEC , typename VectorT >
VectorT | prod (std::vector< std::map< KEY, DATA, COMPARE, AMAP >, AVEC > const &matrix, VectorT const &vector)
template<typename NumericT >
viennacl::matrix_expression < const viennacl::matrix_base < NumericT >, const viennacl::matrix_base < NumericT > , viennacl::op_mat_mat_prod > | prod (viennacl::matrix_base< NumericT > const &A, viennacl::matrix_base< NumericT > const &B)
template<typename NumericT , typename LhsT , typename RhsT , typename OpT >
viennacl::matrix_expression < const viennacl::matrix_base < NumericT >, const viennacl::matrix_expression < const LhsT, const RhsT, OpT > , viennacl::op_mat_mat_prod > | prod (viennacl::matrix_base< NumericT > const &A, viennacl::matrix_expression< const LhsT, const RhsT, OpT > const &B)
template<typename LhsT , typename RhsT , typename OpT , typename NumericT >
viennacl::matrix_expression < const viennacl::matrix_expression < const LhsT, const RhsT, OpT > , const viennacl::matrix_base < NumericT > , viennacl::op_mat_mat_prod > | prod (viennacl::matrix_expression< const LhsT, const RhsT, OpT > const &A, viennacl::matrix_base< NumericT > const &B)
template<typename LhsT1 , typename RhsT1 , typename OpT1 , typename LhsT2 , typename RhsT2 , typename OpT2 >
viennacl::matrix_expression < const viennacl::matrix_expression < const LhsT1, const RhsT1, OpT1 >, const viennacl::matrix_expression < const LhsT2, const RhsT2, OpT2 > , viennacl::op_mat_mat_prod > | prod (viennacl::matrix_expression< const LhsT1, const RhsT1, OpT1 > const &A, viennacl::matrix_expression< const LhsT2, const RhsT2, OpT2 > const &B)
template<typename NumericT >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::vector_base < NumericT > , viennacl::op_prod > | prod (viennacl::matrix_base< NumericT > const &A, viennacl::vector_base< NumericT > const &x)
template<typename NumericT , typename F >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::vector_base < NumericT > , viennacl::op_prod > | prod (viennacl::matrix< NumericT, F > const &A, viennacl::vector_base< NumericT > const &x)
template<typename MatrixT , typename NumericT >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::vector_base < NumericT > , viennacl::op_prod > | prod (viennacl::matrix_range< MatrixT > const &A, viennacl::vector_base< NumericT > const &x)
template<typename MatrixT , typename NumericT >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::vector_base < NumericT > , viennacl::op_prod > | prod (viennacl::matrix_slice< MatrixT > const &A, viennacl::vector_base< NumericT > const &x)
template<typename NumericT , typename LhsT , typename RhsT , typename OpT >
viennacl::vector_expression < const viennacl::matrix_expression < const LhsT, const RhsT, OpT > , const viennacl::vector_base < NumericT > , viennacl::op_prod > | prod (viennacl::matrix_expression< const LhsT, const RhsT, OpT > const &A, viennacl::vector_base< NumericT > const &x)
template<typename NumericT , typename LhsT , typename RhsT , typename OpT >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::vector_expression < const LhsT, const RhsT, OpT > , viennacl::op_prod > | prod (viennacl::matrix_base< NumericT > const &A, viennacl::vector_expression< const LhsT, const RhsT, OpT > const &x)
template<typename LhsT1 , typename RhsT1 , typename OpT1 , typename LhsT2 , typename RhsT2 , typename OpT2 >
viennacl::vector_expression < const viennacl::matrix_expression < const LhsT1, const RhsT1, OpT1 >, const viennacl::vector_expression < const LhsT2, const RhsT2, OpT2 >, viennacl::op_prod > | prod (viennacl::matrix_expression< const LhsT1, const RhsT1, OpT1 > const &A, viennacl::vector_expression< const LhsT2, const RhsT2, OpT2 > const &x)
template<typename SparseMatrixType , typename SCALARTYPE >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value, viennacl::matrix_expression < const SparseMatrixType, const matrix_base< SCALARTYPE > , op_prod > >::type | prod (const SparseMatrixType &sp_mat, const viennacl::matrix_base< SCALARTYPE > &d_mat)
template<typename SparseMatrixType , typename SCALARTYPE >

viennacl::enable_if
< viennacl::is_any_sparse_matrix
< SparseMatrixType >::value,
viennacl::matrix_expression
< const SparseMatrixType,
const
viennacl::matrix_expression
< const viennacl::matrix_base
< SCALARTYPE >, const
viennacl::matrix_base
< SCALARTYPE >, op_trans >
, viennacl::op_prod > >::type

prod (const SparseMatrixType &A, viennacl::matrix_expression< const viennacl::matrix_base< SCALARTYPE >, const viennacl::matrix_base< SCALARTYPE >, op_trans > const &B)

template<typename NumericT >
viennacl::matrix_expression < const compressed_matrix < NumericT >, const compressed_matrix< NumericT > , op_prod > | prod (compressed_matrix< NumericT > const &A, compressed_matrix< NumericT > const &B)
| Sparse matrix-matrix product with compressed_matrix objects. More...
template<typename SparseMatrixType , typename NumericT >
vector_expression< const SparseMatrixType, const vector_base< NumericT > , op_prod > | prod (const SparseMatrixType &A, const vector_base< NumericT > &x)
| Generic matrix-vector product with user-provided sparse matrix type. More...
template<typename SCALARTYPE >
void | qr_method_nsm (viennacl::matrix< SCALARTYPE > &A, viennacl::matrix< SCALARTYPE > &Q, std::vector< SCALARTYPE > &D, std::vector< SCALARTYPE > &E)
template<typename SCALARTYPE >
void | qr_method_sym (viennacl::matrix< SCALARTYPE > &A, viennacl::matrix< SCALARTYPE > &Q, std::vector< SCALARTYPE > &D)
template<typename SCALARTYPE >
void | qr_method_sym (viennacl::matrix< SCALARTYPE > &A, viennacl::matrix< SCALARTYPE > &Q, viennacl::vector_base< SCALARTYPE > &D)
template<typename MatrixType , typename VectorType >
void | recoverQ (MatrixType const &A, VectorType const &betas, MatrixType &Q, MatrixType &R)
template<typename MatrixType , typename VectorType1 , typename VectorType2 >
void | inplace_qr_apply_trans_Q (MatrixType const &A, VectorType1 const &betas, VectorType2 &b)
| Computes Q^T b, where Q is an implicit orthogonal matrix defined via its Householder reflectors stored in A. More...
template<typename T , typename F , unsigned int ALIGNMENT, typename VectorType1 , unsigned int A2>
void | inplace_qr_apply_trans_Q (viennacl::matrix< T, F, ALIGNMENT > const &A, VectorType1 const &betas, viennacl::vector< T, A2 > &b)
template<typename T , typename F , unsigned int ALIGNMENT>
std::vector< T > | inplace_qr (viennacl::matrix< T, F, ALIGNMENT > &A, vcl_size_t block_size=16)
| Overload of inplace-QR factorization of a ViennaCL matrix A. More...
template<typename MatrixType >
std::vector< typename MatrixType::value_type > | inplace_qr (MatrixType &A, vcl_size_t block_size=16)
| Overload of inplace-QR factorization for a general Boost.uBLAS compatible matrix A. More...
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)
| Interface for the generic operation s1 = s2 @ alpha, where s1 and s2 are GPU scalars, @ denotes multiplication or division, and alpha is either a GPU or a CPU scalar. More...
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)

| Interface for the generic operation s1 = s2 @ alpha + s3 @ beta, where s1, s2 and s3 are GPU scalars, @ denotes multiplication or division, and alpha, beta are either a GPU or a CPU scalar. More...
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)

| Interface for the generic operation s1 += s2 @ alpha + s3 @ beta, where s1, s2 and s3 are GPU scalars, @ denotes multiplication or division, and alpha, beta are either a GPU or a CPU scalar. More...
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. More...
template<typename SparseMatrixType , class ScalarType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | prod_impl (const SparseMatrixType &mat, const viennacl::vector_base< ScalarType > &vec, ScalarType alpha, viennacl::vector_base< ScalarType > &result, ScalarType beta)
| Carries out matrix-vector multiplication involving a sparse matrix type. More...
template<typename SparseMatrixType , class ScalarType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | prod_impl (const SparseMatrixType &sp_mat, const viennacl::matrix_base< ScalarType > &d_mat, viennacl::matrix_base< ScalarType > &result)
| Carries out matrix-matrix multiplication first matrix being sparse. More...
template<typename SparseMatrixType , class ScalarType >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | prod_impl (const SparseMatrixType &sp_mat, const viennacl::matrix_expression< const viennacl::matrix_base< ScalarType >, const viennacl::matrix_base< ScalarType >, viennacl::op_trans > &d_mat, viennacl::matrix_base< ScalarType > &result)
| Carries out matrix-matrix multiplication first matrix being sparse, and the second transposed. More...
template<typename NumericT >
void | prod_impl (const viennacl::compressed_matrix< NumericT > &A, const viennacl::compressed_matrix< NumericT > &B, viennacl::compressed_matrix< NumericT > &C)
| Carries out sparse_matrix-sparse_matrix multiplication for CSR matrices. More...
template<typename SparseMatrixType , class ScalarType , typename SOLVERTAG >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | inplace_solve (const SparseMatrixType &mat, viennacl::vector_base< ScalarType > &vec, SOLVERTAG tag)
| Carries out triangular inplace solves. More...
template<typename SparseMatrixType , class ScalarType , typename SOLVERTAG >
viennacl::enable_if < viennacl::is_any_sparse_matrix < SparseMatrixType >::value > ::type | inplace_solve (const matrix_expression< const SparseMatrixType, const SparseMatrixType, op_trans > &mat, viennacl::vector_base< ScalarType > &vec, SOLVERTAG tag)
| Carries out transposed triangular inplace solves. More...
template<typename NumericT >
viennacl::scalar_expression < const viennacl::vector_base < NumericT >, const viennacl::vector_base < NumericT >, viennacl::op_sum > | sum (viennacl::vector_base< NumericT > const &x)
| User interface function for computing the sum of all elements of a vector. More...
template<typename LHS , typename RHS , typename OP >
viennacl::scalar_expression < const viennacl::vector_expression < const LHS, const RHS, OP > , const viennacl::vector_expression < const LHS, const RHS, OP > , viennacl::op_sum > | sum (viennacl::vector_expression< const LHS, const RHS, OP > const &x)
| User interface function for computing the sum of all elements of a vector specified by a vector operation. More...
template<typename NumericT >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::matrix_base < NumericT > , viennacl::op_row_sum > | row_sum (viennacl::matrix_base< NumericT > const &A)
| User interface function for computing the sum of all elements of each row of a matrix. More...
template<typename LHS , typename RHS , typename OP >
viennacl::vector_expression < const viennacl::matrix_expression < const LHS, const RHS, OP > , const viennacl::matrix_expression < const LHS, const RHS, OP > , viennacl::op_row_sum > | row_sum (viennacl::matrix_expression< const LHS, const RHS, OP > const &A)
| User interface function for computing the sum of all elements of each row of a matrix specified by a matrix operation. More...
template<typename NumericT >
viennacl::vector_expression < const viennacl::matrix_base < NumericT >, const viennacl::matrix_base < NumericT > , viennacl::op_col_sum > | column_sum (viennacl::matrix_base< NumericT > const &A)
| User interface function for computing the sum of all elements of each column of a matrix. More...
template<typename LHS , typename RHS , typename OP >
viennacl::vector_expression < const viennacl::matrix_expression < const LHS, const RHS, OP > , const viennacl::matrix_expression < const LHS, const RHS, OP > , viennacl::op_col_sum > | column_sum (viennacl::matrix_expression< const LHS, const RHS, OP > const &A)
| User interface function for computing the sum of all elements of each column of a matrix specified by a matrix operation. More...
template<typename SCALARTYPE , unsigned int ALIGNMENT>
void | svd (viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &A, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &QL, viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > &QR)
| Computes the singular value decomposition of a matrix A. Experimental in 1.3.x. More...
template<class SCALARTYPE , unsigned int ALIGNMENT>
void | prod_impl (const viennacl::toeplitz_matrix< SCALARTYPE, ALIGNMENT > &mat, const viennacl::vector_base< SCALARTYPE > &vec, viennacl::vector_base< SCALARTYPE > &result)
| Carries out matrix-vector multiplication with a toeplitz_matrix. More...
template<typename SCALARTYPE , typename VectorType >
void | tql1 (vcl_size_t n, VectorType &d, VectorType &e)
template<typename SCALARTYPE , typename VectorType , typename F >
void | tql2 (matrix_base< SCALARTYPE, F > &Q, VectorType &d, VectorType &e)
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. 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 > const &proxy)
| Implementation of the element-wise operation v1 = v2 .* v3 and v1 = v2 ./ v3 (using MATLAB syntax) More...
template<typename T >
void | inner_prod_impl (vector_base< T > const &x, vector_tuple< T > const &y_tuple, vector_base< T > &result)
| Computes the inner products <x, y1>, <x, y2>, ..., <x, y_N> and writes the result to a (sub-)vector. More...
template<typename LHS , typename RHS , typename OP , typename S2 >
void | norm_1_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
| Computes the l^1-norm of a vector - interface for a vector expression. Creates a temporary. More...
template<typename NumericT >
void | max_impl (vector_base< NumericT > const &vec, viennacl::scalar< NumericT > &result)
| Computes the maximum of a vector with final reduction on the CPU. More...
template<typename LHS , typename RHS , typename OP , typename NumericT >
void | max_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, viennacl::scalar< NumericT > &result)
| Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename NumericT >
void | min_impl (vector_base< NumericT > const &vec, viennacl::scalar< NumericT > &result)
| Computes the minimum of a vector with final reduction on the CPU. More...
template<typename LHS , typename RHS , typename OP , typename NumericT >
void | min_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, viennacl::scalar< NumericT > &result)
| Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. More...
template<typename NumericT >
void | sum_impl (vector_base< NumericT > const &vec, viennacl::scalar< NumericT > &result)
| Computes the sum of a vector with final reduction on the device (GPU, etc.) More...
template<typename LHS , typename RHS , typename OP , typename NumericT >
void | sum_impl (viennacl::vector_expression< LHS, RHS, OP > const &vec, viennacl::scalar< NumericT > &result)
| Computes the sum of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary. 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 > &vec1, vector_base< NumericT > &vec2)
| This function implements an inclusive scan. More...
template<typename NumericT >
void | inclusive_scan (vector_base< NumericT > &vec)
| Implements an in-place inclusive scan of a vector. More...
template<typename NumericT >
void | exclusive_scan (vector_base< NumericT > &vec1, vector_base< NumericT > &vec2)
| This function implements an exclusive scan. More...
template<typename NumericT >
void | exclusive_scan (vector_base< NumericT > &vec)
| Inplace exclusive scan of a vector. More...

## Variables

const std::string | SVD_HOUSEHOLDER_UPDATE_QR_KERNEL = "house_update_QR"
const std::string | SVD_MATRIX_TRANSPOSE_KERNEL = "transpose_inplace"
const std::string | SVD_INVERSE_SIGNS_KERNEL = "inverse_signs"
const std::string | SVD_GIVENS_PREV_KERNEL = "givens_prev"
const std::string | SVD_FINAL_ITER_UPDATE_KERNEL = "final_iter_update"
const std::string | SVD_UPDATE_QR_COLUMN_KERNEL = "update_qr_column"
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"

## Detailed Description

Provides all linear algebra operations which are not covered by operator overloads.

## Typedef Documentation

typedef viennacl::linalg::detail::spai::fspai_tag viennacl::linalg::fspai_tag

Definition at line 67 of file spai.hpp.

typedef viennacl::linalg::detail::spai::spai_tag viennacl::linalg::spai_tag

Definition at line 66 of file spai.hpp.

## Enumeration Type Documentation

enum viennacl::linalg::amg_coarsening_method

Enumeration of coarsening methods for algebraic multigrid.

Enumerator
AMG_COARSENING_METHOD_ONEPASS |
AMG_COARSENING_METHOD_AGGREGATION |
AMG_COARSENING_METHOD_MIS2_AGGREGATION |

Definition at line 46 of file amg_base.hpp.

enum viennacl::linalg::amg_interpolation_method

Enumeration of interpolation methods for algebraic multigrid.

Enumerator
AMG_INTERPOLATION_METHOD_DIRECT |
AMG_INTERPOLATION_METHOD_AGGREGATION |
AMG_INTERPOLATION_METHOD_SMOOTHED_AGGREGATION |

Definition at line 54 of file amg_base.hpp.

## Function Documentation

template<typename NumericT , typename ScalarType1 >

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

Definition at line 111 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarType1 , typename ScalarType2 >

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

Definition at line 139 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarType1 , typename ScalarType2 >

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

Definition at line 174 of file matrix_operations.hpp.

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 viennacl::linalg::as | ( | S1 & | s1,
|  | S2 const & | s2,
|  | ScalarType1 const & | alpha,
|  | vcl_size_t | len_alpha,
|  | bool | reciprocal_alpha,
|  | bool | flip_sign_alpha
| ) |  |

Interface for the generic operation s1 = s2 @ alpha, where s1 and s2 are GPU scalars, @ denotes multiplication or division, and alpha is either a GPU or a CPU scalar.

Parameters

  s1 | The first (GPU) scalar
  s2 | The second (GPU) scalar
  alpha | The scalar alpha in the operation
  len_alpha | If alpha is obtained from summing over a small GPU vector (e.g. the final summation after a multi-group reduction), then supply the length of the array here
  reciprocal_alpha | If true, then s2 / alpha instead of s2 * alpha is computed
  flip_sign_alpha | If true, then (-alpha) is used instead of alpha

Definition at line 65 of file scalar_operations.hpp.

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 viennacl::linalg::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
| ) |  |

Interface for the generic operation s1 = s2 @ alpha + s3 @ beta, where s1, s2 and s3 are GPU scalars, @ denotes multiplication or division, and alpha, beta are either a GPU or a CPU scalar.

Parameters

  s1 | The first (GPU) scalar
  s2 | The second (GPU) scalar
  alpha | The scalar alpha in the operation
  len_alpha | If alpha is a small GPU vector, which needs to be summed in order to obtain the final scalar, then supply the length of the array here
  reciprocal_alpha | If true, then s2 / alpha instead of s2 * alpha is computed
  flip_sign_alpha | If true, then (-alpha) is used instead of alpha
  s3 | The third (GPU) scalar
  beta | The scalar beta in the operation
  len_beta | If beta is obtained from summing over a small GPU vector (e.g. the final summation after a multi-group reduction), then supply the length of the array here
  reciprocal_beta | If true, then s2 / beta instead of s2 * beta is computed
  flip_sign_beta | If true, then (-beta) is used instead of beta

Definition at line 114 of file scalar_operations.hpp.

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 viennacl::linalg::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
| ) |  |

Interface for the generic operation s1 += s2 @ alpha + s3 @ beta, where s1, s2 and s3 are GPU scalars, @ denotes multiplication or division, and alpha, beta are either a GPU or a CPU scalar.

Parameters

  s1 | The first (GPU) scalar
  s2 | The second (GPU) scalar
  alpha | The scalar alpha in the operation
  len_alpha | If alpha is a small GPU vector, which needs to be summed in order to obtain the final scalar, then supply the length of the array here
  reciprocal_alpha | If true, then s2 / alpha instead of s2 * alpha is computed
  flip_sign_alpha | If true, then (-alpha) is used instead of alpha
  s3 | The third (GPU) scalar
  beta | The scalar beta in the operation
  len_beta | If beta is obtained from summing over a small GPU vector (e.g. the final summation after a multi-group reduction), then supply the length of the array here
  reciprocal_beta | If true, then s2 / beta instead of s2 * beta is computed
  flip_sign_beta | If true, then (-beta) is used instead of beta

Definition at line 170 of file scalar_operations.hpp.

template<typename T , typename ScalarType1 >

void viennacl::linalg::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 78 of file vector_operations.hpp.

template<typename T , typename ScalarType1 , typename ScalarType2 >

void viennacl::linalg::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 107 of file vector_operations.hpp.

template<typename T , typename ScalarType1 , typename ScalarType2 >

void viennacl::linalg::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 144 of file vector_operations.hpp.

template<typename NumericT , typename VectorType >

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

This function stores the diagonal and the superdiagonal of a matrix in two vectors.

Parameters

  A | The matrix from which the vectors will be extracted of.
  dh | The vector in which the diagonal of the matrix will be stored in.
  sh | The vector in which the superdiagonal of the matrix will be stored in.

Definition at line 901 of file matrix_operations.hpp.

template<typename NumericT >

bool viennacl::linalg::bisect | ( | const std::vector< NumericT > & | diagonal,
|  | const std::vector< NumericT > & | superdiagonal,
|  | std::vector< NumericT > & | eigenvalues
| ) |  |

bisect The bisection algorithm computes the eigevalues of a symmetric tridiagonal matrix.

Parameters

  diagonal | diagonal elements of the matrix
  superdiagonal | superdiagonal elements of the matrix
  eigenvalues | Vectors with the eigenvalues in ascending order

Returns
  return false if any errors occured

overloaded function template: std::vectors as parameters

Definition at line 60 of file bisect_gpu.hpp.

template<typename VectorT >

std::vector< typename viennacl::result_of::cpu_value_type<typename VectorT::value_type>::type > viennacl::linalg::bisect | ( | VectorT const & | alphas,
|  | VectorT const & | betas
| ) |  |

Implementation of the bisect-algorithm for the calculation of the eigenvalues of a tridiagonal matrix. Experimental - interface might change.

Refer to "Calculation of the Eigenvalues of a Symmetric Tridiagonal Matrix by the Method of Bisection" in the Handbook Series Linear Algebra, contributed by Barth, Martin, and Wilkinson. http://www.maths.ed.ac.uk/~aar/papers/bamawi.pdf

Parameters

  alphas | Elements of the main diagonal
  betas | Elements of the secondary diagonal

Returns
  Returns the eigenvalues of the tridiagonal matrix defined by alpha and beta

Examples:
  bisect.cpp.

Definition at line 78 of file bisect.hpp.

template<typename NumericT >

bool viennacl::linalg::bisect | ( | const viennacl::vector< NumericT > & | diagonal,
|  | const viennacl::vector< NumericT > & | superdiagonal,
|  | viennacl::vector< NumericT > & | eigenvalues
| ) |  |

bisect The bisection algorithm computes the eigevalues of a symmetric tridiagonal matrix.

Parameters

  diagonal | diagonal elements of the matrix
  superdiagonal | superdiagonal elements of the matrix
  eigenvalues | Vectors with the eigenvalues in ascending order

Returns
  return false if any errors occured

overloaded function template: viennacl::vectors as parameters

Definition at line 122 of file bisect_gpu.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::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

Examples:
  fft.cpp.

Definition at line 235 of file fft_operations.hpp.

template<typename NumericT >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::matrix_base<NumericT>, viennacl::op_col_sum > viennacl::linalg::column_sum | ( | viennacl::matrix_base< NumericT > const & | A | ) |

User interface function for computing the sum of all elements of each column of a matrix.

Definition at line 109 of file sum.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::vector_expression<const viennacl::matrix_expression<const LHS, const RHS, OP>, const viennacl::matrix_expression<const LHS, const RHS, OP>, viennacl::op_col_sum> viennacl::linalg::column_sum | ( | viennacl::matrix_expression< const LHS, const RHS, OP > const & | A | ) |

User interface function for computing the sum of all elements of each column of a matrix specified by a matrix operation.

Typical use case: vector<double> my_sums = viennacl::linalg::column_sum(A + B);

Definition at line 124 of file sum.hpp.

template<typename NumericT >

void viennacl::linalg::column_sum_impl | ( | const matrix_base< NumericT > & | A,
|  | vector_base< NumericT > & | result
| ) |  |

Definition at line 686 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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)

Examples:
  fft.cpp.

Definition at line 421 of file fft_operations.hpp.

template<typename DestNumericT , typename SrcNumericT >

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

Definition at line 51 of file vector_operations.hpp.

template<typename DestNumericT , typename SrcNumericT >

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

Definition at line 54 of file matrix_operations.hpp.

template<class SCALARTYPE , unsigned int ALIGNMENT>

void viennacl::linalg::convolve_i | ( | viennacl::vector< SCALARTYPE, ALIGNMENT > & | input1,
|  | viennacl::vector< SCALARTYPE, ALIGNMENT > & | input2,
|  | viennacl::vector< SCALARTYPE, ALIGNMENT > & | output
| ) |  |

template<typename SCALARTYPE >

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

This function copies a row or a column from a matrix to a vector.

Parameters

  A | The matrix where to copy from.
  V | The vector to fill with data.
  row_start | The number of the first row to copy.
  col_start | The number of the first column to copy.
  copy_col | Set to TRUE to copy a column, FALSE to copy a row.

Definition at line 942 of file matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::direct | ( | viennacl::vector< NumericT, AlignmentV > const & | in,
|  | viennacl::vector< NumericT, AlignmentV > & | 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 1D algorithm for computing Fourier transformation.

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

Definition at line 51 of file fft_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::direct | ( | viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > const & | in,
|  | viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > & | 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 2D algorithm for computing Fourier transformation.

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

Definition at line 89 of file fft_operations.hpp.

template<typename MatrixT , typename VectorT >

viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type viennacl::linalg::eig | ( | MatrixT const & | A,
|  | power_iter_tag const & | tag,
|  | VectorT & | eigenvec
| ) |  |

Implementation of the calculation of the largest eigenvalue (in modulus) and the associated eigenvector using power iteration.

Parameters

  A | The system matrix
  tag | Tag with termination factor
  eigenvec | Vector which holds the associated eigenvector once the routine completes

Returns
  Returns the largest eigenvalue computed by the power iteration method

Definition at line 74 of file power_iter.hpp.

template<typename MatrixT >

viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type viennacl::linalg::eig | ( | MatrixT const & | A,
|  | power_iter_tag const & | tag
| ) |  |

Implementation of the calculation of eigenvalues using power iteration. Does not return the eigenvector.

Parameters

  A | The system matrix
  tag | Tag with termination factor

Returns
  Returns the largest eigenvalue computed by the power iteration method

Definition at line 119 of file power_iter.hpp.

template<typename MatrixT , typename DenseMatrixT >

std::vector< typename viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type > viennacl::linalg::eig | ( | MatrixT const & | matrix,
|  | DenseMatrixT & | eigenvectors_A,
|  | lanczos_tag const & | tag,
|  | bool | compute_eigenvectors = `true`
| ) |  |

Implementation of the calculation of eigenvalues using lanczos (with and without reorthogonalization).

Implementation of Lanczos with partial reorthogonalization is implemented separately.

Parameters

  matrix | The system matrix
  eigenvectors_A | A dense matrix in which the eigenvectors of A will be stored. Both row- and column-major matrices are supported.
  tag | Tag with several options for the lanczos algorithm
  compute_eigenvectors | Boolean flag. If true, eigenvectors are computed. Otherwise the routine returns after calculating eigenvalues.

Returns
  Returns the n largest eigenvalues (n defined in the lanczos_tag)

Examples:
  lanczos.cpp, and power-iter.cpp.

Definition at line 452 of file lanczos.hpp.

template<typename MatrixT >

std::vector< typename viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type > viennacl::linalg::eig | ( | MatrixT const & | matrix,
|  | lanczos_tag const & | tag
| ) |  |

Implementation of the calculation of eigenvalues using lanczos (with and without reorthogonalization).

Implementation of Lanczos with partial reorthogonalization is implemented separately.

Parameters

  matrix | The system matrix
  tag | Tag with several options for the lanczos algorithm

Returns
  Returns the n largest eigenvalues (n defined in the lanczos_tag)

Definition at line 505 of file lanczos.hpp.

template<typename T >

viennacl::vector_expression<const vector_base<T>, const vector_base<T>, op_element_binary<op_div> > viennacl::linalg::element_div | ( | vector_base< T > const & | v1,
|  | vector_base< T > const & | v2
| ) |  |

template<typename T , typename OP >

void viennacl::linalg::element_op | ( | vector_base< T > & | vec1,
|  | vector_expression< const vector_base< T >, const vector_base< T >, 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 255 of file vector_operations.hpp.

template<typename T , typename OP >

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

Implementation of the element-wise operation A = B .* C and A = B ./ C for matrices (using MATLAB syntax). Don't use this function directly, use element_prod() and element_div().

Parameters

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

Definition at line 702 of file matrix_operations.hpp.

template<typename T >

viennacl::vector_expression<const vector_base<T>, const vector_base<T>, op_element_binary<op_prod> > viennacl::linalg::element_prod | ( | vector_base< T > const & | v1,
|  | vector_base< T > const & | v2
| ) |  |

template<typename NumericT >

void viennacl::linalg::exclusive_scan | ( | vector_base< NumericT > & | vec1,
|  | vector_base< NumericT > & | vec2
| ) |  |

This function implements an exclusive scan.

Given an element vector (x_0, x_1, ..., x_{n-1}), this routine computes (0, x_0, x_0 + x_1, ..., x_0 + x_1 + ... + x_{n-2})

The two vectors either need to be the same (in-place), or reside in distinct memory regions. Partial overlaps of vec1 and vec2 are not allowed.

Parameters

  vec1 | Input vector.
  vec2 | The output vector.

Definition at line 1240 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::exclusive_scan | ( | vector_base< NumericT > & | vec | ) |

Inplace exclusive scan of a vector.

Given an element vector (x_0, x_1, ..., x_{n-1}), this routine overwrites the input vector with (0, x_0, x_0 + x_1, ..., x_0 + x_1 + ... + x_{n-2})

Definition at line 1273 of file vector_operations.hpp.

template<typename NumericT >

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

Extracts the lower triangular part L from A.

Diagonal of L is stored explicitly in order to enable better code reuse.

Definition at line 56 of file ilu_operations.hpp.

template<typename NumericT >

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

Extracts the lower triangular part L and the upper triangular part U from A.

Diagonals of L and U are stored explicitly in order to enable better code reuse.

Definition at line 156 of file ilu_operations.hpp.

template<typename NumericT >

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

This function updates the matrix Q. It is part of the tql2 algorithm.

Parameters

  Q | The matrix to be updated.
  tmp1 | Vector with data from the tql2 algorithm.
  tmp2 | Vector with data from the tql2 algorithm.
  l | Data from the tql2 algorithm.
  m | Data from the tql2 algorithm.

Definition at line 1092 of file matrix_operations.hpp.

template<typename NumericT >

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

This function applies a householder transformation to a matrix. A <- P * A with a householder reflection P.

Parameters

  A | The matrix to be updated.
  D | The normalized householder vector.
  start | The repetition counter.

Definition at line 981 of file matrix_operations.hpp.

template<typename NumericT >

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

This function applies a householder transformation to a matrix: A <- A * P with a householder reflection P.

Parameters

  A | The matrix to be updated.
  D | The normalized householder vector.

Definition at line 1018 of file matrix_operations.hpp.

template<typename NumericT >

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

This function updates the matrix Q, which is needed for the computation of the eigenvectors.

Parameters

  Q | The matrix to be updated.
  D | The householder vector.
  A_size1 | size1 of matrix A

Definition at line 1053 of file matrix_operations.hpp.

template<typename NumericT >

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

Performs one nonlinear relaxation step in the Chow-Patel-ICC (cf. Algorithm 3 in paper, but for L rather than U)

We use a fully synchronous (Jacobi-like) variant, because asynchronous methods as described in the paper are a nightmare to debug (and particularly funny if they sometimes fail, sometimes not)

Parameters

  L | Factor L to be updated for the incomplete Cholesky factorization
  aij_L | Lower triangular potion from system matrix

Definition at line 121 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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 accordingly.

Since A should not be modified (const-correctness), updates are in L.

Definition at line 87 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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 (cf. Algorithm 2 in paper)

We use a fully synchronous (Jacobi-like) variant, because asynchronous methods as described in the paper are a nightmare to debug (and particularly funny if they sometimes fail, sometimes not)

Parameters

  L | Lower-triangular matrix L in LU factorization
  aij_L | Lower-triangular matrix L from A
  U_trans | Upper-triangular matrix U in CSC-storage, which is the same as U^trans in CSR-storage
  aij_U_trans | Upper-triangular matrix from A in CSC-storage, which is the same as U^trans in CSR-storage

Definition at line 272 of file ilu_operations.hpp.

template<typename NumericT >

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

Extracts the lower triangular part L and the upper triangular part U from A.

Diagonals of L and U are stored explicitly in order to enable better code reuse.

Definition at line 305 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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.

Since A should not be modified (const-correctness), updates are in L and U.

Definition at line 188 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::ilu_transpose | ( | compressed_matrix< NumericT > const & | A,
|  | compressed_matrix< NumericT > & | B
| ) |  |

Transposition B <- A^T, where the aij-vector is permuted in the same way as the value array in A when assigned to B.

Parameters

  A | Input matrix to be transposed
  B | Output matrix containing the transposed matrix

Definition at line 220 of file ilu_operations.hpp.

template<typename NumericT >

void viennacl::linalg::inclusive_scan | ( | vector_base< NumericT > & | vec1,
|  | vector_base< NumericT > & | vec2
| ) |  |

This function implements an inclusive scan.

Given an element vector (x_0, x_1, ..., x_{n-1}), this routine computes (x_0, x_0 + x_1, ..., x_0 + x_1 + ... + x_{n-1})

The two vectors either need to be the same (in-place), or reside in distinct memory regions. Partial overlaps of vec1 and vec2 are not allowed.

Parameters

  vec1 | Input vector.
  vec2 | The output vector.

Definition at line 1190 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::inclusive_scan | ( | vector_base< NumericT > & | vec | ) |

Implements an in-place inclusive scan of a vector.

Given an input element vector (x_0, x_1, ..., x_{n-1}), this routine overwrites the vector with (x_0, x_0 + x_1, ..., x_0 + x_1 + ... + x_{n-1})

Definition at line 1223 of file vector_operations.hpp.

template<typename T >

vcl_size_t viennacl::linalg::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

Definition at line 845 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP >

vcl_size_t viennacl::linalg::index_norm_inf | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec | ) |

Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression

Definition at line 871 of file vector_operations.hpp.

template<typename VectorT1 , typename VectorT2 >

viennacl::enable_if< viennacl::is_stl< typename viennacl::traits::tag_of< VectorT1 >::type >::value, typename VectorT1::value_type>::type viennacl::linalg::inner_prod | ( | VectorT1 const & | v1,
|  | VectorT2 const & | v2
| ) |  |

Examples:
  blas1.cpp, and lanczos.cpp.

Definition at line 100 of file inner_prod.hpp.

template<typename NumericT >

viennacl::scalar_expression< const vector_base<NumericT>, const vector_base<NumericT>, viennacl::op_inner_prod > viennacl::linalg::inner_prod | ( | vector_base< NumericT > const & | vector1,
|  | vector_base< NumericT > const & | vector2
| ) |  |

Definition at line 116 of file inner_prod.hpp.

template<typename LHS , typename RHS , typename OP , typename NumericT >

viennacl::scalar_expression< const viennacl::vector_expression<LHS, RHS, OP>, const vector_base<NumericT>, viennacl::op_inner_prod > viennacl::linalg::inner_prod | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vector1,
|  | vector_base< NumericT > const & | vector2
| ) |  |

Definition at line 131 of file inner_prod.hpp.

template<typename NumericT , typename LHS , typename RHS , typename OP >

viennacl::scalar_expression< const vector_base<NumericT>, const viennacl::vector_expression<LHS, RHS, OP>, viennacl::op_inner_prod > viennacl::linalg::inner_prod | ( | vector_base< NumericT > const & | vector1,
|  | viennacl::vector_expression< LHS, RHS, OP > const & | vector2
| ) |  |

Definition at line 145 of file inner_prod.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 >

viennacl::scalar_expression< const viennacl::vector_expression<LHS1, RHS1, OP1>, const viennacl::vector_expression<LHS2, RHS2, OP2>, viennacl::op_inner_prod > viennacl::linalg::inner_prod | ( | viennacl::vector_expression< LHS1, RHS1, OP1 > const & | vector1,
|  | viennacl::vector_expression< LHS2, RHS2, OP2 > const & | vector2
| ) |  |

Definition at line 160 of file inner_prod.hpp.

template<typename NumericT >

viennacl::vector_expression< const vector_base<NumericT>, const vector_tuple<NumericT>, viennacl::op_inner_prod > viennacl::linalg::inner_prod | ( | vector_base< NumericT > const & | x,
|  | vector_tuple< NumericT > const & | y_tuple
| ) |  |

Definition at line 173 of file inner_prod.hpp.

template<typename T >

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

Computes the inner product of two vectors with the final reduction step on the CPU - dispatcher interface.

Parameters

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

Definition at line 459 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::inner_prod_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec1,
|  | vector_base< T > const & | vec2,
|  | T & | result
| ) |  |

Definition at line 489 of file vector_operations.hpp.

template<typename T , typename LHS , typename RHS , typename OP >

void viennacl::linalg::inner_prod_cpu | ( | vector_base< T > const & | vec1,
|  | viennacl::vector_expression< LHS, RHS, OP > const & | vec2,
|  | T & | result
| ) |  |

Definition at line 500 of file vector_operations.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 , typename S3 >

void viennacl::linalg::inner_prod_cpu | ( | viennacl::vector_expression< LHS1, RHS1, OP1 > const & | vec1,
|  | viennacl::vector_expression< LHS2, RHS2, OP2 > const & | vec2,
|  | S3 & | result
| ) |  |

Definition at line 512 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::inner_prod_impl | ( | vector_base< T > const & | x,
|  | vector_tuple< T > const & | y_tuple,
|  | vector_base< T > & | result
| ) |  |

Computes the inner products <x, y1>, <x, y2>, ..., <x, y_N> and writes the result to a (sub-)vector.

Parameters

  x | The common vector
  y_tuple | A collection of vector, all of the same size.
  result | The result scalar (on the gpu). Needs to match the number of elements in y_tuple

Definition at line 530 of file vector_operations.hpp.

template<typename T >

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

Computes the inner product of two vectors - dispatcher interface.

Parameters

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

Definition at line 387 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::inner_prod_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec1,
|  | vector_base< T > const & | vec2,
|  | scalar< T > & | result
| ) |  |

Definition at line 417 of file vector_operations.hpp.

template<typename T , typename LHS , typename RHS , typename OP >

void viennacl::linalg::inner_prod_impl | ( | vector_base< T > const & | vec1,
|  | viennacl::vector_expression< LHS, RHS, OP > const & | vec2,
|  | scalar< T > & | result
| ) |  |

Definition at line 428 of file vector_operations.hpp.

template<typename LHS1 , typename RHS1 , typename OP1 , typename LHS2 , typename RHS2 , typename OP2 , typename T >

void viennacl::linalg::inner_prod_impl | ( | viennacl::vector_expression< LHS1, RHS1, OP1 > const & | vec1,
|  | viennacl::vector_expression< LHS2, RHS2, OP2 > const & | vec2,
|  | scalar< T > & | result
| ) |  |

Definition at line 440 of file vector_operations.hpp.

template<typename T , typename F , unsigned int ALIGNMENT>

std::vector<T> viennacl::linalg::inplace_qr | ( | viennacl::matrix< T, F, ALIGNMENT > & | A,
|  | vcl_size_t | block_size = `16`
| ) |  |

Overload of inplace-QR factorization of a ViennaCL matrix A.

Parameters

  A | A dense ViennaCL matrix to be factored
  block_size | The block size to be used.

Examples:
  least-squares.cpp, and qr.cpp.

Definition at line 647 of file qr.hpp.

template<typename MatrixType >

std::vector<typename MatrixType::value_type> viennacl::linalg::inplace_qr | ( | MatrixType & | A,
|  | vcl_size_t | block_size = `16`
| ) |  |

Overload of inplace-QR factorization for a general Boost.uBLAS compatible matrix A.

Parameters

  A | A dense compatible to Boost.uBLAS
  block_size | The block size to be used.

Definition at line 658 of file qr.hpp.

template<typename MatrixType , typename VectorType1 , typename VectorType2 >

void viennacl::linalg::inplace_qr_apply_trans_Q | ( | MatrixType const & | A,
|  | VectorType1 const & | betas,
|  | VectorType2 & | b
| ) |  |

Computes Q^T b, where Q is an implicit orthogonal matrix defined via its Householder reflectors stored in A.

Parameters

  A | A matrix holding the Householder reflectors in the lower triangular part. Typically obtained from calling inplace_qr() on the original matrix
  betas | The scalars beta_i for each Householder reflector (I - beta_i v_i v_i^T)
  b | The vector b to which the result Q^T b is directly written to

Examples:
  least-squares.cpp.

Definition at line 608 of file qr.hpp.

template<typename T , typename F , unsigned int ALIGNMENT, typename VectorType1 , unsigned int A2>

void viennacl::linalg::inplace_qr_apply_trans_Q | ( | viennacl::matrix< T, F, ALIGNMENT > const & | A,
|  | VectorType1 const & | betas,
|  | viennacl::vector< T, A2 > & | b
| ) |  |

Definition at line 628 of file qr.hpp.

template<typename NumericT , typename SolverTagT >

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

Direct inplace solver for triangular systems with multiple right hand sides, i.e. A \ B (MATLAB notation)

Parameters

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

Examples:
  blas2.cpp, and least-squares.cpp.

Definition at line 217 of file direct_solve.hpp.

template<typename NumericT , typename SolverTagT >

void viennacl::linalg::inplace_solve | ( | const matrix_base< NumericT > & | A,
|  | matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > | proxy_B,
|  | SolverTagT |
| ) |  |

Direct inplace solver for triangular systems with multiple transposed right hand sides, i.e. A \ B^T (MATLAB notation)

Parameters

  A | The system matrix
  proxy_B | The proxy for the transposed matrix of row vectors, where the solution is directly written to

Definition at line 230 of file direct_solve.hpp.

template<typename NumericT , typename SolverTagT >

void viennacl::linalg::inplace_solve | ( | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | proxy_A,
|  | matrix_base< NumericT > & | B,
|  | SolverTagT |
| ) |  |

Direct inplace solver for transposed triangular systems with multiple right hand sides, i.e. A^T \ B (MATLAB notation)

Parameters

  proxy_A | The transposed system matrix proxy
  B | The matrix holding the load vectors, where the solution is directly written to

Definition at line 251 of file direct_solve.hpp.

template<typename SparseMatrixType , class ScalarType , typename SOLVERTAG >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value>::type viennacl::linalg::inplace_solve | ( | const SparseMatrixType & | mat,
|  | viennacl::vector_base< ScalarType > & | vec,
|  | SOLVERTAG | tag
| ) |  |

Carries out triangular inplace solves.

Parameters

  mat | The matrix
  vec | The vector
  tag | The solver tag (lower_tag, unit_lower_tag, unit_upper_tag, or upper_tag)

Definition at line 258 of file sparse_matrix_operations.hpp.

template<typename NumericT , typename SolverTagT >

void viennacl::linalg::inplace_solve | ( | matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > const & | proxy_A,
|  | matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > | proxy_B,
|  | SolverTagT |
| ) |  |

Direct inplace solver for transposed triangular systems with multiple transposed right hand sides, i.e. A^T \ B^T (MATLAB notation)

Parameters

  proxy_A | The transposed system matrix proxy
  proxy_B | The transposed matrix holding the load vectors, where the solution is directly written to

Definition at line 271 of file direct_solve.hpp.

template<typename SparseMatrixType , class ScalarType , typename SOLVERTAG >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value>::type viennacl::linalg::inplace_solve | ( | const matrix_expression< const SparseMatrixType, const SparseMatrixType, op_trans > & | mat,
|  | viennacl::vector_base< ScalarType > & | vec,
|  | SOLVERTAG | tag
| ) |  |

Carries out transposed triangular inplace solves.

Parameters

  mat | The matrix
  vec | The vector
  tag | The solver tag (lower_tag, unit_lower_tag, unit_upper_tag, or upper_tag)

Definition at line 296 of file sparse_matrix_operations.hpp.

template<typename NumericT , typename SolverTagT >

void viennacl::linalg::inplace_solve | ( | const matrix_base< NumericT > & | mat,
|  | vector_base< NumericT > & | vec,
|  | SolverTagT const & | tag
| ) |  |

Inplace solution of a triangular system. Matlab notation A \ b.

Parameters

  mat | The system matrix (a dense matrix for which only the respective triangular form is used)
  vec | The right hand side vector
  tag | The tag (either lower_tag, unit_lower_tag, upper_tag, or unit_upper_tag)

Definition at line 453 of file direct_solve.hpp.

template<typename NumericT , typename SolverTagT >

void viennacl::linalg::inplace_solve | ( | matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > const & | proxy,
|  | vector_base< NumericT > & | vec,
|  | SolverTagT const & | tag
| ) |  |

Inplace solution of a triangular system with transposed system matrix.. Matlab notation A' \ b.

Parameters

  proxy | The transposed system matrix (a dense matrix for which only the respective triangular form is used)
  vec | The right hand side vector
  tag | The tag (either lower_tag, unit_lower_tag, upper_tag, or unit_upper_tag)

Definition at line 468 of file direct_solve.hpp.

template<typename NumericT >

void viennacl::linalg::lu_factorize | ( | matrix< NumericT, viennacl::row_major > & | A | ) |

LU factorization of a row-major dense matrix.

Parameters

  A | The system matrix, where the LU matrices are directly written to. The implicit unit diagonal of L is not written.

Examples:
  blas2.cpp.

Definition at line 42 of file lu.hpp.

template<typename NumericT >

void viennacl::linalg::lu_factorize | ( | matrix< NumericT, viennacl::column_major > & | A | ) |

LU factorization of a column-major dense matrix.

Parameters

  A | The system matrix, where the LU matrices are directly written to. The implicit unit diagonal of L is not written.

Definition at line 118 of file lu.hpp.

template<typename NumericT , typename F1 , typename F2 , unsigned int AlignmentV1, unsigned int AlignmentV2>

void viennacl::linalg::lu_substitute | ( | matrix< NumericT, F1, AlignmentV1 > const & | A,
|  | matrix< NumericT, F2, AlignmentV2 > & | B
| ) |  |

LU substitution for the system LU = rhs.

Parameters

  A | The system matrix, where the LU matrices are directly written to. The implicit unit diagonal of L is not written.
  B | The matrix of load vectors, where the solution is directly written to

Examples:
  blas2.cpp.

Definition at line 201 of file lu.hpp.

template<typename NumericT , typename F , unsigned int MatAlignmentV, unsigned int VecAlignmentV>

void viennacl::linalg::lu_substitute | ( | matrix< NumericT, F, MatAlignmentV > const & | A,
|  | vector< NumericT, VecAlignmentV > & | vec
| ) |  |

LU substitution for the system LU = rhs.

Parameters

  A | The system matrix, where the LU matrices are directly written to. The implicit unit diagonal of L is not written.
  vec | The load vector, where the solution is directly written to

Definition at line 216 of file lu.hpp.

template<typename NumericT >

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

Definition at line 208 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::matrix_column | ( | const matrix_base< NumericT > & | A,
|  | unsigned int | j,
|  | vector_base< NumericT > & | v
| ) |  |

Definition at line 337 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::matrix_diag_from_vector | ( | const vector_base< NumericT > & | v,
|  | int | k,
|  | matrix_base< NumericT > & | A
| ) |  |

Dispatcher interface for A = diag(v, k)

Definition at line 261 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::matrix_diag_to_vector | ( | const matrix_base< NumericT > & | A,
|  | int | k,
|  | vector_base< NumericT > & | v
| ) |  |

Dispatcher interface for v = diag(A, k)

Definition at line 287 of file matrix_operations.hpp.

template<typename NumericT >

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

Definition at line 234 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::matrix_row | ( | const matrix_base< NumericT > & | A,
|  | unsigned int | i,
|  | vector_base< NumericT > & | v
| ) |  |

Definition at line 312 of file matrix_operations.hpp.

template<typename NumericT >

NumericT viennacl::linalg::max | ( | std::vector< NumericT > const & | v1 | ) |

Definition at line 47 of file maxmin.hpp.

template<typename ScalarType >

viennacl::scalar_expression< const viennacl::vector_base<ScalarType>, const viennacl::vector_base<ScalarType>, viennacl::op_max > viennacl::linalg::max | ( | viennacl::vector_base< ScalarType > const & | v1 | ) |

Definition at line 67 of file maxmin.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, const viennacl::vector_expression<const LHS, const RHS, OP>, viennacl::op_max> viennacl::linalg::max | ( | viennacl::vector_expression< const LHS, const RHS, OP > const & | vector | ) |

Definition at line 80 of file maxmin.hpp.

template<typename T >

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

Computes the maximum of a vector with final reduction on the CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 928 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::max_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 958 of file vector_operations.hpp.

template<typename T >

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

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::max_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | scalar< T > & | result
| ) |  |

template<typename NumericT >

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

Computes the maximum of a vector with final reduction on the CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 885 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename NumericT >

void viennacl::linalg::max_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | viennacl::scalar< NumericT > & | result
| ) |  |

Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 915 of file vector_operations.hpp.

template<typename NumericT >

NumericT viennacl::linalg::min | ( | std::vector< NumericT > const & | v1 | ) |

Definition at line 91 of file maxmin.hpp.

template<typename ScalarType >

viennacl::scalar_expression< const viennacl::vector_base<ScalarType>, const viennacl::vector_base<ScalarType>, viennacl::op_min > viennacl::linalg::min | ( | viennacl::vector_base< ScalarType > const & | v1 | ) |

Definition at line 111 of file maxmin.hpp.

template<typename ScalarType >

viennacl::scalar_expression< const viennacl::vector_base<ScalarType>, const viennacl::vector_base<ScalarType>, viennacl::op_min > viennacl::linalg::min | ( | viennacl::vector< ScalarType > const & | v1 | ) |

Definition at line 123 of file maxmin.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, const viennacl::vector_expression<const LHS, const RHS, OP>, viennacl::op_min> viennacl::linalg::min | ( | viennacl::vector_expression< const LHS, const RHS, OP > const & | vector | ) |

Definition at line 136 of file maxmin.hpp.

template<typename T >

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

Computes the minimum of a vector with final reduction on the CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 1015 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::min_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 1045 of file vector_operations.hpp.

template<typename T >

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

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::min_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | scalar< T > & | result
| ) |  |

template<typename NumericT >

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

Computes the minimum of a vector with final reduction on the CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 972 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename NumericT >

void viennacl::linalg::min_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | viennacl::scalar< NumericT > & | result
| ) |  |

Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 1002 of file vector_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::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.

Examples:
  fft.cpp.

Definition at line 267 of file fft_operations.hpp.

template<typename ScalarType >

void viennacl::linalg::nmf | ( | viennacl::matrix_base< ScalarType > const & | V,
|  | viennacl::matrix_base< ScalarType > & | W,
|  | viennacl::matrix_base< ScalarType > & | 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

Examples:
  nmf.cpp.

Definition at line 57 of file nmf.hpp.

template<typename T , typename A >

T viennacl::linalg::norm_1 | ( | std::vector< T, A > const & | v1 | ) |

Examples:
  blas1.cpp.

Definition at line 61 of file norm_1.hpp.

template<typename ScalarType >

viennacl::scalar_expression< const viennacl::vector_base<ScalarType>, const viennacl::vector_base<ScalarType>, viennacl::op_norm_1 > viennacl::linalg::norm_1 | ( | viennacl::vector_base< ScalarType > const & | vector | ) |

Definition at line 78 of file norm_1.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, const viennacl::vector_expression<const LHS, const RHS, OP>, viennacl::op_norm_1> viennacl::linalg::norm_1 | ( | viennacl::vector_expression< const LHS, const RHS, OP > const & | vector | ) |

Definition at line 90 of file norm_1.hpp.

template<typename T >

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

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

Parameters

  vec | The vector
  result | The result scalar

Definition at line 613 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::norm_1_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the l^1-norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 644 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::norm_1_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the l^1-norm of a vector - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 598 of file vector_operations.hpp.

template<typename T >

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

Computes the l^1-norm of a vector - dispatcher interface.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 566 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::norm_1_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | scalar< T > & | result
| ) |  |

template<typename T , typename A >

T viennacl::linalg::norm_2 | ( | std::vector< T, A > const & | v1 | ) |

Examples:
  amg.cpp, blas1.cpp, custom-kernels.cpp, iterative-armadillo.cpp, iterative-custom.cpp, iterative-eigen.cpp, iterative-mtl4.cpp, iterative-ublas.cpp, multithreaded.cpp, and spai.cpp.

Definition at line 96 of file norm_2.hpp.

template<typename ScalarType >

viennacl::scalar_expression< const viennacl::vector_base<ScalarType>, const viennacl::vector_base<ScalarType>, viennacl::op_norm_2 > viennacl::linalg::norm_2 | ( | viennacl::vector_base< ScalarType > const & | v | ) |

Definition at line 112 of file norm_2.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, const viennacl::vector_expression<const LHS, const RHS, OP>, viennacl::op_norm_2> viennacl::linalg::norm_2 | ( | viennacl::vector_expression< const LHS, const RHS, OP > const & | vector | ) |

Definition at line 125 of file norm_2.hpp.

template<typename T >

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

Computes the l^2-norm of a vector with final reduction on the CPU - dispatcher interface.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 705 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::norm_2_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the l^2-norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 736 of file vector_operations.hpp.

template<typename T >

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

Computes the l^2-norm of a vector - dispatcher interface.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 660 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::norm_2_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | scalar< T > & | result
| ) |  |

Computes the l^2-norm of a vector - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 691 of file vector_operations.hpp.

template<typename NumericT >

scalar_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_norm_frobenius> viennacl::linalg::norm_frobenius | ( | const matrix_base< NumericT > & | A | ) |

Definition at line 61 of file norm_frobenius.hpp.

template<typename T >

void viennacl::linalg::norm_frobenius_cpu | ( | matrix_base< T > const & | A,
|  | T & | result
| ) |  |

Computes the Frobenius norm of a vector with final reduction on the CPU.

Parameters

  A | The matrix
  result | The result scalar

Note that if A is strided or off-set, then a copy will be created.

Definition at line 399 of file matrix_operations.hpp.

template<typename T >

void viennacl::linalg::norm_frobenius_impl | ( | matrix_base< T > const & | A,
|  | scalar< T > & | result
| ) |  |

Computes the Frobenius norm of a matrix - dispatcher interface.

Parameters

  A | The matrix
  result | The result scalar

Note that if A is strided or off-set, then a copy will be created.

Definition at line 369 of file matrix_operations.hpp.

template<typename T , typename A >

T viennacl::linalg::norm_inf | ( | std::vector< T, A > const & | v1 | ) |

Examples:
  blas1.cpp.

Definition at line 60 of file norm_inf.hpp.

template<typename ScalarType >

viennacl::scalar_expression< const viennacl::vector_base<ScalarType>, const viennacl::vector_base<ScalarType>, viennacl::op_norm_inf > viennacl::linalg::norm_inf | ( | viennacl::vector_base< ScalarType > const & | v1 | ) |

Definition at line 80 of file norm_inf.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, const viennacl::vector_expression<const LHS, const RHS, OP>, viennacl::op_norm_inf> viennacl::linalg::norm_inf | ( | viennacl::vector_expression< const LHS, const RHS, OP > const & | vector | ) |

Definition at line 93 of file norm_inf.hpp.

template<typename T >

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

Computes the supremum-norm of a vector with final reduction on the CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 797 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::norm_inf_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the supremum norm of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 828 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::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 752 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::norm_inf_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | scalar< T > & | result
| ) |  |

Computes the supremum norm of a vector - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 783 of file vector_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

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

Normalize vector on with his own size.

Definition at line 299 of file fft_operations.hpp.

template<typename NumericT >

viennacl::matrix_expression<const vector_base<NumericT>, const vector_base<NumericT>, op_prod> viennacl::linalg::outer_prod | ( | const vector_base< NumericT > & | vec1,
|  | const vector_base< NumericT > & | vec2
| ) |  |

Returns a proxy class for the operation mat += vec1 * vec2^T, i.e. a rank 1 update.

Parameters

  vec1 | The first vector
  vec2 | The second vector

Examples:
  multithreaded.cpp.

Definition at line 840 of file matrix_operations.hpp.

template<typename MatrixT , typename NumericT >

void viennacl::linalg::pipelined_bicgstab_prod | ( | MatrixT 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
| ) |  |

Performs a joint vector update operation needed for an efficient pipelined CG algorithm.

This routines computes for a matrix A and vectors 'p' and 'Ap': Ap = prod(A, p); and computes the two reduction stages for computing inner_prod(p,Ap), inner_prod(Ap,Ap)

Definition at line 208 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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
| ) |  |

Performs a joint vector update operation needed for an efficient pipelined CG algorithm.

This routines computes for vectors 's', 'r', 'Ap': s = r - alpha * Ap with alpha obtained from a reduction step on the 0th and the 3rd out of 6 chunks in inner_prod_buffer and runs the parallel reduction stage for computing inner_prod(s,s)

Definition at line 134 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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
| ) |  |

Performs a joint vector update operation needed for an efficient pipelined BiCGStab algorithm.

x_{j+1} = x_j + alpha * p_j + omega * s_j r_{j+1} = s_j - omega * t_j p_{j+1} = r_{j+1} + beta * (p_j - omega * q_j) and compute first stage of r_dot_r0 = <r_{j+1}, r_o^*> for use in next iteration

Definition at line 171 of file iterative_operations.hpp.

template<typename MatrixT , typename NumericT >

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

Performs a joint vector update operation needed for an efficient pipelined CG algorithm.

This routines computes for a matrix A and vectors 'p' and 'Ap': Ap = prod(A, p); and computes the two reduction stages for computing inner_prod(p,Ap), inner_prod(Ap,Ap)

Definition at line 97 of file iterative_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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
| ) |  |

Performs a joint vector update operation needed for an efficient pipelined CG algorithm.

This routines computes for vectors 'result', 'p', 'r', 'Ap': result += alpha * p; r -= alpha * Ap; p = r + beta * p; and runs the parallel reduction stage for computing inner_prod(r,r)

Definition at line 59 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::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 | k,
|  | vector_base< T > & | vi_in_vk_buffer,
|  | vcl_size_t | buffer_chunk_size
| ) |  |

Computes the first reduction stage for multiple inner products <v_i, v_k>, i=0..k-1.

All vectors v_i are stored column-major in the array 'device_krylov_basis', where each vector has an actual length 'v_k_size', but might be padded to have 'v_k_internal_size'

Definition at line 286 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::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 | 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
| ) |  |

Computes the second reduction stage for multiple inner products <v_i, v_k>, i=0..k-1, then updates v_k -= <v_i, v_k> v_i and computes the first reduction stage for ||v_k||.

All vectors v_i are stored column-major in the array 'device_krylov_basis', where each vector has an actual length 'v_k_size', but might be padded to have 'v_k_internal_size'

Definition at line 321 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::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 248 of file iterative_operations.hpp.

template<typename MatrixType , typename T >

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

Performs a joint vector update operation needed for an efficient pipelined GMRES algorithm.

This routines computes for a matrix A and vectors 'p' and 'Ap': Ap = prod(A, p); and computes the two reduction stages for computing inner_prod(p,Ap), inner_prod(Ap,Ap)

Definition at line 393 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::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 | k
| ) |  |

Computes x += eta_0 r + sum_{i=1}^{k-1} eta_i v_{i-1}.

Definition at line 356 of file iterative_operations.hpp.

template<typename T >

void viennacl::linalg::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 (CPU scalar)
  beta | The second transformation coefficient (CPU scalar)

Examples:
  blas1.cpp.

Definition at line 1152 of file vector_operations.hpp.

template<typename NumericT >

void viennacl::linalg::precondition | ( | viennacl::compressed_matrix< NumericT > & | A,
|  | ichol0_tag const & |
| ) |  |

Implementation of a ILU-preconditioner with static pattern. Optimized version for CSR matrices.

Refer to Chih-Jen Lin and Jorge J. Moré, Incomplete Cholesky Factorizations with Limited Memory, SIAM J. Sci. Comput., 21(1), 24–45 for one of many descriptions of incomplete Cholesky Factorizations

Parameters

  A | The input matrix in CSR format // param tag An ichol0_tag in order to dispatch among several other preconditioners.

Definition at line 55 of file ichol.hpp.

template<typename NumericT >

void viennacl::linalg::precondition | ( | viennacl::compressed_matrix< NumericT > & | A,
|  | ilu0_tag const & |
| ) |  |

Implementation of a ILU-preconditioner with static pattern. Optimized version for CSR matrices.

refer to the Algorithm in Saad's book (1996 edition)

Parameters

  A | The sparse matrix matrix. The result is directly written to A.

Definition at line 78 of file ilu0.hpp.

template<typename NumericT >

void viennacl::linalg::precondition | ( | viennacl::compressed_matrix< NumericT > const & | A,
|  | viennacl::compressed_matrix< NumericT > & | L,
|  | viennacl::compressed_matrix< NumericT > & | U,
|  | ilut_tag const & | tag
| ) |  |

Implementation of a ILU-preconditioner with threshold. Optimized implementation for compressed_matrix.

refer to Algorithm 10.6 by Saad's book (1996 edition)

Parameters

  A | The input matrix. Either a compressed_matrix or of type std::vector< std::map<T, U> >
  L | The output matrix for L.
  U | The output matrix for U.
  tag | An ilut_tag in order to dispatch among several other preconditioners.

Definition at line 193 of file ilut.hpp.

template<typename T , typename A1 , typename A2 , typename VectorT >

VectorT viennacl::linalg::prod | ( | std::vector< std::vector< T, A1 >, A2 > const & | matrix,
|  | VectorT const & | vector
| ) |  |

Examples:
  amg.cpp, armadillo-with-viennacl.cpp, blas2.cpp, blas3.cpp, custom-context.cpp, eigen-with-viennacl.cpp, iterative-custom.cpp, lanczos.cpp, matrix-range.cpp, mtl4-with-viennacl.cpp, nmf.cpp, power-iter.cpp, spai.cpp, sparse.cpp, and structured-matrices.cpp.

Definition at line 102 of file prod.hpp.

template<typename KEY , typename DATA , typename COMPARE , typename AMAP , typename AVEC , typename VectorT >

VectorT viennacl::linalg::prod | ( | std::vector< std::map< KEY, DATA, COMPARE, AMAP >, AVEC > const & | matrix,
|  | VectorT const & | vector
| ) |  |

Definition at line 117 of file prod.hpp.

template<typename NumericT >

viennacl::matrix_expression< const viennacl::matrix_base<NumericT>, const viennacl::matrix_base<NumericT>, viennacl::op_mat_mat_prod > viennacl::linalg::prod | ( | viennacl::matrix_base< NumericT > const & | A,
|  | viennacl::matrix_base< NumericT > const & | B
| ) |  |

Definition at line 153 of file prod.hpp.

template<typename NumericT , typename LhsT , typename RhsT , typename OpT >

viennacl::matrix_expression< const viennacl::matrix_base<NumericT>, const viennacl::matrix_expression<const LhsT, const RhsT, OpT>, viennacl::op_mat_mat_prod > viennacl::linalg::prod | ( | viennacl::matrix_base< NumericT > const & | A,
|  | viennacl::matrix_expression< const LhsT, const RhsT, OpT > const & | B
| ) |  |

Definition at line 166 of file prod.hpp.

template<typename LhsT , typename RhsT , typename OpT , typename NumericT >

viennacl::matrix_expression< const viennacl::matrix_expression<const LhsT, const RhsT, OpT>, const viennacl::matrix_base<NumericT>, viennacl::op_mat_mat_prod > viennacl::linalg::prod | ( | viennacl::matrix_expression< const LhsT, const RhsT, OpT > const & | A,
|  | viennacl::matrix_base< NumericT > const & | B
| ) |  |

Definition at line 179 of file prod.hpp.

template<typename LhsT1 , typename RhsT1 , typename OpT1 , typename LhsT2 , typename RhsT2 , typename OpT2 >

viennacl::matrix_expression< const viennacl::matrix_expression<const LhsT1, const RhsT1, OpT1>, const viennacl::matrix_expression<const LhsT2, const RhsT2, OpT2>, viennacl::op_mat_mat_prod > viennacl::linalg::prod | ( | viennacl::matrix_expression< const LhsT1, const RhsT1, OpT1 > const & | A,
|  | viennacl::matrix_expression< const LhsT2, const RhsT2, OpT2 > const & | B
| ) |  |

Definition at line 194 of file prod.hpp.

template<typename NumericT >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::vector_base<NumericT>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix_base< NumericT > const & | A,
|  | viennacl::vector_base< NumericT > const & | x
| ) |  |

Definition at line 209 of file prod.hpp.

template<typename NumericT , typename F >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::vector_base<NumericT>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix< NumericT, F > const & | A,
|  | viennacl::vector_base< NumericT > const & | x
| ) |  |

Definition at line 222 of file prod.hpp.

template<typename MatrixT , typename NumericT >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::vector_base<NumericT>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix_range< MatrixT > const & | A,
|  | viennacl::vector_base< NumericT > const & | x
| ) |  |

Definition at line 235 of file prod.hpp.

template<typename MatrixT , typename NumericT >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::vector_base<NumericT>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix_slice< MatrixT > const & | A,
|  | viennacl::vector_base< NumericT > const & | x
| ) |  |

Definition at line 248 of file prod.hpp.

template<typename NumericT , typename LhsT , typename RhsT , typename OpT >

viennacl::vector_expression< const viennacl::matrix_expression<const LhsT, const RhsT, OpT>, const viennacl::vector_base<NumericT>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix_expression< const LhsT, const RhsT, OpT > const & | A,
|  | viennacl::vector_base< NumericT > const & | x
| ) |  |

Definition at line 261 of file prod.hpp.

template<typename NumericT , typename LhsT , typename RhsT , typename OpT >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::vector_expression<const LhsT, const RhsT, OpT>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix_base< NumericT > const & | A,
|  | viennacl::vector_expression< const LhsT, const RhsT, OpT > const & | x
| ) |  |

Definition at line 275 of file prod.hpp.

template<typename LhsT1 , typename RhsT1 , typename OpT1 , typename LhsT2 , typename RhsT2 , typename OpT2 >

viennacl::vector_expression< const viennacl::matrix_expression<const LhsT1, const RhsT1, OpT1>, const viennacl::vector_expression<const LhsT2, const RhsT2, OpT2>, viennacl::op_prod > viennacl::linalg::prod | ( | viennacl::matrix_expression< const LhsT1, const RhsT1, OpT1 > const & | A,
|  | viennacl::vector_expression< const LhsT2, const RhsT2, OpT2 > const & | x
| ) |  |

Definition at line 290 of file prod.hpp.

template<typename SparseMatrixType , typename SCALARTYPE >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, viennacl::matrix_expression<const SparseMatrixType, const matrix_base <SCALARTYPE>, op_prod > >::type viennacl::linalg::prod | ( | const SparseMatrixType & | sp_mat,
|  | const viennacl::matrix_base< SCALARTYPE > & | d_mat
| ) |  |

Definition at line 307 of file prod.hpp.

template<typename SparseMatrixType , typename SCALARTYPE >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, viennacl::matrix_expression< const SparseMatrixType, const viennacl::matrix_expression<const viennacl::matrix_base<SCALARTYPE>, const viennacl::matrix_base<SCALARTYPE>, op_trans>, viennacl::op_prod > >::type viennacl::linalg::prod | ( | const SparseMatrixType & | A,
|  | viennacl::matrix_expression< const viennacl::matrix_base< SCALARTYPE >, const viennacl::matrix_base< SCALARTYPE >, op_trans > const & | B
| ) |  |

Definition at line 324 of file prod.hpp.

template<typename NumericT >

viennacl::matrix_expression<const compressed_matrix<NumericT>, const compressed_matrix<NumericT>, op_prod > viennacl::linalg::prod | ( | compressed_matrix< NumericT > const & | A,
|  | compressed_matrix< NumericT > const & | B
| ) |  |

Sparse matrix-matrix product with compressed_matrix objects.

Definition at line 342 of file prod.hpp.

template<typename SparseMatrixType , typename NumericT >

vector_expression<const SparseMatrixType, const vector_base<NumericT>, op_prod > viennacl::linalg::prod | ( | const SparseMatrixType & | A,
|  | const vector_base< NumericT > & | x
| ) |  |

Generic matrix-vector product with user-provided sparse matrix type.

Definition at line 355 of file prod.hpp.

template<class SCALARTYPE , unsigned int ALIGNMENT>

void viennacl::linalg::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

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

Definition at line 48 of file vandermonde_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::prod_impl | ( | viennacl::hankel_matrix< NumericT, AlignmentV > const & | A,
|  | viennacl::vector_base< NumericT > const & | vec,
|  | viennacl::vector_base< NumericT > & | result
| ) |  |

Carries out matrix-vector multiplication with a hankel_matrix.

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

Parameters

  A | The matrix
  vec | The vector
  result | The result vector

Definition at line 49 of file hankel_matrix_operations.hpp.

template<class SCALARTYPE , unsigned int ALIGNMENT>

void viennacl::linalg::prod_impl | ( | const viennacl::toeplitz_matrix< SCALARTYPE, ALIGNMENT > & | mat,
|  | const viennacl::vector_base< SCALARTYPE > & | vec,
|  | viennacl::vector_base< SCALARTYPE > & | result
| ) |  |

Carries out matrix-vector multiplication with a toeplitz_matrix.

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

Parameters

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

Definition at line 49 of file toeplitz_matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::prod_impl | ( | viennacl::circulant_matrix< NumericT, AlignmentV > const & | mat,
|  | viennacl::vector_base< NumericT > const & | vec,
|  | viennacl::vector_base< NumericT > & | result
| ) |  |

Carries out matrix-vector multiplication with a circulant_matrix.

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

Parameters

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

Definition at line 49 of file circulant_matrix_operations.hpp.

template<typename SparseMatrixType , class ScalarType >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value>::type viennacl::linalg::prod_impl | ( | const SparseMatrixType & | mat,
|  | const viennacl::vector_base< ScalarType > & | vec,
|  | ScalarType | alpha,
|  | viennacl::vector_base< ScalarType > & | result,
|  | ScalarType | beta
| ) |  |

Carries out matrix-vector multiplication involving a sparse matrix type.

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

Parameters

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

Definition at line 92 of file sparse_matrix_operations.hpp.

template<typename SparseMatrixType , class ScalarType >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value>::type viennacl::linalg::prod_impl | ( | const SparseMatrixType & | sp_mat,
|  | const viennacl::matrix_base< ScalarType > & | d_mat,
|  | viennacl::matrix_base< ScalarType > & | result
| ) |  |

Carries out matrix-matrix multiplication first matrix being sparse.

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

Parameters

  sp_mat | The sparse matrix
  d_mat | The dense matrix
  result | The result matrix (dense)

Definition at line 135 of file sparse_matrix_operations.hpp.

template<typename SparseMatrixType , class ScalarType >

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value>::type viennacl::linalg::prod_impl | ( | const SparseMatrixType & | sp_mat,
|  | const viennacl::matrix_expression< const viennacl::matrix_base< ScalarType >, const viennacl::matrix_base< ScalarType >, viennacl::op_trans > & | d_mat,
|  | viennacl::matrix_base< ScalarType > & | result
| ) |  |

Carries out matrix-matrix multiplication first matrix being sparse, and the second transposed.

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

Parameters

  sp_mat | The sparse matrix
  d_mat | The dense matrix (transposed)
  result | The result matrix (dense)

Definition at line 175 of file sparse_matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::prod_impl | ( | const viennacl::compressed_matrix< NumericT > & | A,
|  | const viennacl::compressed_matrix< NumericT > & | B,
|  | viennacl::compressed_matrix< NumericT > & | 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 219 of file sparse_matrix_operations.hpp.

template<typename NumericT , typename ScalarType >

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

Carries out matrix-matrix multiplication.

Implementation of C = prod(A, B);

Definition at line 519 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarType >

void viennacl::linalg::prod_impl | ( | const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | A,
|  | const matrix_base< NumericT > & | B,
|  | matrix_base< NumericT > & | C,
|  | ScalarType | alpha,
|  | ScalarType | beta
| ) |  |

Carries out matrix-matrix multiplication.

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

Definition at line 560 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarType >

void viennacl::linalg::prod_impl | ( | const matrix_base< NumericT > & | A,
|  | const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | B,
|  | matrix_base< NumericT > & | C,
|  | ScalarType | alpha,
|  | ScalarType | beta
| ) |  |

Carries out matrix-matrix multiplication.

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

Definition at line 603 of file matrix_operations.hpp.

template<typename NumericT , typename ScalarType >

void viennacl::linalg::prod_impl | ( | const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | A,
|  | const viennacl::matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | B,
|  | matrix_base< NumericT > & | C,
|  | ScalarType | alpha,
|  | ScalarType | beta
| ) |  |

Carries out matrix-matrix multiplication.

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

Definition at line 643 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::prod_impl | ( | const matrix_base< NumericT > & | 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

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

Definition at line 438 of file matrix_operations.hpp.

template<typename NumericT >

void viennacl::linalg::prod_impl | ( | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, 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_trans | The transposed matrix proxy
  vec | The vector
  result | The result vector

Definition at line 479 of file matrix_operations.hpp.

template<typename SparseMatrixType , class SCALARTYPE , unsigned int ALIGNMENT>

viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value, vector_expression<const SparseMatrixType, const vector<SCALARTYPE, ALIGNMENT>, op_prod > >::type viennacl::linalg::prod_impl | ( | const SparseMatrixType & | mat,
|  | const vector< SCALARTYPE, ALIGNMENT > & | vec
| ) |  |

template<typename SCALARTYPE >

void viennacl::linalg::qr_method_nsm | ( | viennacl::matrix< SCALARTYPE > & | A,
|  | viennacl::matrix< SCALARTYPE > & | Q,
|  | std::vector< SCALARTYPE > & | D,
|  | std::vector< SCALARTYPE > & | E
| ) |  |

Definition at line 796 of file qr-method.hpp.

template<typename SCALARTYPE >

void viennacl::linalg::qr_method_sym | ( | viennacl::matrix< SCALARTYPE > & | A,
|  | viennacl::matrix< SCALARTYPE > & | Q,
|  | std::vector< SCALARTYPE > & | D
| ) |  |

Examples:
  qr_method.cpp.

Definition at line 806 of file qr-method.hpp.

template<typename SCALARTYPE >

void viennacl::linalg::qr_method_sym | ( | viennacl::matrix< SCALARTYPE > & | A,
|  | viennacl::matrix< SCALARTYPE > & | Q,
|  | viennacl::vector_base< SCALARTYPE > & | D
| ) |  |

Definition at line 817 of file qr-method.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::radix2 | ( | viennacl::matrix< NumericT, viennacl::row_major, AlignmentV > & | 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 1D 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 162 of file fft_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::radix2 | ( | viennacl::vector< NumericT, AlignmentV > & | 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 2D 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 198 of file fft_operations.hpp.

template<typename NumericT >

void viennacl::linalg::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)

Examples:
  fft.cpp.

Definition at line 390 of file fft_operations.hpp.

template<typename MatrixType , typename VectorType >

void viennacl::linalg::recoverQ | ( | MatrixType const & | A,
|  | VectorType const & | betas,
|  | MatrixType & | Q,
|  | MatrixType & | R
| ) |  |

Examples:
  qr.cpp.

Definition at line 564 of file qr.hpp.

template<typename NumericT , unsigned int AlignmentV>

void viennacl::linalg::reorder | ( | viennacl::vector< NumericT, AlignmentV > & | 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 125 of file fft_operations.hpp.

template<typename NumericT >

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

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

Definition at line 452 of file fft_operations.hpp.

template<typename NumericT >

viennacl::vector_expression< const viennacl::matrix_base<NumericT>, const viennacl::matrix_base<NumericT>, viennacl::op_row_sum > viennacl::linalg::row_sum | ( | viennacl::matrix_base< NumericT > const & | A | ) |

User interface function for computing the sum of all elements of each row of a matrix.

Definition at line 77 of file sum.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::vector_expression<const viennacl::matrix_expression<const LHS, const RHS, OP>, const viennacl::matrix_expression<const LHS, const RHS, OP>, viennacl::op_row_sum> viennacl::linalg::row_sum | ( | viennacl::matrix_expression< const LHS, const RHS, OP > const & | A | ) |

User interface function for computing the sum of all elements of each row of a matrix specified by a matrix operation.

Typical use case: vector<double> my_sums = viennacl::linalg::row_sum(A + B);

Definition at line 92 of file sum.hpp.

template<typename NumericT >

void viennacl::linalg::row_sum_impl | ( | const matrix_base< NumericT > & | A,
|  | vector_base< NumericT > & | result
| ) |  |

Definition at line 679 of file matrix_operations.hpp.

template<typename NumericT , typename S1 >

void viennacl::linalg::scaled_rank_1_update | ( | matrix_base< NumericT > & | 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

  mat1 | 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 859 of file matrix_operations.hpp.

template<typename MatrixType , typename VectorType >

VectorType viennacl::linalg::solve | ( | const MatrixType & | matrix,
|  | VectorType const & | rhs,
|  | mixed_precision_cg_tag const & | tag
| ) |  |

Implementation of the conjugate gradient solver without preconditioner.

Following the algorithm in the book by Y. Saad "Iterative Methods for sparse linear systems"

Parameters

  matrix | The system matrix
  rhs | The load vector
  tag | Solver configuration tag

Returns
  The result vector

Definition at line 96 of file mixed_precision_cg.hpp.

template<typename MatrixType , typename VectorType >

VectorType viennacl::linalg::solve | ( | const MatrixType & | matrix,
|  | VectorType const & | rhs,
|  | mixed_precision_cg_tag const & | tag,
|  | viennacl::linalg::no_precond |
| ) |  |

Definition at line 190 of file mixed_precision_cg.hpp.

template<typename NumericT , typename SolverTagT >

matrix_base<NumericT> viennacl::linalg::solve | ( | const matrix_base< NumericT > & | A,
|  | const matrix_base< NumericT > & | B,
|  | SolverTagT | tag
| ) |  |

Convenience functions for C = solve(A, B, some_tag()); Creates a temporary result matrix and forwards the request to inplace_solve()

Parameters

  A | The system matrix
  B | The matrix of load vectors
  tag | Dispatch tag

Definition at line 301 of file direct_solve.hpp.

template<typename NumericT , typename SolverTagT >

matrix_base<NumericT> viennacl::linalg::solve | ( | const matrix_base< NumericT > & | A,
|  | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | proxy,
|  | SolverTagT | tag
| ) |  |

Convenience functions for C = solve(A, B^T, some_tag()); Creates a temporary result matrix and forwards the request to inplace_solve()

Parameters

  A | The system matrix
  proxy | The transposed load vector
  tag | Dispatch tag

Definition at line 318 of file direct_solve.hpp.

template<typename NumericT , typename SolverTagT >

matrix_base<NumericT> viennacl::linalg::solve | ( | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | proxy,
|  | const matrix_base< NumericT > & | B,
|  | SolverTagT | tag
| ) |  |

Convenience functions for result = solve(trans(mat), B, some_tag()); Creates a temporary result matrix and forwards the request to inplace_solve()

Parameters

  proxy | The transposed system matrix proxy
  B | The matrix of load vectors
  tag | Dispatch tag

Definition at line 335 of file direct_solve.hpp.

template<typename MatrixT , typename VectorT , typename PreconditionerT >

VectorT viennacl::linalg::solve | ( | MatrixT const & | matrix,
|  | VectorT const & | rhs,
|  | cg_tag const & | tag,
|  | PreconditionerT const & | precond
| ) |  |

Implementation of the preconditioned conjugate gradient solver, generic implementation for non-ViennaCL types.

Following Algorithm 9.1 in "Iterative Methods for Sparse Linear Systems" by Y. Saad

Parameters

  matrix | The system matrix
  rhs | The load vector
  tag | Solver configuration tag
  precond | A preconditioner. Precondition operation is done via member function apply()

Returns
  The result vector

Definition at line 339 of file cg.hpp.

template<typename IndexT , typename NumericT , typename PreconditionerT >

std::vector<NumericT> viennacl::linalg::solve | ( | std::vector< std::map< IndexT, NumericT > > const & | A,
|  | std::vector< NumericT > const & | rhs,
|  | cg_tag const & | tag,
|  | PreconditionerT const & | precond
| ) |  |

Convenience overload for calling the CG solver using types from the C++ STL.

A std::vector<std::map<T, U> > matrix is convenient for e.g. finite element assembly. It is not the fastest option for setting up a system, but often it is fast enough - particularly for just trying things out.

Definition at line 350 of file cg.hpp.

template<typename NumericT , typename SolverTagT >

matrix_base<NumericT> viennacl::linalg::solve | ( | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | proxy_A,
|  | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | proxy_B,
|  | SolverTagT | tag
| ) |  |

Convenience functions for result = solve(trans(mat), vec, some_tag()); Creates a temporary result vector and forwards the request to inplace_solve()

Parameters

  proxy_A | The transposed system matrix proxy
  proxy_B | The transposed matrix of load vectors, where the solution is directly written to
  tag | Dispatch tag

Definition at line 352 of file direct_solve.hpp.

template<typename MatrixT , typename VectorT >

VectorT viennacl::linalg::solve | ( | MatrixT const & | matrix,
|  | VectorT const & | rhs,
|  | cg_tag const & | tag
| ) |  |

Entry point for the unpreconditioned CG method.

Parameters

  matrix | The system matrix
  rhs | Right hand side vector (load vector)
  tag | A BiCGStab tag providing relative tolerances, etc.

Definition at line 372 of file cg.hpp.

template<typename NumericT >

vector<NumericT> viennacl::linalg::solve | ( | const matrix_base< NumericT > & | mat,
|  | const vector_base< NumericT > & | vec,
|  | viennacl::linalg::upper_tag const & | tag
| ) |  |

Convenience function for result = solve(mat, vec, upper_tag()); for an upper triangular solve.

Creates a temporary result vector and forwards the request to inplace_solve()

Parameters

  mat | The system matrix
  vec | The load vector
  tag | Dispatch tag

Definition at line 492 of file direct_solve.hpp.

template<typename MatrixT , typename VectorT , typename PreconditionerT >

VectorT viennacl::linalg::solve | ( | MatrixT const & | matrix,
|  | VectorT const & | rhs,
|  | bicgstab_tag const & | tag,
|  | PreconditionerT const & | precond
| ) |  |

Examples:
  amg.cpp, blas2.cpp, iterative-armadillo.cpp, iterative-eigen.cpp, iterative-mtl4.cpp, iterative-ublas.cpp, iterative.cpp, matrix-free.cpp, multithreaded_cg.cpp, and spai.cpp.

Definition at line 496 of file bicgstab.hpp.

template<typename IndexT , typename NumericT , typename PreconditionerT >

std::vector<NumericT> viennacl::linalg::solve | ( | std::vector< std::map< IndexT, NumericT > > const & | A,
|  | std::vector< NumericT > const & | rhs,
|  | bicgstab_tag const & | tag,
|  | PreconditionerT const & | precond
| ) |  |

Convenience overload for calling the preconditioned BiCGStab solver using types from the C++ STL.

A std::vector<std::map<T, U> > matrix is convenient for e.g. finite element assembly. It is not the fastest option for setting up a system, but often it is fast enough - particularly for just trying things out.

Definition at line 508 of file bicgstab.hpp.

template<typename NumericT >

vector<NumericT> viennacl::linalg::solve | ( | const matrix_base< NumericT > & | mat,
|  | const vector_base< NumericT > & | vec,
|  | viennacl::linalg::unit_upper_tag const & | tag
| ) |  |

Convenience function for result = solve(mat, vec, upper_tag()); for an upper triangular solve with unit diagonal.

Creates a temporary result vector and forwards the request to inplace_solve()

Parameters

  mat | The system matrix
  vec | The load vector
  tag | Dispatch tag

Definition at line 511 of file direct_solve.hpp.

template<typename MatrixT , typename VectorT >

VectorT viennacl::linalg::solve | ( | MatrixT const & | matrix,
|  | VectorT const & | rhs,
|  | bicgstab_tag const & | tag
| ) |  |

Entry point for the unpreconditioned BiCGStab method.

Parameters

  matrix | The system matrix
  rhs | Right hand side vector (load vector)
  tag | A BiCGStab tag providing relative tolerances, etc.

Definition at line 530 of file bicgstab.hpp.

template<typename NumericT >

vector<NumericT> viennacl::linalg::solve | ( | const matrix_base< NumericT > & | mat,
|  | const vector_base< NumericT > & | vec,
|  | viennacl::linalg::lower_tag const & | tag
| ) |  |

Convenience function for result = solve(mat, vec, upper_tag()); for a lower triangular solve.

Creates a temporary result vector and forwards the request to inplace_solve()

Parameters

  mat | The system matrix
  vec | The load vector
  tag | Dispatch tag

Definition at line 530 of file direct_solve.hpp.

template<typename NumericT >

vector<NumericT> viennacl::linalg::solve | ( | const matrix_base< NumericT > & | mat,
|  | const vector_base< NumericT > & | vec,
|  | viennacl::linalg::unit_lower_tag const & | tag
| ) |  |

Convenience function for result = solve(mat, vec, upper_tag()); for a lower triangular solve with unit diagonal.

Creates a temporary result vector and forwards the request to inplace_solve()

Parameters

  mat | The system matrix
  vec | The load vector
  tag | Dispatch tag

Definition at line 549 of file direct_solve.hpp.

template<typename NumericT , typename SolverTagT >

vector<NumericT> viennacl::linalg::solve | ( | const matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_trans > & | proxy,
|  | const vector_base< NumericT > & | vec,
|  | SolverTagT const & | tag
| ) |  |

Convenience functions for result = solve(trans(mat), vec, some_tag()); Creates a temporary result vector and forwards the request to inplace_solve()

Parameters

  proxy | The transposed system matrix proxy
  vec | The load vector, where the solution is directly written to
  tag | Dispatch tag

Definition at line 566 of file direct_solve.hpp.

template<typename MatrixT , typename VectorT , typename PreconditionerT >

VectorT viennacl::linalg::solve | ( | MatrixT const & | matrix,
|  | VectorT const & | rhs,
|  | gmres_tag const & | tag,
|  | PreconditionerT const & | precond
| ) |  |

Definition at line 636 of file gmres.hpp.

template<typename IndexT , typename NumericT , typename PreconditionerT >

std::vector<NumericT> viennacl::linalg::solve | ( | std::vector< std::map< IndexT, NumericT > > const & | A,
|  | std::vector< NumericT > const & | rhs,
|  | gmres_tag const & | tag,
|  | PreconditionerT const & | precond
| ) |  |

Convenience overload for calling the preconditioned BiCGStab solver using types from the C++ STL.

A std::vector<std::map<T, U> > matrix is convenient for e.g. finite element assembly. It is not the fastest option for setting up a system, but often it is fast enough - particularly for just trying things out.

Definition at line 647 of file gmres.hpp.

template<typename MatrixT , typename VectorT >

VectorT viennacl::linalg::solve | ( | MatrixT const & | A,
|  | VectorT const & | rhs,
|  | gmres_tag const & | tag
| ) |  |

Entry point for the unpreconditioned GMRES method.

Parameters

  A | The system matrix
  rhs | Right hand side vector (load vector)
  tag | A BiCGStab tag providing relative tolerances, etc.

Definition at line 670 of file gmres.hpp.

template<typename NumericT >

viennacl::scalar_expression< const viennacl::vector_base<NumericT>, const viennacl::vector_base<NumericT>, viennacl::op_sum > viennacl::linalg::sum | ( | viennacl::vector_base< NumericT > const & | x | ) |

User interface function for computing the sum of all elements of a vector.

Definition at line 45 of file sum.hpp.

template<typename LHS , typename RHS , typename OP >

viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, const viennacl::vector_expression<const LHS, const RHS, OP>, viennacl::op_sum> viennacl::linalg::sum | ( | viennacl::vector_expression< const LHS, const RHS, OP > const & | x | ) |

User interface function for computing the sum of all elements of a vector specified by a vector operation.

Typical use case: double my_sum = viennacl::linalg::sum(x + y);

Definition at line 60 of file sum.hpp.

template<typename T >

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

Computes the sum of a vector with final reduction on the CPU.

Parameters

  vec | The vector
  result | The result scalar

Definition at line 1102 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename S2 >

void viennacl::linalg::sum_cpu | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | S2 & | result
| ) |  |

Computes the sum of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 1132 of file vector_operations.hpp.

template<typename T >

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

template<typename LHS , typename RHS , typename OP , typename T >

void viennacl::linalg::sum_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | scalar< T > & | result
| ) |  |

template<typename NumericT >

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

Computes the sum of a vector with final reduction on the device (GPU, etc.)

Parameters

  vec | The vector
  result | The result scalar

Definition at line 1059 of file vector_operations.hpp.

template<typename LHS , typename RHS , typename OP , typename NumericT >

void viennacl::linalg::sum_impl | ( | viennacl::vector_expression< LHS, RHS, OP > const & | vec,
|  | viennacl::scalar< NumericT > & | result
| ) |  |

Computes the sum of a vector with final reduction on the CPU - interface for a vector expression. Creates a temporary.

Parameters

  vec | The vector expression
  result | The result scalar

Definition at line 1089 of file vector_operations.hpp.

template<typename SCALARTYPE , unsigned int ALIGNMENT>

void viennacl::linalg::svd | ( | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | A,
|  | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | QL,
|  | viennacl::matrix< SCALARTYPE, row_major, ALIGNMENT > & | QR
| ) |  |

Computes the singular value decomposition of a matrix A. Experimental in 1.3.x.

Parameters

  A | The input matrix. Will be overwritten with a diagonal matrix containing the singular values on return
  QL | The left orthogonal matrix
  QR | The right orthogonal matrix

Definition at line 492 of file svd.hpp.

template<typename S1 , typename S2 >

viennacl::enable_if< viennacl::is_scalar<S1>::value && viennacl::is_scalar<S2>::value >::type viennacl::linalg::swap | ( | S1 & | s1,
|  | S2 & | s2
| ) |  |

Swaps the contents of two scalars.

Parameters

  s1 | The first scalar
  s2 | The second scalar

Definition at line 213 of file scalar_operations.hpp.

template<typename SCALARTYPE , typename VectorType >

void viennacl::linalg::tql1 | ( | vcl_size_t | n,
|  | VectorType & | d,
|  | VectorType & | e
| ) |  |

Definition at line 41 of file tql2.hpp.

template<typename SCALARTYPE , typename VectorType , typename F >

void viennacl::linalg::tql2 | ( | matrix_base< SCALARTYPE, F > & | Q,
|  | VectorType & | d,
|  | VectorType & | e
| ) |  |

Examples:
  tql2.cpp.

Definition at line 131 of file tql2.hpp.

template<typename NumericT , typename SizeT , typename DistanceT >

void viennacl::linalg::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 83 of file matrix_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

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

Inplace_transpose matrix.

Examples:
  fft.cpp.

Definition at line 329 of file fft_operations.hpp.

template<typename NumericT , unsigned int AlignmentV>

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

Transpose matrix.

Definition at line 359 of file fft_operations.hpp.

template<typename T >

void viennacl::linalg::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 | Whether 'alpha' should be written to padded memory as well. This is used for setting all entries to zero, including padded memory.

Definition at line 187 of file vector_operations.hpp.

template<typename T >

void viennacl::linalg::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 218 of file vector_operations.hpp.

## Variable Documentation

const std::string viennacl::linalg::SVD_FINAL_ITER_UPDATE_KERNEL = "final_iter_update"

Definition at line 53 of file qr-method-common.hpp.

const std::string viennacl::linalg::SVD_GIVENS_PREV_KERNEL = "givens_prev"

Definition at line 52 of file qr-method-common.hpp.

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

Definition at line 55 of file qr-method-common.hpp.

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

Definition at line 56 of file qr-method-common.hpp.

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

Definition at line 57 of file qr-method-common.hpp.

const std::string viennacl::linalg::SVD_HOUSEHOLDER_UPDATE_QR_KERNEL = "house_update_QR"

Definition at line 49 of file qr-method-common.hpp.

const std::string viennacl::linalg::SVD_INVERSE_SIGNS_KERNEL = "inverse_signs"

Definition at line 51 of file qr-method-common.hpp.

const std::string viennacl::linalg::SVD_MATRIX_TRANSPOSE_KERNEL = "transpose_inplace"

Definition at line 50 of file qr-method-common.hpp.

const std::string viennacl::linalg::SVD_UPDATE_QR_COLUMN_KERNEL = "update_qr_column"

Definition at line 54 of file qr-method-common.hpp.