ViennaCL - The Vienna Computing Library  1.5.2
Data Structures | Namespaces | Typedefs | Enumerations | Functions
forwards.h File Reference

This file provides the forward declarations for the main types used within ViennaCL. More...

#include <cstddef>
#include <cassert>
#include <string>
#include "viennacl/meta/enable_if.hpp"

Go to the source code of this file.

Data Structures

struct  op_assign
 A tag class representing assignment. More...
 
struct  op_inplace_add
 A tag class representing inplace addition. More...
 
struct  op_inplace_sub
 A tag class representing inplace subtraction. More...
 
struct  op_add
 A tag class representing addition. More...
 
struct  op_sub
 A tag class representing subtraction. More...
 
struct  op_mult
 A tag class representing multiplication by a scalar. More...
 
struct  op_prod
 A tag class representing matrix-vector products and element-wise multiplications. More...
 
struct  op_mat_mat_prod
 A tag class representing matrix-matrix products. More...
 
struct  op_div
 A tag class representing division. More...
 
struct  op_pow
 A tag class representing the power function. More...
 
struct  op_element_binary< OP >
 A tag class representing element-wise binary operations (like multiplication) on vectors or matrices. More...
 
struct  op_element_unary< OP >
 A tag class representing element-wise unary operations (like sin()) on vectors or matrices. More...
 
struct  op_abs
 A tag class representing the modulus function for integers. More...
 
struct  op_acos
 A tag class representing the acos() function. More...
 
struct  op_asin
 A tag class representing the asin() function. More...
 
struct  op_atan
 A tag class representing the atan() function. More...
 
struct  op_atan2
 A tag class representing the atan2() function. More...
 
struct  op_ceil
 A tag class representing the ceil() function. More...
 
struct  op_cos
 A tag class representing the cos() function. More...
 
struct  op_cosh
 A tag class representing the cosh() function. More...
 
struct  op_exp
 A tag class representing the exp() function. More...
 
struct  op_fabs
 A tag class representing the fabs() function. More...
 
struct  op_fdim
 A tag class representing the fdim() function. More...
 
struct  op_floor
 A tag class representing the floor() function. More...
 
struct  op_fmax
 A tag class representing the fmax() function. More...
 
struct  op_fmin
 A tag class representing the fmin() function. More...
 
struct  op_fmod
 A tag class representing the fmod() function. More...
 
struct  op_log
 A tag class representing the log() function. More...
 
struct  op_log10
 A tag class representing the log10() function. More...
 
struct  op_sin
 A tag class representing the sin() function. More...
 
struct  op_sinh
 A tag class representing the sinh() function. More...
 
struct  op_sqrt
 A tag class representing the sqrt() function. More...
 
struct  op_tan
 A tag class representing the tan() function. More...
 
struct  op_tanh
 A tag class representing the tanh() function. More...
 
struct  op_matrix_diag
 A tag class representing the (off-)diagonal of a matrix. More...
 
struct  op_vector_diag
 A tag class representing a matrix given by a vector placed on a certain (off-)diagonal. More...
 
struct  op_row
 A tag class representing the extraction of a matrix row to a vector. More...
 
struct  op_column
 A tag class representing the extraction of a matrix column to a vector. More...
 
struct  op_inner_prod
 A tag class representing inner products of two vectors. More...
 
struct  op_norm_1
 A tag class representing the 1-norm of a vector. More...
 
struct  op_norm_2
 A tag class representing the 2-norm of a vector. More...
 
struct  op_norm_inf
 A tag class representing the inf-norm of a vector. More...
 
struct  op_norm_frobenius
 A tag class representing the Frobenius-norm of a matrix. More...
 
struct  op_trans
 A tag class representing transposed matrices. More...
 
struct  op_flip_sign
 A tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0) More...
 
class  scalar< SCALARTYPE >
 This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type like float or double. More...
 
class  scalar_expression< LHS, RHS, OP >
 A proxy for scalar expressions (e.g. from inner vector products) More...
 
class  entry_proxy< SCALARTYPE >
 A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-users of the library. More...
 
class  vector_expression< LHS, RHS, OP >
 An expression template class that represents a binary operation that yields a vector. More...
 
class  vector_iterator< SCALARTYPE, ALIGNMENT >
 A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! More...
 
class  const_vector_iterator< SCALARTYPE, ALIGNMENT >
 A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!! More...
 
class  implicit_vector_base< SCALARTYPE >
 Common base class for representing vectors where the entries are not all stored explicitly. More...
 
class  zero_vector< SCALARTYPE >
 Represents a vector consisting of zeros only. More...
 
class  unit_vector< SCALARTYPE >
 Represents a vector consisting of 1 at a given index and zeros otherwise. More...
 
class  one_vector< SCALARTYPE >
 Represents a vector consisting of ones only. More...
 
class  scalar_vector< SCALARTYPE >
 Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
 
class  vector_base< SCALARTYPE, SizeType, DistanceType >
 Common base class for dense vectors, vector ranges, and vector slices. More...
 
class  vector< SCALARTYPE, ALIGNMENT >
 A vector class representing a linear memory sequence on the GPU. Inspired by boost::numeric::ublas::vector. More...
 
class  vector_tuple< ScalarT >
 Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie(). More...
 
struct  row_major_tag
 Tag class for indicating row-major layout of a matrix. Not passed to the matrix directly, see row_major type. More...
 
struct  column_major_tag
 Tag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type. More...
 
struct  row_major
 A tag for row-major storage of a dense matrix. More...
 
struct  column_major
 A tag for column-major storage of a dense matrix. More...
 
class  matrix_expression< LHS, RHS, OP >
 Expression template class for representing a tree of expressions which ultimately result in a matrix. More...
 
class  matrix_base< SCALARTYPE, F, SizeType, DistanceType >
 A dense matrix class. More...
 
class  matrix< SCALARTYPE, F, ALIGNMENT >
 A dense matrix class. More...
 
class  implicit_matrix_base< SCALARTYPE >
 Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<> More...
 
class  identity_matrix< SCALARTYPE >
 Represents a vector consisting of 1 at a given index and zeros otherwise. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
 
class  zero_matrix< SCALARTYPE >
 Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
 
class  scalar_matrix< SCALARTYPE >
 Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only. More...
 
singleton  compressed_matrix< SCALARTYPE, ALIGNMENT >
 A sparse square matrix in compressed sparse rows format. More...
 
singleton  compressed_compressed_matrix< SCALARTYPE >
 A sparse square matrix in compressed sparse rows format optimized for the case that only a few rows carry nonzero entries. More...
 
singleton  coordinate_matrix< SCALARTYPE, ALIGNMENT >
 A sparse square matrix, where entries are stored as triplets (i,j, val), where i and j are the row and column indices and val denotes the entry. More...
 
singleton  ell_matrix< SCALARTYPE, ALIGNMENT >
 Sparse matrix class using the ELLPACK format for storing the nonzeros. More...
 
class  hyb_matrix< SCALARTYPE, ALIGNMENT >
 Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros. More...
 
singleton  circulant_matrix< SCALARTYPE, ALIGNMENT >
 A Circulant matrix class. More...
 
class  hankel_matrix< SCALARTYPE, ALIGNMENT >
 A Hankel matrix class. More...
 
class  toeplitz_matrix< SCALARTYPE, ALIGNMENT >
 A Toeplitz matrix class. More...
 
class  vandermonde_matrix< SCALARTYPE, ALIGNMENT >
 A Vandermonde matrix class. More...
 
class  basic_range< SizeType, DistanceType >
 A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded. More...
 
class  basic_slice< SizeType, DistanceType >
 A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded. More...
 
class  vector_range< VectorType >
 Class for representing non-strided subvectors of a bigger vector x. More...
 
class  vector_slice< VectorType >
 Class for representing strided subvectors of a bigger vector x. More...
 
class  matrix_range< MatrixType >
 Class for representing non-strided submatrices of a bigger matrix A. More...
 
class  matrix_slice< MatrixType >
 Class for representing strided submatrices of a bigger matrix A. More...
 
struct  is_cpu_scalar< T >
 Helper struct for checking whether a type is a host scalar type (e.g. float, double) More...
 
struct  is_scalar< T >
 Helper struct for checking whether a type is a viennacl::scalar<> More...
 
struct  is_flip_sign_scalar< T >
 Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<> More...
 
struct  is_any_scalar< T >
 Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy) More...
 
struct  is_any_vector< T >
 Checks for a type being either vector_base or implicit_vector_base. More...
 
struct  is_any_dense_matrix< T >
 Checks for either matrix_base or implicit_matrix_base. More...
 
struct  is_row_major< T >
 Helper class for checking whether a matrix has a row-major layout. More...
 
struct  is_compressed_matrix< T >
 Helper class for checking whether a matrix is a compressed_matrix (CSR format) More...
 
struct  is_coordinate_matrix< T >
 Helper class for checking whether a matrix is a coordinate_matrix (COO format) More...
 
struct  is_ell_matrix< T >
 Helper class for checking whether a matrix is an ell_matrix (ELL format) More...
 
struct  is_hyb_matrix< T >
 Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR) More...
 
struct  is_any_sparse_matrix< T >
 Helper class for checking whether the provided type is one of the sparse matrix types (compressed_matrix, coordinate_matrix, etc.) More...
 
struct  is_circulant_matrix< T >
 Helper class for checking whether a matrix is a circulant matrix. More...
 
struct  is_hankel_matrix< T >
 Helper class for checking whether a matrix is a Hankel matrix. More...
 
struct  is_toeplitz_matrix< T >
 Helper class for checking whether a matrix is a Toeplitz matrix. More...
 
struct  is_vandermonde_matrix< T >
 Helper class for checking whether a matrix is a Vandermonde matrix. More...
 
struct  is_any_dense_structured_matrix< T >
 Helper class for checking whether the provided type is any of the dense structured matrix types (circulant, Hankel, etc.) More...
 
class  memory_exception
 Exception class in case of memory errors. More...
 
class  cuda_not_available_exception
 
struct  MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE >
 Helper class for incrementing an iterator in a dense matrix. More...
 
struct  lower_tag
 A tag class representing a lower triangular matrix. More...
 
struct  upper_tag
 A tag class representing an upper triangular 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...
 
class  no_precond
 A tag class representing the use of no preconditioner. More...
 

Namespaces

 viennacl
 Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.
 
 viennacl::tools
 Namespace for various tools used within ViennaCL.
 
 viennacl::linalg
 Provides all linear algebra operations which are not covered by operator overloads.
 
 viennacl::linalg::detail
 Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user.
 
 viennacl::backend
 Namespace providing routines for handling the different memory domains.
 
 viennacl::backend::cpu_ram
 Provides implementations for handling memory buffers in CPU RAM.
 
 viennacl::backend::cpu_ram::detail
 Holds implementation details for handling memory buffers in CPU RAM. Not intended for direct use by library users.
 
 viennacl::backend::cuda
 Provides implementations for handling CUDA memory buffers.
 
 viennacl::backend::cuda::detail
 Holds implementation details for handling CUDA memory buffers. Not intended for direct use by library users.
 
 viennacl::backend::detail
 Implementation details for the generic memory backend interface.
 
 viennacl::backend::opencl
 Provides implementations for handling OpenCL memory buffers.
 
 viennacl::backend::opencl::detail
 Holds implementation details for handling OpenCL memory buffers. Not intended for direct use by library users.
 
 viennacl::detail
 Holds implementation details for functionality in the main viennacl-namespace. Not intended for direct use by library users.
 
 viennacl::detail::fft
 Helper namespace for fast Fourier transforms. Not to be used directly by library users.
 
 viennacl::detail::fft::FFT_DATA_ORDER
 Helper namespace for fast-Fourier transformation. Deprecated.
 
 viennacl::generator
 Provides an OpenCL kernel generator.
 
 viennacl::generator::autotune
 Provides the implementation for tuning the kernels for a particular device.
 
 viennacl::generator::detail
 Contains implementation details of the kernel generator.
 
 viennacl::generator::profiles
 Namespace holding the various device-specific parameters for generating the best kernels.
 
 viennacl::generator::utils
 Contains various helper routines for kernel generation.
 
 viennacl::io
 Provides basic input-output functionality.
 
 viennacl::io::detail
 Implementation details for IO functionality. Usually not of interest for a library user.
 
 viennacl::io::tag
 Namespace holding the various XML tag definitions for the kernel parameter tuning facility.
 
 viennacl::io::val
 Namespace holding the various XML strings for the kernel parameter tuning facility.
 
 viennacl::linalg::cuda
 Holds all CUDA compute kernels used by ViennaCL.
 
 viennacl::linalg::cuda::detail
 Helper functions for the CUDA linear algebra backend.
 
 viennacl::linalg::detail::amg
 Implementation namespace for algebraic multigrid preconditioner.
 
 viennacl::linalg::detail::spai
 Implementation namespace for sparse approximate inverse preconditioner.
 
 viennacl::linalg::host_based
 Holds all compute kernels with conventional host-based execution (buffers in CPU RAM).
 
 viennacl::linalg::host_based::detail
 Helper functions for the host-based linear algebra backend.
 
 viennacl::linalg::kernels
 Namespace containing the OpenCL kernels. Deprecated, will be moved to viennacl::linalg::opencl in future releases.
 
 viennacl::linalg::opencl
 Holds all routines providing OpenCL linear algebra operations.
 
 viennacl::linalg::opencl::detail
 Helper functions for OpenCL-accelerated linear algebra operations.
 
 viennacl::linalg::opencl::kernels
 Contains the OpenCL kernel generation functions for a predefined set of functionality.
 
 viennacl::linalg::opencl::kernels::detail
 Implementation details for the predefined OpenCL kernels.
 
 viennacl::ocl
 OpenCL backend. Manages platforms, contexts, buffers, kernels, etc.
 
 viennacl::result_of
 Namespace containing many meta-functions.
 
 viennacl::tools::detail
 Contains implementation details for the tools. Usually not of interest for the library user.
 
 viennacl::traits
 Namespace providing traits-information as well as generic wrappers to common routines for vectors and matrices such as size() or clear()
 
 viennacl::scheduler
 Contains the scheduling functionality which allows for dynamic kernel generation as well as the fusion of multiple statements into a single kernel.
 
 viennacl::scheduler::detail
 Implementation details for the scheduler.
 
 viennacl::scheduler::result_of
 Helper metafunctions used for the scheduler.
 

Typedefs

typedef std::size_t vcl_size_t
 
typedef std::ptrdiff_t vcl_ptrdiff_t
 
typedef basic_range range
 
typedef basic_slice slice
 

Enumerations

enum  memory_types { MEMORY_NOT_INITIALIZED, MAIN_MEMORY, OPENCL_MEMORY, CUDA_MEMORY }
 
enum  row_info_types { SPARSE_ROW_NORM_INF = 0, SPARSE_ROW_NORM_1, SPARSE_ROW_NORM_2, SPARSE_ROW_DIAGONAL }
 

Functions

template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >
void copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< SCALARTYPE, ALIGNMENT > gpu_begin)
 STL-like transfer for the entries of a GPU vector to the CPU. The cpu type does not need to lie in a linear piece of memory. More...
 
template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
void copy (const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_begin, const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_end, vector_iterator< SCALARTYPE, ALIGNMENT_DEST > gpu_dest_begin)
 Copy (parts of a) GPU vector to another GPU vector. More...
 
template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
void copy (const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_begin, const_vector_iterator< SCALARTYPE, ALIGNMENT_SRC > const &gpu_src_end, const_vector_iterator< SCALARTYPE, ALIGNMENT_DEST > gpu_dest_begin)
 
template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR >
void fast_copy (const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)
 STL-like transfer of a GPU vector to the CPU. The cpu type is assumed to reside in a linear piece of memory, such as e.g. for std::vector. More...
 
template<typename CPU_ITERATOR , typename SCALARTYPE , unsigned int ALIGNMENT>
void fast_copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< SCALARTYPE, ALIGNMENT > gpu_begin)
 STL-like transfer of a CPU vector to the GPU. The cpu type is assumed to reside in a linear piece of memory, such as e.g. for std::vector. More...
 
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 , typename F >
void norm_frobenius_impl (matrix_base< T, F > const &A, scalar< T > &result)
 Computes the Frobenius norm of a matrix - dispatcher interface. More...
 
template<typename T , typename F >
void norm_frobenius_cpu (matrix_base< T, F > 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 , typename F >
void prod_impl (const matrix_base< NumericT, F > &mat, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
 Carries out matrix-vector multiplication. More...
 
template<typename NumericT , typename F >
void prod_impl (const matrix_expression< const matrix_base< NumericT, F >, const matrix_base< NumericT, F >, op_trans > &mat_trans, const vector_base< NumericT > &vec, vector_base< NumericT > &result)
 Carries out matrix-vector multiplication with a transposed matrix. 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)
 

Detailed Description

This file provides the forward declarations for the main types used within ViennaCL.