This file provides the forward declarations for the main types used within ViennaCL. More...
#include <cstddef>#include <cassert>#include <string>#include <stdexcept>#include "viennacl/meta/enable_if.hpp"#include "viennacl/version.hpp"Go to the source code of this file.
| Classes | |
| struct | viennacl::op_assign | 
| A tag class representing assignment.  More... | |
| struct | viennacl::op_inplace_add | 
| A tag class representing inplace addition.  More... | |
| struct | viennacl::op_inplace_sub | 
| A tag class representing inplace subtraction.  More... | |
| struct | viennacl::op_add | 
| A tag class representing addition.  More... | |
| struct | viennacl::op_sub | 
| A tag class representing subtraction.  More... | |
| struct | viennacl::op_mult | 
| A tag class representing multiplication by a scalar.  More... | |
| struct | viennacl::op_prod | 
| A tag class representing matrix-vector products and element-wise multiplications.  More... | |
| struct | viennacl::op_mat_mat_prod | 
| A tag class representing matrix-matrix products.  More... | |
| struct | viennacl::op_div | 
| A tag class representing division.  More... | |
| struct | viennacl::op_pow | 
| A tag class representing the power function.  More... | |
| struct | viennacl::op_eq | 
| A tag class representing equality.  More... | |
| struct | viennacl::op_neq | 
| A tag class representing inequality.  More... | |
| struct | viennacl::op_greater | 
| A tag class representing greater-than.  More... | |
| struct | viennacl::op_less | 
| A tag class representing less-than.  More... | |
| struct | viennacl::op_geq | 
| A tag class representing greater-than-or-equal-to.  More... | |
| struct | viennacl::op_leq | 
| A tag class representing less-than-or-equal-to.  More... | |
| struct | viennacl::op_sum | 
| A tag class representing the summation of a vector.  More... | |
| struct | viennacl::op_row_sum | 
| A tag class representing the summation of all rows of a matrix.  More... | |
| struct | viennacl::op_col_sum | 
| A tag class representing the summation of all columns of a matrix.  More... | |
| struct | viennacl::op_element_cast< OP > | 
| A tag class representing element-wise casting operations on vectors and matrices.  More... | |
| struct | viennacl::op_element_binary< OP > | 
| A tag class representing element-wise binary operations (like multiplication) on vectors or matrices.  More... | |
| struct | viennacl::op_element_unary< OP > | 
| A tag class representing element-wise unary operations (like sin()) on vectors or matrices.  More... | |
| struct | viennacl::op_abs | 
| A tag class representing the modulus function for integers.  More... | |
| struct | viennacl::op_acos | 
| A tag class representing the acos() function.  More... | |
| struct | viennacl::op_asin | 
| A tag class representing the asin() function.  More... | |
| struct | viennacl::op_argmax | 
| A tag class for representing the argmax() function.  More... | |
| struct | viennacl::op_argmin | 
| A tag class for representing the argmin() function.  More... | |
| struct | viennacl::op_atan | 
| A tag class representing the atan() function.  More... | |
| struct | viennacl::op_atan2 | 
| A tag class representing the atan2() function.  More... | |
| struct | viennacl::op_ceil | 
| A tag class representing the ceil() function.  More... | |
| struct | viennacl::op_cos | 
| A tag class representing the cos() function.  More... | |
| struct | viennacl::op_cosh | 
| A tag class representing the cosh() function.  More... | |
| struct | viennacl::op_exp | 
| A tag class representing the exp() function.  More... | |
| struct | viennacl::op_fabs | 
| A tag class representing the fabs() function.  More... | |
| struct | viennacl::op_fdim | 
| A tag class representing the fdim() function.  More... | |
| struct | viennacl::op_floor | 
| A tag class representing the floor() function.  More... | |
| struct | viennacl::op_fmax | 
| A tag class representing the fmax() function.  More... | |
| struct | viennacl::op_fmin | 
| A tag class representing the fmin() function.  More... | |
| struct | viennacl::op_fmod | 
| A tag class representing the fmod() function.  More... | |
| struct | viennacl::op_log | 
| A tag class representing the log() function.  More... | |
| struct | viennacl::op_log10 | 
| A tag class representing the log10() function.  More... | |
| struct | viennacl::op_sin | 
| A tag class representing the sin() function.  More... | |
| struct | viennacl::op_sinh | 
| A tag class representing the sinh() function.  More... | |
| struct | viennacl::op_sqrt | 
| A tag class representing the sqrt() function.  More... | |
| struct | viennacl::op_tan | 
| A tag class representing the tan() function.  More... | |
| struct | viennacl::op_tanh | 
| A tag class representing the tanh() function.  More... | |
| struct | viennacl::op_matrix_diag | 
| A tag class representing the (off-)diagonal of a matrix.  More... | |
| struct | viennacl::op_vector_diag | 
| A tag class representing a matrix given by a vector placed on a certain (off-)diagonal.  More... | |
| struct | viennacl::op_row | 
| A tag class representing the extraction of a matrix row to a vector.  More... | |
| struct | viennacl::op_column | 
| A tag class representing the extraction of a matrix column to a vector.  More... | |
| struct | viennacl::op_inner_prod | 
| A tag class representing inner products of two vectors.  More... | |
| struct | viennacl::op_norm_1 | 
| A tag class representing the 1-norm of a vector.  More... | |
| struct | viennacl::op_norm_2 | 
| A tag class representing the 2-norm of a vector.  More... | |
| struct | viennacl::op_norm_inf | 
| A tag class representing the inf-norm of a vector.  More... | |
| struct | viennacl::op_max | 
| A tag class representing the maximum of a vector.  More... | |
| struct | viennacl::op_min | 
| A tag class representing the minimum of a vector.  More... | |
| struct | viennacl::op_norm_frobenius | 
| A tag class representing the Frobenius-norm of a matrix.  More... | |
| struct | viennacl::op_trans | 
| A tag class representing transposed matrices.  More... | |
| struct | viennacl::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 | viennacl::scalar< TYPE > | 
| 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 | viennacl::scalar_expression< LHS, RHS, OP > | 
| A proxy for scalar expressions (e.g. from inner vector products)  More... | |
| class | viennacl::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 | viennacl::const_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 | viennacl::vector_expression< LHS, RHS, OP > | 
| An expression template class that represents a binary operation that yields a vector.  More... | |
| class | viennacl::vector_iterator< SCALARTYPE, ALIGNMENT > | 
| A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!!  More... | |
| class | viennacl::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 | viennacl::implicit_vector_base< NumericT > | 
| Common base class for representing vectors where the entries are not all stored explicitly.  More... | |
| struct | viennacl::zero_vector< NumericT > | 
| struct | viennacl::unit_vector< NumericT > | 
| Represents a vector consisting of 1 at a given index and zeros otherwise.  More... | |
| struct | viennacl::one_vector< SCALARTYPE > | 
| struct | viennacl::scalar_vector< NumericT > | 
| 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 | viennacl::vector_base< NumericT, SizeT, DistanceT > | 
| Common base class for dense vectors, vector ranges, and vector slices.  More... | |
| class | viennacl::vector< SCALARTYPE, ALIGNMENT > | 
| class | viennacl::vector_tuple< ScalarT > | 
| Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie().  More... | |
| struct | viennacl::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 | viennacl::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 | viennacl::row_major | 
| A tag for row-major storage of a dense matrix.  More... | |
| struct | viennacl::column_major | 
| A tag for column-major storage of a dense matrix.  More... | |
| class | viennacl::matrix_expression< LHS, RHS, OP > | 
| Expression template class for representing a tree of expressions which ultimately result in a matrix.  More... | |
| class | viennacl::matrix_iterator< ROWCOL, MATRIXTYPE > | 
| A dense matrix class.  More... | |
| class | viennacl::matrix_base< NumericT, SizeT, DistanceT > | 
| class | viennacl::matrix< SCALARTYPE, F, ALIGNMENT > | 
| A dense matrix class.  More... | |
| class | viennacl::implicit_matrix_base< NumericT > | 
| Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<>  More... | |
| class | viennacl::identity_matrix< NumericT > | 
| 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 | viennacl::zero_matrix< NumericT > | 
| Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only.  More... | |
| class | viennacl::scalar_matrix< NumericT > | 
| 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 | viennacl::compressed_matrix< NumericT, AlignmentV > | 
| A sparse square matrix in compressed sparse rows format.  More... | |
| class | viennacl::compressed_compressed_matrix< NumericT > | 
| A sparse square matrix in compressed sparse rows format optimized for the case that only a few rows carry nonzero entries.  More... | |
| class | viennacl::coordinate_matrix< NumericT, AlignmentV > | 
| 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... | |
| class | viennacl::ell_matrix< NumericT, AlignmentV > | 
| Sparse matrix class using the ELLPACK format for storing the nonzeros.  More... | |
| class | viennacl::sliced_ell_matrix< ScalarT, IndexT > | 
| Sparse matrix class using the sliced ELLPACK with parameters C,  .  More... | |
| class | viennacl::hyb_matrix< SCALARTYPE, ALIGNMENT > | 
| Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros.  More... | |
| class | viennacl::circulant_matrix< NumericT, AlignmentV > | 
| A Circulant matrix class.  More... | |
| class | viennacl::hankel_matrix< SCALARTYPE, ALIGNMENT > | 
| A Hankel matrix class.  More... | |
| class | viennacl::toeplitz_matrix< SCALARTYPE, ALIGNMENT > | 
| A Toeplitz matrix class.  More... | |
| class | viennacl::vandermonde_matrix< SCALARTYPE, ALIGNMENT > | 
| A Vandermonde matrix class.  More... | |
| class | viennacl::basic_range< SizeType, DistanceType > | 
| A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.  More... | |
| class | viennacl::basic_slice< SizeType, DistanceType > | 
| A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.  More... | |
| class | viennacl::vector_range< VectorType > | 
| Class for representing non-strided subvectors of a bigger vector x.  More... | |
| class | viennacl::vector_slice< VectorType > | 
| Class for representing strided subvectors of a bigger vector x.  More... | |
| class | viennacl::matrix_range< MatrixType > | 
| Class for representing non-strided submatrices of a bigger matrix A.  More... | |
| class | viennacl::matrix_slice< MatrixType > | 
| Class for representing strided submatrices of a bigger matrix A.  More... | |
| struct | viennacl::is_cpu_scalar< T > | 
| Helper struct for checking whether a type is a host scalar type (e.g. float, double)  More... | |
| struct | viennacl::is_scalar< T > | 
| Helper struct for checking whether a type is a viennacl::scalar<>  More... | |
| struct | viennacl::is_flip_sign_scalar< T > | 
| Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<>  More... | |
| struct | viennacl::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 | viennacl::is_any_vector< T > | 
| Checks for a type being either vector_base or implicit_vector_base.  More... | |
| struct | viennacl::is_any_dense_matrix< T > | 
| Checks for either matrix_base or implicit_matrix_base.  More... | |
| struct | viennacl::is_row_major< T > | 
| Helper class for checking whether a matrix has a row-major layout.  More... | |
| struct | viennacl::is_compressed_matrix< T > | 
| Helper class for checking whether a matrix is a compressed_matrix (CSR format)  More... | |
| struct | viennacl::is_coordinate_matrix< T > | 
| Helper class for checking whether a matrix is a coordinate_matrix (COO format)  More... | |
| struct | viennacl::is_ell_matrix< T > | 
| Helper class for checking whether a matrix is an ell_matrix (ELL format)  More... | |
| struct | viennacl::is_sliced_ell_matrix< T > | 
| Helper class for checking whether a matrix is a sliced_ell_matrix (SELL-C-  format)  More... | |
| struct | viennacl::is_hyb_matrix< T > | 
| Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR)  More... | |
| struct | viennacl::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 | viennacl::is_circulant_matrix< T > | 
| Helper class for checking whether a matrix is a circulant matrix.  More... | |
| struct | viennacl::is_hankel_matrix< T > | 
| Helper class for checking whether a matrix is a Hankel matrix.  More... | |
| struct | viennacl::is_toeplitz_matrix< T > | 
| Helper class for checking whether a matrix is a Toeplitz matrix.  More... | |
| struct | viennacl::is_vandermonde_matrix< T > | 
| Helper class for checking whether a matrix is a Vandermonde matrix.  More... | |
| struct | viennacl::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 | viennacl::memory_exception | 
| Exception class in case of memory errors.  More... | |
| class | viennacl::cuda_not_available_exception | 
| class | viennacl::zero_on_diagonal_exception | 
| class | viennacl::unknown_norm_exception | 
| struct | viennacl::tools::MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE > | 
| Helper class for incrementing an iterator in a dense matrix.  More... | |
| struct | viennacl::linalg::lower_tag | 
| A tag class representing a lower triangular matrix.  More... | |
| struct | viennacl::linalg::upper_tag | 
| A tag class representing an upper triangular matrix.  More... | |
| struct | viennacl::linalg::unit_lower_tag | 
| A tag class representing a lower triangular matrix with unit diagonal.  More... | |
| struct | viennacl::linalg::unit_upper_tag | 
| A tag class representing an upper triangular matrix with unit diagonal.  More... | |
| class | viennacl::linalg::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::backend | |
| Namespace providing routines for handling the different memory domains. | |
| 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::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::device_specific | |
| Provides an OpenCL kernel generator. | |
| viennacl::device_specific::autotune | |
| Provides the implementation for tuning the kernels for a particular device. | |
| viennacl::device_specific::detail | |
| Contains implementation details of the kernel generator. | |
| viennacl::device_specific::profiles | |
| Namespace holding the various device-specific parameters for generating the best kernels. | |
| viennacl::device_specific::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 | viennacl::vcl_size_t | 
| typedef std::ptrdiff_t | viennacl::vcl_ptrdiff_t | 
| typedef basic_range | viennacl::range | 
| typedef basic_slice | viennacl::slice | 
| Functions | |
| template<typename SCALARTYPE , unsigned int ALIGNMENT, typename CPU_ITERATOR > | |
| void | viennacl::copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< SCALARTYPE, ALIGNMENT > gpu_begin) | 
| template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST> | |
| void | viennacl::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) | 
| template<typename SCALARTYPE , unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST> | |
| void | viennacl::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 | viennacl::fast_copy (const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin) | 
| template<typename CPU_ITERATOR , typename SCALARTYPE , unsigned int ALIGNMENT> | |
| void | viennacl::fast_copy (CPU_ITERATOR const &cpu_begin, CPU_ITERATOR const &cpu_end, vector_iterator< SCALARTYPE, ALIGNMENT > gpu_begin) | 
| 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 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 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 > | |
| 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.  More... | |
| 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) | 
| 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) | 
| 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) | 
| 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.  More... | |
| 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) | 
| 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) | 
| 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) | 
| 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.  More... | |
| 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 > | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| template<typename T > | |
| void | viennacl::linalg::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 | 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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 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.  More... | |
| 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.  More... | |
| 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 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.  More... | |
| 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.  More... | |
| 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 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  More... | |
| 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.  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 | viennacl::linalg::prod_impl (const SparseMatrixType &mat, const vector< SCALARTYPE, ALIGNMENT > &vec) | 
| template<typename NumericT > | |
| void | viennacl::linalg::row_sum_impl (const matrix_base< NumericT > &A, vector_base< NumericT > &result) | 
| template<typename NumericT > | |
| void | viennacl::linalg::column_sum_impl (const matrix_base< NumericT > &A, vector_base< NumericT > &result) | 
This file provides the forward declarations for the main types used within ViennaCL.
Definition in file forwards.h.