ViennaCL - The Vienna Computing Library  1.6.2
Free open-source GPU-accelerated linear algebra and solver library.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 Cviennacl::ocl::accelerator_tagA tag identifying OpenCL devices as accelerators (e.g. Intel Xeon Phi)
 Cviennacl::advanced_cuthill_mckee_tagTag for the advanced Cuthill-McKee algorithm (i.e. running the 'standard' Cuthill-McKee algorithm for a couple of different seeds)
 Cviennacl::result_of::alignment< T >Retrieves the alignment from a vector. Deprecated - will be replaced by a pure runtime facility in the future
 Cviennacl::linalg::opencl::kernels::ambm_configConfiguration struct for generating OpenCL kernels for linear combinations of matrices
 Cviennacl::linalg::detail::amg::amg_nonzero_scalar< InternalT, IteratorT, NumericT >A class for a scalar that can be written to the sparse matrix or sparse vector datatypes
 Cviennacl::linalg::detail::amg::amg_pointA class for the AMG points. Saves point index and influence measure Holds information whether point is undecided, C or F point. Holds lists of points that are influenced by or influencing this point
 Cviennacl::linalg::detail::amg::amg_pointvectorA class for the AMG points. Holds pointers of type amg_point in a vector that can be accessed using [point-index]. Additional list of pointers sorted by influence number and index to improve coarsening performance (see amg_coarse_classic_onepass() in amg_coarse.hpp) Constructs indices for C points on the coarse level, needed for interpolation
 Cviennacl::linalg::amg_precond< MatrixT >AMG preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::amg_precond< compressed_matrix< NumericT, AlignmentV > >AMG preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::detail::amg::amg_slicing< InternalT1, InternalT2 >A class for the matrix slicing for parallel coarsening schemes (RS0/RS3)
 Cviennacl::linalg::detail::amg::amg_sparsematrix< NumericT >A class for the sparse matrix type. Uses vector of maps as data structure for higher performance and lower memory usage. Uses similar interface as ublas::compressed_matrix. Can deal with transposed of matrix internally: Creation, Storage, Iterators, etc
 Cviennacl::linalg::detail::amg::amg_sparsevector< NumericT >A class for the sparse vector type
 Cviennacl::linalg::detail::amg::amg_sparsevector< amg_point * >
 Cviennacl::linalg::detail::amg::amg_sparsevector_iterator< InternalT >Defines an iterator for the sparse vector type
 Cviennacl::linalg::detail::amg::amg_tagA tag for algebraic multigrid (AMG). Used to transport information from the user to the implementation
 Cviennacl::backend::cpu_ram::detail::array_deleter< U >Helper struct for deleting an pointer to an array
 Cviennacl::linalg::opencl::kernels::asbs_configConfiguration struct for generating OpenCL kernels for linear combinations of viennacl::scalar<> objects
 Cviennacl::tools::detail::auxInterface for the reference counter inside the shared_ptr
 Cviennacl::ocl::backend< dummy >A backend that provides contexts for ViennaCL objects (vector, matrix, etc.)
 Cviennacl::basic_range< SizeType, DistanceType >A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded
 Cviennacl::basic_slice< SizeType, DistanceType >A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded
 Cviennacl::linalg::bicgstab_tagA tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function
 Cviennacl::device_specific::binary_leafBinary leaf interface
 Cviennacl::linalg::opencl::kernels::bisect_kernel< NumericT >Main kernel class for the generation of the bisection kernels and utilities
 Cviennacl::linalg::block_ilu_precond< MatrixT, ILUTag >A block ILU preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::block_ilu_precond< compressed_matrix< NumericT, AlignmentV >, ILUTagT >ILUT preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::detail::spai::block_matrixRepresents contigious matrices on GPU
 Cviennacl::linalg::detail::spai::block_vectorRepresents a contiguous vector on the GPU to represent a concatentation of small vectors
 Cviennacl::linalg::cg_tagA tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function
 Cviennacl::device_specific::char_to_type< C >
 Cviennacl::tools::CHECK_SCALAR_TEMPLATE_ARGUMENT< T >A guard that checks whether the floating point type of GPU types is either float or double
 Cviennacl::circulant_matrix< NumericT, AlignmentV >A Circulant matrix class
 Cviennacl::result_of::cl_type< T >Metafunction for deducing the OpenCL type for a numeric type, e.g. float -> cl_float
 Cviennacl::linalg::detail::amg::classcompComparison class for the sorted set of points in amg_pointvector. Set is sorted by influence measure from lower to higher with the point-index as tie-breaker
 Cviennacl::col_iterationA tag indicating iteration along increasing columns index of a matrix
 Cviennacl::column_majorA tag for column-major storage of a dense matrix
 Cviennacl::column_major_tagTag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type
 Cviennacl::ocl::command_queueA class representing a command queue
 Cviennacl::linalg::detail::spai::CompareSecondHelper functor for comparing std::pair<> based on the second member
 Cviennacl::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
 Cviennacl::linalg::opencl::kernels::compressed_compressed_matrix< NumericT >Main kernel class for generating OpenCL kernels for compressed_compressed_matrix
 Cviennacl::compressed_matrix< NumericT, AlignmentV >A sparse square matrix in compressed sparse rows format
 Cviennacl::linalg::opencl::kernels::compressed_matrix< NumericT >Main kernel class for generating OpenCL kernels for compressed_matrix
 Cviennacl::compressed_matrix< double >
 Cviennacl::compressed_matrix< float >
 Cviennacl::compressed_matrix< NumericT >
 Cviennacl::compressed_matrix< NumericType >
 Cviennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT >
 Cviennacl::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
 Cviennacl::tools::CONST_REMOVER< T >Removes the const qualifier from a type
 Cviennacl::tools::const_sparse_matrix_adapted_iterator< NumericT, SizeT, is_iterator1, is_forward >A const iterator for sparse matrices of type std::vector<std::map<SizeT, NumericT> >
 Cviennacl::tools::const_sparse_matrix_adapter< NumericT, SizeT >Adapts a constant sparse matrix type made up from std::vector<std::map<SizeT, NumericT> > to basic ublas-compatibility
 Cviennacl::const_vector_iterator< SCALARTYPE, ALIGNMENT >A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!!
 Cviennacl::const_vector_iterator< NumericT, AlignmentV >
 Cviennacl::contextRepresents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also suitable for CUDA and OpenMP
 Cviennacl::ocl::contextManages an OpenCL context and provides the respective convenience functions for creating buffers, etc
 Cviennacl::backend::detail::convert_to_opencl< T >Helper struct for converting a type to its OpenCL pendant
 Cviennacl::linalg::opencl::kernels::coordinate_matrix< NumericT >Main kernel class for generating OpenCL kernels for coordinate_matrix
 Cviennacl::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
 Cviennacl::coordinate_matrix< double >
 Cviennacl::coordinate_matrix< float >
 Cviennacl::tools::detail::countReference counting class for the shared_ptr implementation
 Cviennacl::tools::CPU_SCALAR_TYPE_DEDUCER< T >Obtain the cpu scalar type from a type, including a GPU type like viennacl::scalar<T>
 Cviennacl::ocl::cpu_tagA tag identifying OpenCL devices as CPUs
 Cviennacl::result_of::cpu_value_type< T >Helper meta function for retrieving the main RAM-based value type. Particularly important to obtain T from viennacl::scalar<T> in a generic way
 Cviennacl::backend::cuda::detail::cuda_deleter< U >Functor for deleting a CUDA handle. Used within the smart pointer class
 Cviennacl::cuthill_mckee_tagA tag class for selecting the Cuthill-McKee algorithm for reducing the bandwidth of a sparse matrix
 Cviennacl::device_specific::builtin_database::database_type< ParamT >
 Cviennacl::tools::detail::default_deleter< U >Default deleter class for a pointer. The default is to just call 'delete' on the pointer. Provide your own implementations for 'delete[]' and 'free'
 Cviennacl::ocl::default_tagA tag denoting the default OpenCL device type (SDK-specific)
 Cdense_matrix< T >
 Cviennacl::ocl::deviceA class representing a compute device (e.g. a GPU)
 Cviennacl::device_specific::builtin_database::database_type< ParamT >::device_architecture_t
 Cviennacl::device_specific::builtin_database::database_type< ParamT >::device_name_t
 Cviennacl::device_specific::builtin_database::database_type< ParamT >::device_type_t
 Cviennacl::ocl::DOUBLE_PRECISION_CHECKER< ScalarType >Ensures that double precision types are only allocated if it is supported by the device. If double precision is requested for a device not capable of providing that, a double_precision_not_provided_error is thrown
 Cviennacl::linalg::opencl::kernels::ell_matrix< NumericT >Main kernel class for generating OpenCL kernels for ell_matrix
 Cviennacl::ell_matrix< NumericT, AlignmentV >Sparse matrix class using the ELLPACK format for storing the nonzeros
 Cviennacl::ell_matrix< double >
 Cviennacl::ell_matrix< float >
 Cviennacl::enable_if< b, T >Simple enable-if variant that uses the SFINAE pattern
 Cviennacl::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
 Cviennacl::ocl::error_checker< T >An error reporting class. Template argument is used to avoid problems with external linkage
 Cexception
 Cviennacl::device_specific::execution_handler
 Cviennacl::device_specific::builtin_database::database_type< ParamT >::expression_t
 Cviennacl::linalg::detail::FastMatrix< SCALARTYPE >Internal helper class representing a row-major dense matrix used for the QR method for the purpose of computing eigenvalues
 Cviennacl::linalg::opencl::kernels::fft< NumericT >Main kernel class for generating OpenCL kernels for the fast Fourier transform
 Cviennacl::device_specific::utils::first_letter_of_type< T >
 Cviennacl::device_specific::utils::first_letter_of_type< char >
 Cviennacl::device_specific::utils::first_letter_of_type< double >
 Cviennacl::device_specific::utils::first_letter_of_type< float >
 Cviennacl::device_specific::utils::first_letter_of_type< int >
 Cviennacl::device_specific::utils::first_letter_of_type< long >
 Cviennacl::device_specific::utils::first_letter_of_type< short >
 Cviennacl::device_specific::utils::first_letter_of_type< unsigned char >
 Cviennacl::device_specific::utils::first_letter_of_type< unsigned int >
 Cviennacl::device_specific::utils::first_letter_of_type< unsigned long >
 Cviennacl::device_specific::utils::first_letter_of_type< unsigned short >
 Cviennacl::linalg::fspai_precond< MatrixType >Implementation of the Factored SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type
 Cviennacl::linalg::fspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >Implementation of the Factored SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix
 Cviennacl::linalg::detail::spai::fspai_tagA tag for FSPAI. Experimental
 Cviennacl::gibbs_poole_stockmeyer_tagTag class for identifying the Gibbs-Poole-Stockmeyer algorithm for reducing the bandwidth of a sparse matrix
 Cviennacl::linalg::gmres_tagA tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function
 Cviennacl::ocl::gpu_tagA tag identifying OpenCL devices as GPUs
 Cviennacl::ocl::handle< OCL_TYPE >Handle class the effectively represents a smart pointer for OpenCL handles
 Cviennacl::ocl::handle< cl_command_queue >
 Cviennacl::ocl::handle< cl_context >
 Cviennacl::ocl::handle< cl_kernel >
 Cviennacl::ocl::handle< cl_mem >
 Cviennacl::ocl::handle< cl_program >
 Cviennacl::device_specific::utils::handle_fun
 Cviennacl::ocl::handle_inc_dec_helper< OCL_TYPE >Helper for OpenCL reference counting used by class handle
 Cviennacl::hankel_matrix< SCALARTYPE, ALIGNMENT >A Hankel matrix class
 Cviennacl::linalg::opencl::kernels::hyb_matrix< NumericT >Main kernel class for generating OpenCL kernels for hyb_matrix
 Cviennacl::hyb_matrix< SCALARTYPE, ALIGNMENT >Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros
 Cviennacl::hyb_matrix< double >
 Cviennacl::hyb_matrix< float >
 Cviennacl::linalg::ichol0_precond< MatrixT >Incomplete Cholesky preconditioner class with static pattern (ICHOL0), can be supplied to solve()-routines
 Cviennacl::linalg::ichol0_precond< compressed_matrix< NumericT, AlignmentV > >ILU0 preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::ichol0_tagA tag for incomplete Cholesky factorization with static pattern (ILU0)
 Cviennacl::linalg::opencl::kernels::ilu< NumericT >Main kernel class for generating OpenCL kernels for incomplete LU factorization preconditioners
 Cviennacl::linalg::ilu0_precond< MatrixT >ILU0 preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::ilu0_precond< viennacl::compressed_matrix< NumericT, AlignmentV > >ILU0 preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::ilu0_tagA tag for incomplete LU factorization with static pattern (ILU0)
 Cviennacl::linalg::detail::ilu_vector_range< VectorT, NumericT, SizeT >Helper range class for representing a subvector of a larger buffer
 Cviennacl::linalg::ilut_precond< MatrixT >ILUT preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::ilut_precond< viennacl::compressed_matrix< NumericT, AlignmentV > >ILUT preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::ilut_tagA tag for incomplete LU factorization with threshold (ILUT)
 Cviennacl::implicit_matrix_base< NumericT >Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<>
 Cviennacl::implicit_matrix_base< char >
 Cviennacl::implicit_matrix_base< double >
 Cviennacl::implicit_matrix_base< float >
 Cviennacl::implicit_matrix_base< int >
 Cviennacl::implicit_matrix_base< long >
 Cviennacl::implicit_matrix_base< short >
 Cviennacl::implicit_matrix_base< unsigned char >
 Cviennacl::implicit_matrix_base< unsigned int >
 Cviennacl::implicit_matrix_base< unsigned long >
 Cviennacl::implicit_matrix_base< unsigned short >
 Cviennacl::implicit_vector_base< NumericT >Common base class for representing vectors where the entries are not all stored explicitly
 Cviennacl::implicit_vector_base< char >
 Cviennacl::implicit_vector_base< double >
 Cviennacl::implicit_vector_base< float >
 Cviennacl::implicit_vector_base< int >
 Cviennacl::implicit_vector_base< long >
 Cviennacl::implicit_vector_base< short >
 Cviennacl::implicit_vector_base< unsigned char >
 Cviennacl::implicit_vector_base< unsigned int >
 Cviennacl::implicit_vector_base< unsigned long >
 Cviennacl::implicit_vector_base< unsigned short >
 Cviennacl::device_specific::index_tuple
 Cviennacl::linalg::detail::InputData< NumericT >In this class the input matrix is stored
 Cviennacl::device_specific::utils::internal_size1_fun
 Cviennacl::device_specific::utils::internal_size2_fun
 Cviennacl::device_specific::utils::internal_size_fun
 Cviennacl::is_addition< T >Helper metafunction for checking whether the provided type is viennacl::op_add (for addition)
 Cviennacl::is_any_dense_matrix< T >Checks for either matrix_base or implicit_matrix_base
 Cviennacl::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.)
 Cviennacl::is_any_scalar< T >Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy)
 Cviennacl::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.)
 Cviennacl::is_any_vector< T >Checks for a type being either vector_base or implicit_vector_base
 Cviennacl::is_circulant_matrix< T >Helper class for checking whether a matrix is a circulant matrix
 Cviennacl::is_compressed_matrix< T >Helper class for checking whether a matrix is a compressed_matrix (CSR format)
 Cviennacl::is_coordinate_matrix< T >Helper class for checking whether a matrix is a coordinate_matrix (COO format)
 Cviennacl::is_cpu_scalar< T >Helper struct for checking whether a type is a host scalar type (e.g. float, double)
 Cviennacl::is_division< T >Helper metafunction for checking whether the provided type is viennacl::op_div (for division)
 Cviennacl::is_eigen< Tag >Meta function which checks whether a tag is tag_eigen
 Cviennacl::is_ell_matrix< T >Helper class for checking whether a matrix is an ell_matrix (ELL format)
 Cviennacl::is_flip_sign_scalar< T >Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<>
 Cviennacl::is_hankel_matrix< T >Helper class for checking whether a matrix is a Hankel matrix
 Cviennacl::is_hyb_matrix< T >Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR)
 Cviennacl::is_mtl4< Tag >Meta function which checks whether a tag is tag_mtl4
 Cviennacl::is_primitive_type< T >Helper class for checking whether a type is a primitive type
 Cviennacl::is_product< T >Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication)
 Cviennacl::is_row_major< T >Helper class for checking whether a matrix has a row-major layout
 Cviennacl::device_specific::utils::is_same_type< T, U >
 Cviennacl::device_specific::utils::is_same_type< T, T >
 Cviennacl::is_scalar< T >Helper struct for checking whether a type is a viennacl::scalar<>
 Cviennacl::is_sliced_ell_matrix< T >Helper class for checking whether a matrix is a sliced_ell_matrix (SELL-C- $ \sigma $ format)
 Cviennacl::is_stl< Tag >Meta function which checks whether a tag is tag_ublas
 Cviennacl::is_subtraction< T >Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction)
 Cviennacl::is_toeplitz_matrix< T >Helper class for checking whether a matrix is a Toeplitz matrix
 Cviennacl::is_ublas< Tag >Meta function which checks whether a tag is tag_ublas
 Cviennacl::is_vandermonde_matrix< T >Helper class for checking whether a matrix is a Vandermonde matrix
 Cviennacl::is_viennacl< Tag >Meta function which checks whether a tag is tag_viennacl
 Cviennacl::linalg::opencl::kernels::iterative< NumericT >Main kernel class for generating specialized OpenCL kernels for fast iterative solvers
 Cviennacl::linalg::jacobi_precond< MatrixT, is_viennacl >Jacobi preconditioner class, can be supplied to solve()-routines. Generic version for non-ViennaCL matrices
 Cviennacl::linalg::jacobi_precond< MatrixT, true >Jacobi preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::jacobi_tagA tag for a jacobi preconditioner
 Cviennacl::ocl::kernelRepresents an OpenCL kernel within ViennaCL
 Cviennacl::linalg::lanczos_tagA tag for the lanczos algorithm
 Cviennacl::device_specific::lazy_program_compiler
 Cviennacl::device_specific::utils::leading_start
 Cviennacl::device_specific::utils::leading_stride
 Cviennacl::scheduler::lhs_rhs_elementA class representing the 'data' for the LHS or RHS operand of the respective node
 Cviennacl::ocl::local_memA class representing local (shared) OpenCL memory. Typically used as kernel argument
 Cviennacl::device_specific::template_base::loop_body_base
 Cviennacl::linalg::lower_tagA tag class representing a lower triangular matrix
 Cviennacl::device_specific::mapped_objectMapped Object
 Cviennacl::linalg::cuda::mat_mult_matrix_index< LayoutT >Helper struct for accessing an element of a row- or column-major matrix
 Cviennacl::linalg::opencl::kernels::matrix< NumericT >Main kernel class for generating OpenCL kernels for operations on/with viennacl::vector<> without involving matrices, multiple inner products, or element-wise operations other than addition or subtraction
 Cviennacl::linalg::host_based::detail::matrix_array_wrapper< NumericT, LayoutT, is_transposed >Helper array for accessing a strided submatrix embedded in a larger matrix
 Cviennacl::matrix_base< NumericT, SizeT, DistanceT >
 Cviennacl::matrix_base< char >
 Cviennacl::matrix_base< double >
 Cviennacl::matrix_base< float >
 Cviennacl::matrix_base< int >
 Cviennacl::matrix_base< long >
 Cviennacl::matrix_base< MatrixType::cpu_value_type >
 Cviennacl::matrix_base< NumericT >
 Cviennacl::matrix_base< short >
 Cviennacl::matrix_base< unsigned char >
 Cviennacl::matrix_base< unsigned int >
 Cviennacl::matrix_base< unsigned long >
 Cviennacl::matrix_base< unsigned short >
 Cviennacl::linalg::opencl::kernels::matrix_element< NumericT >Main kernel class for generating OpenCL kernels for elementwise operations other than addition and subtraction on/with viennacl::vector<>
 Cviennacl::matrix_expression< LHS, RHS, OP >Expression template class for representing a tree of expressions which ultimately result in a matrix
 Cviennacl::matrix_iterator< ROWCOL, MATRIXTYPE >A dense matrix class
 Cviennacl::tools::MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE >Helper class for incrementing an iterator in a dense matrix
 Cviennacl::linalg::opencl::kernels::matrix_legacy< NumericT, LayoutT >Main kernel class for generating OpenCL kernels for operations on/with dense matrix objects of type viennacl::matrix<>
 Cmatrix_maker< UBlasType, F >
 Cmatrix_maker< boost::numeric::ublas::matrix< T >, F >
 Cmatrix_maker< boost::numeric::ublas::matrix_range< MatrixT >, F >
 Cmatrix_maker< boost::numeric::ublas::matrix_slice< MatrixT >, F >
 Cviennacl::linalg::opencl::kernels::matrix_prod< NumericT >Main kernel class for generating OpenCL kernels for operations on/with viennacl::vector<> without involving matrices, multiple inner products, or element-wise operations other than addition or subtraction
 Cviennacl::tools::MATRIX_SIZE_DEDUCER< LHS, RHS, OP >Deduces the size of the resulting vector represented by a vector_expression from the operands
 Cviennacl::linalg::opencl::kernels::matrix_solve< NumericT, LayoutT1, LayoutT2 >Main kernel class for the generation of matrix solve kernels
 Cviennacl::backend::mem_handleMain abstraction class for multiple memory domains. Represents a buffer in either main RAM, an OpenCL context, or a CUDA device
 Cviennacl::linalg::mixed_precision_cg_tagA tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function
 Cviennacl::device_specific::mapped_object::MorphBase
 Cmy_inserter< MatrixType >
 Cviennacl::linalg::opencl::kernels::nmf< NumericT >Main kernel class for generating OpenCL kernels for nonnegative matrix factorization of a dense matrices
 Cviennacl::linalg::nmf_configConfiguration class for the nonnegative-matrix-factorization algorithm. Specify tolerances, maximum iteration counts, etc., here
 Cviennacl::linalg::no_precondA tag class representing the use of no preconditioner
 Cviennacl::device_specific::mapped_object::node_info
 Cviennacl::scheduler::result_of::num_nodes< T >
 Cviennacl::scheduler::result_of::num_nodes< const matrix_expression< LHS, RHS, OP > >
 Cviennacl::scheduler::result_of::num_nodes< const scalar_expression< LHS, RHS, OP > >
 Cviennacl::scheduler::result_of::num_nodes< const vector_expression< LHS, RHS, OP > >
 Cviennacl::scheduler::result_of::num_nodes< matrix_expression< LHS, RHS, OP > >
 Cviennacl::scheduler::result_of::num_nodes< scalar_expression< LHS, RHS, OP > >
 Cviennacl::scheduler::result_of::num_nodes< vector_expression< LHS, RHS, OP > >
 Cviennacl::scheduler::result_of::numeric_type_id< T >Helper metafunction for obtaining the runtime type ID for a numerical type
 Cviennacl::one_vector< SCALARTYPE >
 Cviennacl::op_absA tag class representing the modulus function for integers
 Cviennacl::op_acosA tag class representing the acos() function
 Cviennacl::op_addA tag class representing addition
 Cviennacl::linalg::detail::op_applier< OpT >Worker class for decomposing expression templates
 Cviennacl::op_argmaxA tag class for representing the argmax() function
 Cviennacl::op_argminA tag class for representing the argmin() function
 Cviennacl::op_asinA tag class representing the asin() function
 Cop_assign
 Cviennacl::op_assignA tag class representing assignment
 Cviennacl::op_atanA tag class representing the atan() function
 Cviennacl::op_atan2A tag class representing the atan2() function
 Cviennacl::op_ceilA tag class representing the ceil() function
 Cviennacl::op_columnA tag class representing the extraction of a matrix column to a vector
 Cviennacl::op_cosA tag class representing the cos() function
 Cviennacl::op_coshA tag class representing the cosh() function
 Cviennacl::op_divA tag class representing division
 Cviennacl::scheduler::op_elementStruct for holding the type family as well as the type of an operation (could be addition, subtraction, norm, etc.)
 Cviennacl::op_element_binary< OP >A tag class representing element-wise binary operations (like multiplication) on vectors or matrices
 Cviennacl::op_element_cast< OP >A tag class representing element-wise casting operations on vectors and matrices
 Cviennacl::op_element_unary< OP >A tag class representing element-wise unary operations (like sin()) on vectors or matrices
 Cviennacl::op_eqA tag class representing equality
 Cviennacl::linalg::detail::op_executor< A, OP, T >Worker class for decomposing expression templates
 Cviennacl::op_expA tag class representing the exp() function
 Cviennacl::op_fabsA tag class representing the fabs() function
 Cviennacl::op_fdimA tag class representing the fdim() function
 Cviennacl::op_flip_signA tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0)
 Cviennacl::op_floorA tag class representing the floor() function
 Cviennacl::op_fmaxA tag class representing the fmax() function
 Cviennacl::op_fminA tag class representing the fmin() function
 Cviennacl::op_fmodA tag class representing the fmod() function
 Cviennacl::op_geqA tag class representing greater-than-or-equal-to
 Cviennacl::op_greaterA tag class representing greater-than
 Cviennacl::op_inner_prodA tag class representing inner products of two vectors
 Cviennacl::op_inplace_addA tag class representing inplace addition
 Cviennacl::op_inplace_subA tag class representing inplace subtraction
 Cviennacl::op_leqA tag class representing less-than-or-equal-to
 Cviennacl::op_lessA tag class representing less-than
 Cviennacl::op_logA tag class representing the log() function
 Cviennacl::op_log10A tag class representing the log10() function
 Cviennacl::op_mat_mat_prodA tag class representing matrix-matrix products
 Cviennacl::op_matrix_diagA tag class representing the (off-)diagonal of a matrix
 Cviennacl::op_maxA tag class representing the maximum of a vector
 Cviennacl::op_minA tag class representing the minimum of a vector
 Cop_minus_assign
 Cviennacl::op_multA tag class representing multiplication by a scalar
 Cviennacl::op_neqA tag class representing inequality
 Cviennacl::op_norm_1A tag class representing the 1-norm of a vector
 Cviennacl::op_norm_2A tag class representing the 2-norm of a vector
 Cviennacl::op_norm_frobeniusA tag class representing the Frobenius-norm of a matrix
 Cviennacl::op_norm_infA tag class representing the inf-norm of a vector
 Cop_plus_assign
 Cviennacl::op_powA tag class representing the power function
 Cviennacl::op_prodA tag class representing matrix-vector products and element-wise multiplications
 Cviennacl::op_reduce_columns< T >
 Cviennacl::op_reduce_rows< T >
 Cviennacl::op_reduce_vector< T >
 Cviennacl::op_rowA tag class representing the extraction of a matrix row to a vector
 Cviennacl::op_sinA tag class representing the sin() function
 Cviennacl::op_sinhA tag class representing the sinh() function
 Cviennacl::op_sqrtA tag class representing the sqrt() function
 Cviennacl::op_subA tag class representing subtraction
 Cviennacl::op_tanA tag class representing the tan() function
 Cviennacl::op_tanhA tag class representing the tanh() function
 Cviennacl::op_transA tag class representing transposed matrices
 Cviennacl::scheduler::result_of::op_type_info< T >
 Cviennacl::scheduler::result_of::op_type_info< op_add >
 Cviennacl::scheduler::result_of::op_type_info< op_assign >
 Cviennacl::scheduler::result_of::op_type_info< op_column >
 Cviennacl::scheduler::result_of::op_type_info< op_div >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_argmax > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_argmin > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_div > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_eq > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_fmax > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_fmin > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_geq > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_greater > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_leq > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_less > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_neq > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_pow > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_binary< op_prod > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< char > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< double > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< float > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< int > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< long > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< short > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< unsigned char > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< unsigned int > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< unsigned long > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_cast< unsigned short > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_abs > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_acos > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_asin > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_atan > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_ceil > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_cos > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_cosh > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_exp > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_fabs > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_floor > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_log > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_log10 > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_sin > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_sinh > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_sqrt > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_tan > >
 Cviennacl::scheduler::result_of::op_type_info< op_element_unary< op_tanh > >
 Cviennacl::scheduler::result_of::op_type_info< op_flip_sign >
 Cviennacl::scheduler::result_of::op_type_info< op_inner_prod >
 Cviennacl::scheduler::result_of::op_type_info< op_inplace_add >
 Cviennacl::scheduler::result_of::op_type_info< op_inplace_sub >
 Cviennacl::scheduler::result_of::op_type_info< op_mat_mat_prod >
 Cviennacl::scheduler::result_of::op_type_info< op_matrix_diag >
 Cviennacl::scheduler::result_of::op_type_info< op_max >
 Cviennacl::scheduler::result_of::op_type_info< op_min >
 Cviennacl::scheduler::result_of::op_type_info< op_mult >
 Cviennacl::scheduler::result_of::op_type_info< op_norm_1 >
 Cviennacl::scheduler::result_of::op_type_info< op_norm_2 >
 Cviennacl::scheduler::result_of::op_type_info< op_norm_inf >
 Cviennacl::scheduler::result_of::op_type_info< op_prod >
 Cviennacl::scheduler::result_of::op_type_info< op_reduce_columns< OP > >
 Cviennacl::scheduler::result_of::op_type_info< op_reduce_rows< OP > >
 Cviennacl::scheduler::result_of::op_type_info< op_reduce_vector< OP > >
 Cviennacl::scheduler::result_of::op_type_info< op_row >
 Cviennacl::scheduler::result_of::op_type_info< op_sub >
 Cviennacl::scheduler::result_of::op_type_info< op_trans >
 Cviennacl::scheduler::result_of::op_type_info< op_vector_diag >
 Cviennacl::op_vector_diagA tag class representing a matrix given by a vector placed on a certain (off-)diagonal
 Costream
 Cviennacl::ocl::packed_cl_uintHelper class for packing four cl_uint numbers into a uint4 type for access inside an OpenCL kernel
 Cviennacl::device_specific::template_base::parameters_type
 Cviennacl::ocl::platformWrapper class for an OpenCL platform
 Cviennacl::linalg::power_iter_tagA tag for the power iteration algorithm
 Cviennacl::ocl::programWrapper class for an OpenCL program
 Cviennacl::linalg::detail::ResultDataLarge< NumericT >In this class the data of the result for large matrices is stored
 Cviennacl::linalg::detail::ResultDataSmall< NumericT >In this class the data of the result for small matrices is stored
 Cviennacl::row_iterationA tag indicating iteration along increasing row index of a matrix
 Cviennacl::row_majorA tag for row-major storage of a dense matrix
 Cviennacl::device_specific::utils::row_major_fun
 Cviennacl::row_major_tagTag class for indicating row-major layout of a matrix. Not passed to the matrix directly, see row_major type
 Cviennacl::linalg::row_scaling< MatrixType, is_viennacl >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
 Cviennacl::linalg::row_scaling< MatrixType, true >Jacobi preconditioner class, can be supplied to solve()-routines
 Cviennacl::linalg::row_scaling_tagA tag for a row scaling preconditioner which merely normalizes the equation system such that each row of the system matrix has unit norm
 Cviennacl::linalg::opencl::kernels::row_wise_reduction< NumericT >Main kernel class for generating OpenCL kernels for operations on/with viennacl::vector<> without involving matrices, multiple inner products, or element-wise operations other than addition or subtraction
 Cviennacl::linalg::opencl::kernels::scalar< NumericT >Main kernel class for generating OpenCL kernels for operations involving viennacl::scalar<>, but not viennacl::vector<> or viennacl::matrix<>
 Cviennacl::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
 Cviennacl::scalar< char >
 Cviennacl::scalar< double >
 Cviennacl::scalar< float >
 Cviennacl::scalar< int >
 Cviennacl::scalar< long >
 Cviennacl::scalar< short >
 Cviennacl::scalar< unsigned char >
 Cviennacl::scalar< unsigned int >
 Cviennacl::scalar< unsigned long >
 Cviennacl::scalar< unsigned short >
 Cviennacl::scalar_expression< LHS, RHS, OP >A proxy for scalar expressions (e.g. from inner vector products)
 Cviennacl::scalar_expression< LHS, RHS, op_inner_prod >Specialization of a scalar expression for inner products. Allows for a final reduction on the CPU
 Cviennacl::scalar_expression< LHS, RHS, op_max >Specialization of a scalar expression for max(). Allows for a final reduction on the CPU
 Cviennacl::scalar_expression< LHS, RHS, op_min >Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU
 Cviennacl::scalar_expression< LHS, RHS, op_norm_1 >Specialization of a scalar expression for norm_1. Allows for a final reduction on the CPU
 Cviennacl::scalar_expression< LHS, RHS, op_norm_2 >Specialization of a scalar expression for norm_2. Allows for a final reduction on the CPU
 Cviennacl::scalar_expression< LHS, RHS, op_norm_frobenius >Specialization of a scalar expression for norm_frobenius. Allows for a final reduction on the CPU
 Cviennacl::scalar_expression< LHS, RHS, op_norm_inf >Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU
 Cviennacl::device_specific::utils::scalartype_size_fun
 Cviennacl::tools::detail::sha1
 Cviennacl::tools::shared_ptr< T >A shared pointer class similar to boost::shared_ptr. Reimplemented in order to avoid a Boost-dependency. Will be replaced by std::shared_ptr as soon as C++11 is widely available
 Cviennacl::tools::shared_ptr< char >
 Cviennacl::device_specific::utils::size1_fun
 Cviennacl::device_specific::utils::size2_fun
 Cviennacl::device_specific::utils::size_fun
 Cviennacl::result_of::size_type< T >Generic meta-function for retrieving the size_type associated with type T
 Cviennacl::sliced_ell_matrix< ScalarT, IndexT >Sparse matrix class using the sliced ELLPACK with parameters C, $ \sigma $
 Cviennacl::linalg::opencl::kernels::sliced_ell_matrix< NumericT, IndexT >Main kernel class for generating OpenCL kernels for ell_matrix
 Cviennacl::linalg::opencl::kernels::sliced_ell_matrix< NumericT, unsigned int >
 Cviennacl::linalg::opencl::kernels::spai< NumericT >Main kernel class for generating OpenCL kernels for the sparse approximate inverse preconditioners
 Cviennacl::linalg::spai_precond< MatrixType >Implementation of the SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type
 Cviennacl::linalg::spai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >Implementation of the SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix
 Cviennacl::linalg::detail::spai::spai_tagA tag for SPAI
 Cviennacl::tools::sparse_matrix_adapted_iterator< NumericT, SizeT, is_iterator1 >A non-const iterator for sparse matrices of type std::vector<std::map<SizeT, NumericT> >
 Cviennacl::linalg::detail::spai::sparse_vector< NumericT >Represents a sparse vector based on std::map<unsigned int, NumericT>
 Cviennacl::device_specific::utils::start1_fun
 Cviennacl::device_specific::utils::start2_fun
 Cviennacl::scheduler::statementThe main class for representing a statement such as x = inner_prod(y,z); at runtime
 Cviennacl::scheduler::statement_nodeMain datastructure for an node in the statement tree
 Cviennacl::device_specific::statements_container
 Cviennacl::device_specific::utils::stride1_fun
 Cviennacl::device_specific::utils::stride2_fun
 Cviennacl::device_specific::utils::stride_fun
 Cviennacl::linalg::opencl::kernels::svd< NumericT, MatrixLayout >Main kernel class for generating OpenCL kernels for singular value decomposition of dense matrices
 Cviennacl::device_specific::symbolic_binder
 Cviennacl::tag_eigenA tag class for identifying types from Eigen
 Cviennacl::tag_mtl4A tag class for identifying types from MTL4
 Cviennacl::tag_noneA tag class for identifying 'unknown' types
 Cviennacl::traits::tag_of< T, Active >Generic base for wrapping other linear algebra packages
 Cviennacl::tag_stlA tag class for identifying types from the C++ STL
 Cviennacl::tag_ublasA tag class for identifying types from uBLAS
 Cviennacl::tag_viennaclA tag class for identifying types from ViennaCL
 Cviennacl::device_specific::template_base
 CtestData
 Cviennacl::tools::timerSimple timer class based on gettimeofday (POSIX) or QueryPerformanceCounter (Windows)
 CTimer
 Cviennacl::toeplitz_matrix< SCALARTYPE, ALIGNMENT >A Toeplitz matrix class
 Cviennacl::toeplitz_matrix< NumericT, AlignmentV >
 Cviennacl::device_specific::tree_parsing::traversal_functorBase functor class for traversing a statement
 Cviennacl::device_specific::builtin_database::database_type< ParamT >::type
 Cviennacl::device_specific::utils::type_to_string< T >
 Cviennacl::ocl::type_to_string< T >Helper class for converting a type to its string representation
 Cviennacl::device_specific::utils::type_to_string< char >
 Cviennacl::device_specific::utils::type_to_string< double >
 Cviennacl::device_specific::utils::type_to_string< float >
 Cviennacl::device_specific::utils::type_to_string< int >
 Cviennacl::device_specific::utils::type_to_string< long >
 Cviennacl::device_specific::utils::type_to_string< short >
 Cviennacl::device_specific::utils::type_to_string< unsigned char >
 Cviennacl::device_specific::utils::type_to_string< unsigned int >
 Cviennacl::device_specific::utils::type_to_string< unsigned long >
 Cviennacl::device_specific::utils::type_to_string< unsigned short >
 Cviennacl::linalg::cuda::detail::type_to_type2< NumericT >
 Cviennacl::linalg::cuda::detail::type_to_type2< double >
 Cviennacl::linalg::cuda::detail::type_to_type2< float >
 Cviennacl::backend::typesafe_host_array< T, special >Helper class implementing an array on the host. Default case: No conversion necessary
 Cviennacl::backend::typesafe_host_array< T, true >Special host array type for conversion between OpenCL types and pure CPU types
 Cviennacl::linalg::unit_lower_tagA tag class representing a lower triangular matrix with unit diagonal
 Cviennacl::linalg::unit_upper_tagA tag class representing an upper triangular matrix with unit diagonal
 Cviennacl::linalg::upper_tagA tag class representing an upper triangular matrix
 Cviennacl::result_of::value_type< T >Generic helper function for retrieving the value_type associated with type T
 Cviennacl::vandermonde_matrix< SCALARTYPE, ALIGNMENT >A Vandermonde matrix class
 Cviennacl::linalg::opencl::kernels::vector< NumericT >Main kernel class for generating OpenCL kernels for operations on/with viennacl::vector<> without involving matrices, multiple inner products, or element-wise operations other than addition or subtraction
 Cviennacl::linalg::host_based::detail::vector_array_wrapper< NumericT >Helper class for accessing a strided subvector of a larger vector
 Cviennacl::vector_base< NumericT, SizeT, DistanceT >Common base class for dense vectors, vector ranges, and vector slices
 Cviennacl::vector_base< char >
 Cviennacl::vector_base< double >
 Cviennacl::vector_base< float >
 Cviennacl::vector_base< int >
 Cviennacl::vector_base< long >
 Cviennacl::vector_base< NumericT >
 Cviennacl::vector_base< short >
 Cviennacl::vector_base< unsigned char >
 Cviennacl::vector_base< unsigned int >
 Cviennacl::vector_base< unsigned long >
 Cviennacl::vector_base< unsigned short >
 Cviennacl::vector_base< VectorType::cpu_value_type >
 Cviennacl::linalg::opencl::kernels::vector_element< NumericT >Main kernel class for generating OpenCL kernels for elementwise operations other than addition and subtraction on/with viennacl::vector<>
 Cviennacl::vector_expression< LHS, RHS, OP >An expression template class that represents a binary operation that yields a vector
 Cviennacl::linalg::opencl::kernels::vector_multi_inner_prod< NumericT >Main kernel class for generating OpenCL kernels for operations on/with viennacl::vector<> without involving matrices, multiple inner products, or element-wise operations other than addition or subtraction
 Cvector_proxy< NumericT >
 Cviennacl::vector_tuple< ScalarT >Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie()
 CViennaCLBackend_implGeneric backend for CUDA, OpenCL, host-based stuff
 CViennaCLCUDABackend_impl
 CViennaCLHostBackend_impl
 CViennaCLHostScalar_impl
 CViennaCLMatrix_impl
 CViennaCLOpenCLBackend_impl
 CViennaCLScalar_impl
 CViennaCLVector_impl
 Cviennacl::linalg::detail::z_handler< VectorT, PreconditionerT >Handles the no_precond case at minimal overhead
 Cviennacl::linalg::detail::z_handler< VectorT, viennacl::linalg::no_precond >