ViennaCL - The Vienna Computing Library: viennacl/forwards.h File Reference

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | 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 <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

## Enumerations
enum | viennacl::memory_types { viennacl::MEMORY_NOT_INITIALIZED, viennacl::MAIN_MEMORY, viennacl::OPENCL_MEMORY, viennacl::CUDA_MEMORY }
enum | viennacl::linalg::detail::row_info_types { viennacl::linalg::detail::SPARSE_ROW_NORM_INF = 0, viennacl::linalg::detail::SPARSE_ROW_NORM_1, viennacl::linalg::detail::SPARSE_ROW_NORM_2, viennacl::linalg::detail::SPARSE_ROW_DIAGONAL }

## 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)

## Detailed Description

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

Definition in file forwards.h.