| ►Nviennacl | Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them |
| ►Nbackend | Namespace providing routines for handling the different memory domains |
| ►Ncpu_ram | Provides implementations for handling memory buffers in CPU RAM |
| ►Ndetail | Holds implementation details for handling memory buffers in CPU RAM. Not intended for direct use by library users |
| Carray_deleter | Helper struct for deleting an pointer to an array |
| ►Ncuda | Provides implementations for handling CUDA memory buffers |
| ►Ndetail | Holds implementation details for handling CUDA memory buffers. Not intended for direct use by library users |
| Ccuda_deleter | Functor for deleting a CUDA handle. Used within the smart pointer class |
| Ccuda_exception | |
| ►Ndetail | Implementation details for the generic memory backend interface |
| Cconvert_to_opencl | Helper struct for converting a type to its OpenCL pendant |
| ►Nopencl | Provides implementations for handling OpenCL memory buffers |
| Cmem_handle | Main abstraction class for multiple memory domains. Represents a buffer in either main RAM, an OpenCL context, or a CUDA device |
| Ctypesafe_host_array | Helper class implementing an array on the host. Default case: No conversion necessary |
| Ctypesafe_host_array< T, true > | Special host array type for conversion between OpenCL types and pure CPU types |
| ►Ndetail | Holds implementation details for functionality in the main viennacl-namespace. Not intended for direct use by library users |
| ►Nfft | Helper namespace for fast Fourier transforms. Not to be used directly by library users |
| ►Ndevice_specific | Provides an OpenCL kernel generator |
| ►Nbuiltin_database | |
| ►Ndevices | |
| ►Naccelerator | |
| ►Ncpu | |
| ►Ngpu | |
| ►Namd | |
| ►Nevergreen | |
| ►Nnorthern_islands | |
| ►Nsouthern_islands | |
| ►Nvolcanic_islands | |
| ►Nnvidia | |
| ►Nfermi | |
| ►Nkepler | |
| ►Nmaxwell | |
| ►Ntesla | |
| ►Cdatabase_type | |
| Cdevice_architecture_t | |
| Cdevice_name_t | |
| Cdevice_type_t | |
| Cexpression_t | |
| Ctype | |
| ►Ntree_parsing | |
| Cevaluate_expression_traversal | Functor for generating the expression string from a statement |
| Cfilter | |
| Cfilter_elements | |
| Cprocess_traversal | Functor for fetching or writing-back the elements in a statement |
| Cstatement_representation_functor | |
| Ctraversal_functor | Base functor class for traversing a statement |
| ►Nutils | Contains various helper routines for kernel generation |
| Cfirst_letter_of_type | |
| Cfirst_letter_of_type< char > | |
| Cfirst_letter_of_type< double > | |
| Cfirst_letter_of_type< float > | |
| Cfirst_letter_of_type< int > | |
| Cfirst_letter_of_type< long > | |
| Cfirst_letter_of_type< short > | |
| Cfirst_letter_of_type< unsigned char > | |
| Cfirst_letter_of_type< unsigned int > | |
| Cfirst_letter_of_type< unsigned long > | |
| Cfirst_letter_of_type< unsigned short > | |
| Chandle_fun | |
| Cinternal_size1_fun | |
| Cinternal_size2_fun | |
| Cinternal_size_fun | |
| Cis_same_type | |
| Cis_same_type< T, T > | |
| Ckernel_generation_stream | |
| Cleading_start | |
| Cleading_stride | |
| Crow_major_fun | |
| Cscalartype_size_fun | |
| Csize1_fun | |
| Csize2_fun | |
| Csize_fun | |
| Cstart1_fun | |
| Cstart2_fun | |
| Cstride1_fun | |
| Cstride2_fun | |
| Cstride_fun | |
| Ctype_to_string | |
| Ctype_to_string< char > | |
| Ctype_to_string< double > | |
| Ctype_to_string< float > | |
| Ctype_to_string< int > | |
| Ctype_to_string< long > | |
| Ctype_to_string< short > | |
| Ctype_to_string< unsigned char > | |
| Ctype_to_string< unsigned int > | |
| Ctype_to_string< unsigned long > | |
| Ctype_to_string< unsigned short > | |
| Cbinary_leaf | Binary leaf interface |
| Cbind_all_unique | |
| Cbind_to_handle | |
| Cchar_to_type | |
| Cexecution_handler | |
| Cgenerator_not_supported_exception | Exception for the case the generator is unable to deal with the operation |
| Cindex_tuple | |
| Clazy_program_compiler | |
| Cmapped_buffer | Buffered |
| Cmapped_handle | Handle |
| Cmapped_host_scalar | Host scalar |
| Cmapped_implicit_matrix | Implicit matrix |
| Cmapped_implicit_vector | Implicit vector |
| Cmapped_matrix | Matrix |
| Cmapped_matrix_column | Matrix column |
| Cmapped_matrix_diag | Matrix diag |
| Cmapped_matrix_product | Matrix product |
| Cmapped_matrix_row | Matrix row |
| ►Cmapped_object | Mapped Object |
| CMorphBase | |
| CMorphBase1D | |
| CMorphBase2D | |
| Cnode_info | |
| Cmapped_reduction | Reduction |
| Cmapped_row_wise_reduction | Vector reduction |
| Cmapped_scalar | Scalar |
| Cmapped_scalar_reduction | Scalar reduction |
| Cmapped_trans | Trans |
| Cmapped_vector | Vector |
| Cmapped_vector_diag | Vector diag |
| Cmatrix_product_parameters | |
| Cmatrix_product_template | |
| Cstatements_container | |
| Csymbolic_binder | |
| ►Ctemplate_base | |
| Cinvalid_template_exception | |
| Cloop_body_base | |
| Cparameters_type | |
| Ctemplate_base_impl | |
| ►Nio | Provides basic input-output functionality |
| ►Nlinalg | Provides all linear algebra operations which are not covered by operator overloads |
| ►Ncuda | Holds all CUDA compute kernels used by ViennaCL |
| ►Ndetail | Helper functions for the CUDA linear algebra backend |
| Cspmv_alpha_beta | |
| Cspmv_pure | |
| Ctype_to_type2 | |
| Ctype_to_type2< double > | |
| Ctype_to_type2< float > | |
| Cmat_mult_matrix_index | Helper struct for accessing an element of a row- or column-major matrix |
| ►Ndetail | Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user |
| ►Namg | Implementation namespace for algebraic multigrid preconditioner |
| Camg_level_context | |
| ►Nspai | Implementation namespace for sparse approximate inverse preconditioner |
| Cblock_matrix | Represents contigious matrices on GPU |
| Cblock_vector | Represents a contiguous vector on the GPU to represent a concatentation of small vectors |
| CCompareSecond | Helper functor for comparing std::pair<> based on the second member |
| Cfspai_tag | A tag for FSPAI. Experimental |
| Cspai_tag | A tag for SPAI |
| Csparse_vector | Represents a sparse vector based on std::map<unsigned int, NumericT> |
| CFastMatrix | Internal helper class representing a row-major dense matrix used for the QR method for the purpose of computing eigenvalues |
| Cilu_vector_range | Helper range class for representing a subvector of a larger buffer |
| Cilut_sparse_vector | Helper struct for holding a sparse vector in linear memory. For internal use only |
| CInputData | In this class the input matrix is stored |
| Cop_applier | Worker class for decomposing expression templates |
| Cop_executor | Worker class for decomposing expression templates |
| CResultDataLarge | In this class the data of the result for large matrices is stored |
| CResultDataSmall | In this class the data of the result for small matrices is stored |
| Cz_handler | Handles the no_precond case at minimal overhead |
| Cz_handler< VectorT, viennacl::linalg::no_precond > | |
| ►Nhost_based | Holds all compute kernels with conventional host-based execution (buffers in CPU RAM) |
| ►Namg | |
| Camg_id_influence | Helper struct for sequential classical one-pass coarsening |
| ►Ndetail | Helper functions for the host-based linear algebra backend |
| ►Nfft | |
| Cmatrix_array_wrapper | Helper array for accessing a strided submatrix embedded in a larger matrix |
| Cvector_array_wrapper | Helper class for accessing a strided subvector of a larger vector |
| Cspgemm_output_write_disabled | |
| Cspgemm_output_write_enabled | |
| ►Nopencl | Holds all routines providing OpenCL linear algebra operations |
| ►Nkernels | Contains the OpenCL kernel generation functions for a predefined set of functionality |
| Cambm_config | Configuration struct for generating OpenCL kernels for linear combinations of matrices |
| Camg | Main kernel class for generating OpenCL kernels for compressed_matrix |
| Casbs_config | Configuration struct for generating OpenCL kernels for linear combinations of viennacl::scalar<> objects |
| Cavbv_config | Configuration struct for generating OpenCL kernels for linear combinations of vectors |
| Cbisect_kernel | Main kernel class for the generation of the bisection kernels and utilities |
| Ccompressed_compressed_matrix | Main kernel class for generating OpenCL kernels for compressed_compressed_matrix |
| Ccompressed_matrix | Main kernel class for generating OpenCL kernels for compressed_matrix (except solvers) |
| Ccompressed_matrix_solve | Main kernel class for triangular solver OpenCL kernels for compressed_matrix |
| Ccoordinate_matrix | Main kernel class for generating OpenCL kernels for coordinate_matrix |
| Cell_matrix | Main kernel class for generating OpenCL kernels for ell_matrix |
| Cfft | Main kernel class for generating OpenCL kernels for the fast Fourier transform |
| Chyb_matrix | Main kernel class for generating OpenCL kernels for hyb_matrix |
| Cilu | Main kernel class for generating OpenCL kernels for incomplete LU factorization preconditioners |
| Citerative | Main kernel class for generating specialized OpenCL kernels for fast iterative solvers |
| Cmatrix | Main kernel class for generating OpenCL kernels for operations on/with dense matrix objects of type viennacl::matrix<> |
| Cmatrix_convert | Main kernel class for vector conversion routines (e.g. convert vector<int> to vector<float>) |
| Cmatrix_element | Main kernel class for generating OpenCL kernels for elementwise-operations such as element_sin() on/with dense matrix objects of type viennacl::matrix<> |
| Cmatrix_legacy | Main kernel class for generating OpenCL kernels for operations on/with dense matrix objects of type viennacl::matrix<> |
| Cmatrix_prod | 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 |
| Cmatrix_solve | Main kernel class for the generation of matrix solve kernels |
| Cnmf | Main kernel class for generating OpenCL kernels for nonnegative matrix factorization of a dense matrices |
| Cscalar | Main kernel class for generating OpenCL kernels for operations involving viennacl::scalar<>, but not viennacl::vector<> or viennacl::matrix<> |
| Cscan | Main kernel class for generating OpenCL kernels for singular value decomposition of dense matrices |
| Csliced_ell_matrix | Main kernel class for generating OpenCL kernels for ell_matrix |
| Csliced_ell_matrix< NumericT, unsigned int > | |
| Cspai | Main kernel class for generating OpenCL kernels for the sparse approximate inverse preconditioners |
| Csvd | Main kernel class for generating OpenCL kernels for singular value decomposition of dense matrices |
| Cvector | 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_convert | Main kernel class for vector conversion routines (e.g. convert vector<int> to vector<float>) |
| Cvector_element | Main kernel class for generating OpenCL kernels for elementwise operations other than addition and subtraction on/with viennacl::vector<> |
| Cvector_multi_inner_prod | Main kernel class for generating OpenCL kernels for multiple inner products on/with viennacl::vector<> |
| Camg_coarse_problem_too_large_exception | |
| Camg_precond | AMG preconditioner class, can be supplied to solve()-routines |
| Camg_precond< compressed_matrix< NumericT, AlignmentV > > | AMG preconditioner class, can be supplied to solve()-routines |
| Camg_tag | A tag for algebraic multigrid (AMG). Used to transport information from the user to the implementation |
| Cbicgstab_solver | |
| Cbicgstab_tag | A tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function |
| Cblock_ilu_precond | A block ILU preconditioner class, can be supplied to solve()-routines |
| Cblock_ilu_precond< compressed_matrix< NumericT, AlignmentV >, ILUTagT > | ILUT preconditioner class, can be supplied to solve()-routines |
| Ccg_solver | |
| Ccg_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function |
| Cchow_patel_icc_precond | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines |
| Cchow_patel_icc_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines |
| Cchow_patel_ilu_precond | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines |
| Cchow_patel_ilu_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines |
| Cchow_patel_tag | A tag for incomplete LU and incomplete Cholesky factorization with static pattern (Parallel-ILU0, Parallel ICC0) |
| Cfspai_precond | Implementation of the Factored SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type |
| Cfspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > > | Implementation of the Factored SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix |
| Cgmres_solver | |
| Cgmres_tag | A tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function |
| Cichol0_precond | Incomplete Cholesky preconditioner class with static pattern (ICHOL0), can be supplied to solve()-routines |
| Cichol0_precond< compressed_matrix< NumericT, AlignmentV > > | ILU0 preconditioner class, can be supplied to solve()-routines |
| Cichol0_tag | A tag for incomplete Cholesky factorization with static pattern (ILU0) |
| Cilu0_precond | ILU0 preconditioner class, can be supplied to solve()-routines |
| Cilu0_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | ILU0 preconditioner class, can be supplied to solve()-routines |
| Cilu0_tag | A tag for incomplete LU factorization with static pattern (ILU0) |
| Cilut_precond | ILUT preconditioner class, can be supplied to solve()-routines |
| Cilut_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | ILUT preconditioner class, can be supplied to solve()-routines |
| Cilut_tag | A tag for incomplete LU factorization with threshold (ILUT) |
| Cjacobi_precond | Jacobi preconditioner class, can be supplied to solve()-routines. Generic version for non-ViennaCL matrices |
| Cjacobi_precond< MatrixT, true > | Jacobi preconditioner class, can be supplied to solve()-routines |
| Cjacobi_tag | A tag for a jacobi preconditioner |
| Clanczos_tag | A tag for the lanczos algorithm |
| Clower_tag | A tag class representing a lower triangular matrix |
| Cmixed_precision_cg_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function |
| Cnmf_config | Configuration class for the nonnegative-matrix-factorization algorithm. Specify tolerances, maximum iteration counts, etc., here |
| Cno_precond | A tag class representing the use of no preconditioner |
| Cpower_iter_tag | A tag for the power iteration algorithm |
| Crow_scaling | Jacobi-type preconditioner class, can be supplied to solve()-routines. This is a diagonal preconditioner with the diagonal entries being (configurable) row norms of the matrix |
| Crow_scaling< MatrixType, true > | Jacobi preconditioner class, can be supplied to solve()-routines |
| Crow_scaling_tag | A tag for a row scaling preconditioner which merely normalizes the equation system such that each row of the system matrix has unit norm |
| Cspai_precond | Implementation of the SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type |
| Cspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > > | Implementation of the SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix |
| Cunit_lower_tag | A tag class representing a lower triangular matrix with unit diagonal |
| Cunit_upper_tag | A tag class representing an upper triangular matrix with unit diagonal |
| Cupper_tag | A tag class representing an upper triangular matrix |
| ►Nocl | OpenCL backend. Manages platforms, contexts, buffers, kernels, etc |
| Caccelerator_tag | A tag identifying OpenCL devices as accelerators (e.g. Intel Xeon Phi) |
| Cbackend | A backend that provides contexts for ViennaCL objects (vector, matrix, etc.) |
| Cbuild_program_failure | Exception thrown if the OpenCL program cannot be built, usually due to a syntax error in the OpenCL code |
| Ccommand_queue | A class representing a command queue |
| Ccompiler_not_available | Exception thrown if the OpenCL just-in-time compiler is not available |
| Ccontext | Manages an OpenCL context and provides the respective convenience functions for creating buffers, etc |
| Ccpu_tag | A tag identifying OpenCL devices as CPUs |
| Cdefault_tag | A tag denoting the default OpenCL device type (SDK-specific) |
| Cdevice | A class representing a compute device (e.g. a GPU) |
| Cdevice_not_available | Exception thrown if the selected compute device is not available (maybe locked by another process) |
| Cdevice_not_found | Exception thrown in the case that a requested compute device was not found |
| CDOUBLE_PRECISION_CHECKER | 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 |
| Cdouble_precision_not_provided_error | Exception thrown if the user wants to use double precision arithmetics, but the device does not support double precision |
| Cerror_checker | An error reporting class. Template argument is used to avoid problems with external linkage |
| Cgpu_tag | A tag identifying OpenCL devices as GPUs |
| Chandle | Handle class the effectively represents a smart pointer for OpenCL handles |
| Chandle_inc_dec_helper | Helper for OpenCL reference counting used by class handle |
| Cimage_format_mismatch | Exception thrown if there is a mismatch in image formats for the operands |
| Cimage_format_not_supported | Exception thrown if the requested image format is not supported |
| Cinvalid_arg_index | Exception thrown if the kernel argument index is invalid, e.g. an arg index larger than the number of kernel arguments was provided |
| Cinvalid_arg_size | Exception thrown if the arguments to an OpenCL kernel have an invalid size e.g. not sizeof(cl_mem)) |
| Cinvalid_arg_value | Exception thrown if the kernel argument provided has an invalid value |
| Cinvalid_binary | Exception thrown if the OpenCL binary (generated from the jit-compiler or loaded from some other location) won't work on the device (e.g. due to a lack of double precision support) |
| Cinvalid_buffer_size | Exception thrown if the provided buffer size is invalid (e.g. zero) |
| Cinvalid_build_options | Exception thrown if invalid build options are passed to the OpenCL just-in-time compiler |
| Cinvalid_command_queue | Exception thrown if an invalid OpenCL command queue is provided to an OpenCL function |
| Cinvalid_context | Exception thrown if an invalid OpenCL context is provided to an OpenCL function |
| Cinvalid_device | Exception thrown if an invalid OpenCL device is provided to an OpenCL function |
| Cinvalid_device_type | Exception thrown if an invalid device type is specified |
| Cinvalid_event | Exception thrown if the provided event object (of type cl_event) is invalid |
| Cinvalid_event_wait_list | Exception thrown if the provided event wait list is invalid |
| Cinvalid_gl_object | Exception thrown if the provided OpenGL (not OpenCL) object is invalid |
| Cinvalid_global_offset | Exception thrown if the provided offset for get_global_id() in OpenCL kernels is invalid |
| Cinvalid_global_work_size | Exception thrown if the total number of work items is invalid (for example, not divisible by the number of work items per work group) |
| Cinvalid_host_ptr | Exception thrown if the provided pointer to host memory is invalid |
| Cinvalid_image_format_descriptor | Exception thrown if an invalid image format descriptor is provided |
| Cinvalid_image_size | Exception thrown if the image size provided is invalid (e.g. zero) |
| Cinvalid_kernel | Exception thrown if the provided kernel object (of type cl_kernel) is invalid (e.g. not initialized, from different context, or corrupted) |
| Cinvalid_kernel_args | Exception thrown if the kernel arguments are invalid and/or do not fit the kernel parameter list |
| Cinvalid_kernel_definition | Exception thrown if the kernel definition (number of arguments, argument types, etc.) is not the same for all devices for which the program has been built |
| Cinvalid_kernel_name | Exception thrown if the provided kernel name is invalid (e.g. not part of the program provided) |
| Cinvalid_mem_object | Exception thrown if an invalid OpenCL memory object (of type cl_mem) is passed to an OpenCL funciton |
| Cinvalid_mip_level | Exception thrown if the provided miplevel is greater than zero, but the OpenGL implementation does not support creating from non-zero mipmap levels |
| Cinvalid_operation | Exception thrown if interoperability of OpenCL with other frameworks collide |
| Cinvalid_platform | Exception thrown if an invalid OpenCL platform is provided to an OpenCL function |
| Cinvalid_program | Exception thrown if an OpenCL program object handle is invalid (e.g. not initialized) |
| Cinvalid_program_executable | Exception thrown if there is no built program exectuable available for the device |
| Cinvalid_property | Exception thrown if an invalid property is provided to a function (vague value) |
| Cinvalid_queue_properties | Exception thrown if invalid OpenCL command queue properties are provided when creating a command queue |
| Cinvalid_sampler | Exception thrown if an invalid sampler is provided for an image |
| Cinvalid_value | Exception thrown is an invalid value is provided to an OpenCL function |
| Cinvalid_work_dimension | Exception thrown if the work dimension is invalid (usually this means that the work dimension was set to be larger than three |
| Cinvalid_work_group_size | Exception thrown if the number of work groups is invalid (usually this means that more than 256/512/768/1024 work groups have been specified, but the device(s) cannot support this |
| Cinvalid_work_item_size | Exception thrown if the number of work items per work group invalid (usually this means that more than 256/512/768/1024 work items have been specified, but the device(s) cannot support this |
| Ckernel | Represents an OpenCL kernel within ViennaCL |
| Ckernel_not_found | |
| Clocal_mem | A class representing local (shared) OpenCL memory. Typically used as kernel argument |
| Cmap_failure | Exception thrown if the mapping of device memory to the host memory space failed |
| Cmem_copy_overlap | Exception thrown if the source buffer overlaps the destination buffer when copying from device memory to device memory |
| Cmem_object_allocation_failure | Exception thrown if a memory object cannot be allocated. Usually the requested memory buffer is simply too large |
| Cout_of_host_memory | Exception thrown if the host cannot provide enough memory for the datastructures in the OpenCL backend (temporary arrays, etc.) to perform the requested operation |
| Cout_of_resources | Exception thrown if the compute device is out of resources (either global memory, registers, etc.) for the requested operation |
| Cpacked_cl_uint | Helper class for packing four cl_uint numbers into a uint4 type for access inside an OpenCL kernel |
| Cplatform | Wrapper class for an OpenCL platform |
| Cprofiling_info_not_available | Exception thrown if the OpenCL context does not have CL_QUEUE_PROFILING_ENABLE set, if the execution is not complete, or the event object is a user event object |
| Cprogram | Wrapper class for an OpenCL program |
| Cprogram_not_found | |
| Cqueue_not_found | |
| Ctype_to_string | Helper class for converting a type to its string representation |
| Cunknown_error | Exception thrown if the returned error cannot be resolved to some defined error constant. Might result from invalid sources, invalid memory operations, etc |
| ►Nresult_of | Namespace containing many meta-functions |
| Calignment | Retrieves the alignment from a vector. Deprecated - will be replaced by a pure runtime facility in the future |
| Ccl_type | Metafunction for deducing the OpenCL type for a numeric type, e.g. float -> cl_float |
| Ccpu_value_type | Helper meta function for retrieving the main RAM-based value type. Particularly important to obtain T from viennacl::scalar<T> in a generic way |
| Csize_type | Generic meta-function for retrieving the size_type associated with type T |
| Cvalue_type | Generic helper function for retrieving the value_type associated with type T |
| ►Nscheduler | Contains the scheduling functionality which allows for dynamic kernel generation as well as the fusion of multiple statements into a single kernel |
| ►Nresult_of | Helper metafunctions used for the scheduler |
| Cnum_nodes | |
| Cnum_nodes< const matrix_expression< LHS, RHS, OP > > | |
| Cnum_nodes< const scalar_expression< LHS, RHS, OP > > | |
| Cnum_nodes< const vector_expression< LHS, RHS, OP > > | |
| Cnum_nodes< matrix_expression< LHS, RHS, OP > > | |
| Cnum_nodes< scalar_expression< LHS, RHS, OP > > | |
| Cnum_nodes< vector_expression< LHS, RHS, OP > > | |
| Cnumeric_type_id | Helper metafunction for obtaining the runtime type ID for a numerical type |
| Cop_type_info | Metafunction for querying type informations |
| Clhs_rhs_element | A class representing the 'data' for the LHS or RHS operand of the respective node |
| Cop_element | Struct for holding the type family as well as the type of an operation (could be addition, subtraction, norm, etc.) |
| Cstatement | The main class for representing a statement such as x = inner_prod(y,z); at runtime |
| Cstatement_node | Main datastructure for an node in the statement tree |
| Cstatement_not_supported_exception | Exception for the case the scheduler is unable to deal with the operation |
| ►Ntools | Namespace for various tools used within ViennaCL |
| ►Ndetail | Contains implementation details for the tools. Usually not of interest for the library user |
| Caux | Interface for the reference counter inside the shared_ptr |
| Cauximpl | Implementation helper for the reference counting mechanism inside shared_ptr |
| Ccount | Reference counting class for the shared_ptr implementation |
| Cdefault_deleter | Default deleter class for a pointer. The default is to just call 'delete' on the pointer. Provide your own implementations for 'delete[]' and 'free' |
| Csha1 | |
| CCHECK_SCALAR_TEMPLATE_ARGUMENT | A guard that checks whether the floating point type of GPU types is either float or double |
| CCONST_REMOVER | Removes the const qualifier from a type |
| Cconst_sparse_matrix_adapted_iterator | A const iterator for sparse matrices of type std::vector<std::map<SizeT, NumericT> > |
| Cconst_sparse_matrix_adapter | Adapts a constant sparse matrix type made up from std::vector<std::map<SizeT, NumericT> > to basic ublas-compatibility |
| CCPU_SCALAR_TYPE_DEDUCER | Obtain the cpu scalar type from a type, including a GPU type like viennacl::scalar<T> |
| CMATRIX_ITERATOR_INCREMENTER | Helper class for incrementing an iterator in a dense matrix |
| CMATRIX_SIZE_DEDUCER | Deduces the size of the resulting vector represented by a vector_expression from the operands |
| Cnormal_random_numbers | Random number generator for returning normally distributed values |
| Cshared_ptr | 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 |
| Csparse_matrix_adapted_iterator | A non-const iterator for sparse matrices of type std::vector<std::map<SizeT, NumericT> > |
| Csparse_matrix_adapter | Adapts a non-const sparse matrix type made up from std::vector<std::map<SizeT, NumericT> > to basic ublas-compatibility |
| Ctimer | Simple timer class based on gettimeofday (POSIX) or QueryPerformanceCounter (Windows) |
| Cuniform_random_numbers | Random number generator for returning uniformly distributed values in the closed interval [0, 1] |
| ►Ntraits | Namespace providing traits-information as well as generic wrappers to common routines for vectors and matrices such as size() or clear() |
| Ctag_of | Generic base for wrapping other linear algebra packages |
| Cadvanced_cuthill_mckee_tag | Tag for the advanced Cuthill-McKee algorithm (i.e. running the 'standard' Cuthill-McKee algorithm for a couple of different seeds) |
| Cbasic_range | A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded |
| Cbasic_slice | A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded |
| Ccirculant_matrix | A Circulant matrix class |
| Ccol_iteration | A tag indicating iteration along increasing columns index of a matrix |
| Ccolumn_major | A tag for column-major storage of a dense matrix |
| Ccolumn_major_tag | Tag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type |
| Ccompressed_compressed_matrix | A sparse square matrix in compressed sparse rows format optimized for the case that only a few rows carry nonzero entries |
| Ccompressed_matrix | A sparse square matrix in compressed sparse rows format |
| Cconst_entry_proxy | A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-users of the library |
| Cconst_vector_iterator | A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!! |
| Ccontext | Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also suitable for CUDA and OpenMP |
| Ccoordinate_matrix | 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 |
| Ccuda_not_available_exception | |
| Ccuthill_mckee_tag | A tag class for selecting the Cuthill-McKee algorithm for reducing the bandwidth of a sparse matrix |
| Cell_matrix | Sparse matrix class using the ELLPACK format for storing the nonzeros |
| Cenable_if | Simple enable-if variant that uses the SFINAE pattern |
| Centry_proxy | A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-users of the library |
| Cgibbs_poole_stockmeyer_tag | Tag class for identifying the Gibbs-Poole-Stockmeyer algorithm for reducing the bandwidth of a sparse matrix |
| Chankel_matrix | A Hankel matrix class |
| Chyb_matrix | Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros |
| Cidentity_matrix | 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 |
| Cimplicit_matrix_base | Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<> |
| Cimplicit_vector_base | Common base class for representing vectors where the entries are not all stored explicitly |
| Cis_addition | Helper metafunction for checking whether the provided type is viennacl::op_add (for addition) |
| Cis_any_dense_matrix | Checks for either matrix_base or implicit_matrix_base |
| Cis_any_dense_structured_matrix | Helper class for checking whether the provided type is any of the dense structured matrix types (circulant, Hankel, etc.) |
| Cis_any_scalar | Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy) |
| Cis_any_sparse_matrix | Helper class for checking whether the provided type is one of the sparse matrix types (compressed_matrix, coordinate_matrix, etc.) |
| Cis_any_vector | Checks for a type being either vector_base or implicit_vector_base |
| Cis_circulant_matrix | Helper class for checking whether a matrix is a circulant matrix |
| Cis_compressed_matrix | Helper class for checking whether a matrix is a compressed_matrix (CSR format) |
| Cis_coordinate_matrix | Helper class for checking whether a matrix is a coordinate_matrix (COO format) |
| Cis_cpu_scalar | Helper struct for checking whether a type is a host scalar type (e.g. float, double) |
| Cis_division | Helper metafunction for checking whether the provided type is viennacl::op_div (for division) |
| Cis_eigen | Meta function which checks whether a tag is tag_eigen |
| Cis_ell_matrix | Helper class for checking whether a matrix is an ell_matrix (ELL format) |
| Cis_flip_sign_scalar | Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<> |
| Cis_hankel_matrix | Helper class for checking whether a matrix is a Hankel matrix |
| Cis_hyb_matrix | Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR) |
| Cis_mtl4 | Meta function which checks whether a tag is tag_mtl4 |
| Cis_primitive_type | Helper class for checking whether a type is a primitive type |
| Cis_product | Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication) |
| Cis_row_major | Helper class for checking whether a matrix has a row-major layout |
| Cis_scalar | Helper struct for checking whether a type is a viennacl::scalar<> |
| Cis_sliced_ell_matrix | Helper class for checking whether a matrix is a sliced_ell_matrix (SELL-C- format) |
| Cis_stl | Meta function which checks whether a tag is tag_ublas |
| Cis_subtraction | Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction) |
| Cis_toeplitz_matrix | Helper class for checking whether a matrix is a Toeplitz matrix |
| Cis_ublas | Meta function which checks whether a tag is tag_ublas |
| Cis_vandermonde_matrix | Helper class for checking whether a matrix is a Vandermonde matrix |
| Cis_viennacl | Meta function which checks whether a tag is tag_viennacl |
| Cmatrix | A dense matrix class |
| Cmatrix_base | |
| Cmatrix_expression | Expression template class for representing a tree of expressions which ultimately result in a matrix |
| Cmatrix_iterator | A dense matrix class |
| Cmatrix_range | Class for representing non-strided submatrices of a bigger matrix A |
| Cmatrix_range< matrix_range< MatrixType > > | |
| Cmatrix_slice | Class for representing strided submatrices of a bigger matrix A |
| Cmatrix_slice< matrix_range< MatrixType > > | |
| Cmemory_exception | Exception class in case of memory errors |
| Cone_vector | |
| Cop_abs | A tag class representing the modulus function for integers |
| Cop_acos | A tag class representing the acos() function |
| Cop_add | A tag class representing addition |
| Cop_argmax | A tag class for representing the argmax() function |
| Cop_argmin | A tag class for representing the argmin() function |
| Cop_asin | A tag class representing the asin() function |
| Cop_assign | A tag class representing assignment |
| Cop_atan | A tag class representing the atan() function |
| Cop_atan2 | A tag class representing the atan2() function |
| Cop_ceil | A tag class representing the ceil() function |
| Cop_col_sum | A tag class representing the summation of all columns of a matrix |
| Cop_column | A tag class representing the extraction of a matrix column to a vector |
| Cop_cos | A tag class representing the cos() function |
| Cop_cosh | A tag class representing the cosh() function |
| Cop_div | A tag class representing division |
| Cop_element_binary | A tag class representing element-wise binary operations (like multiplication) on vectors or matrices |
| Cop_element_cast | A tag class representing element-wise casting operations on vectors and matrices |
| Cop_element_unary | A tag class representing element-wise unary operations (like sin()) on vectors or matrices |
| Cop_eq | A tag class representing equality |
| Cop_exp | A tag class representing the exp() function |
| Cop_fabs | A tag class representing the fabs() function |
| Cop_fdim | A tag class representing the fdim() function |
| Cop_flip_sign | A tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0) |
| Cop_floor | A tag class representing the floor() function |
| Cop_fmax | A tag class representing the fmax() function |
| Cop_fmin | A tag class representing the fmin() function |
| Cop_fmod | A tag class representing the fmod() function |
| Cop_geq | A tag class representing greater-than-or-equal-to |
| Cop_greater | A tag class representing greater-than |
| Cop_inner_prod | A tag class representing inner products of two vectors |
| Cop_inplace_add | A tag class representing inplace addition |
| Cop_inplace_sub | A tag class representing inplace subtraction |
| Cop_leq | A tag class representing less-than-or-equal-to |
| Cop_less | A tag class representing less-than |
| Cop_log | A tag class representing the log() function |
| Cop_log10 | A tag class representing the log10() function |
| Cop_mat_mat_prod | A tag class representing matrix-matrix products |
| Cop_matrix_diag | A tag class representing the (off-)diagonal of a matrix |
| Cop_max | A tag class representing the maximum of a vector |
| Cop_min | A tag class representing the minimum of a vector |
| Cop_mult | A tag class representing multiplication by a scalar |
| Cop_neq | A tag class representing inequality |
| Cop_norm_1 | A tag class representing the 1-norm of a vector |
| Cop_norm_2 | A tag class representing the 2-norm of a vector |
| Cop_norm_frobenius | A tag class representing the Frobenius-norm of a matrix |
| Cop_norm_inf | A tag class representing the inf-norm of a vector |
| Cop_pow | A tag class representing the power function |
| Cop_prod | A tag class representing matrix-vector products and element-wise multiplications |
| Cop_row | A tag class representing the extraction of a matrix row to a vector |
| Cop_row_sum | A tag class representing the summation of all rows of a matrix |
| Cop_sin | A tag class representing the sin() function |
| Cop_sinh | A tag class representing the sinh() function |
| Cop_sqrt | A tag class representing the sqrt() function |
| Cop_sub | A tag class representing subtraction |
| Cop_sum | A tag class representing the summation of a vector |
| Cop_tan | A tag class representing the tan() function |
| Cop_tanh | A tag class representing the tanh() function |
| Cop_trans | A tag class representing transposed matrices |
| Cop_vector_diag | A tag class representing a matrix given by a vector placed on a certain (off-)diagonal |
| Crow_iteration | A tag indicating iteration along increasing row index of a matrix |
| Crow_major | A tag for row-major storage of a dense matrix |
| Crow_major_tag | Tag class for indicating row-major layout of a matrix. Not passed to the matrix directly, see row_major type |
| Cscalar | This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type like float or double |
| Cscalar_expression | A proxy for scalar expressions (e.g. from inner vector products) |
| Cscalar_expression< LHS, RHS, op_inner_prod > | Specialization of a scalar expression for inner products. Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_max > | Specialization of a scalar expression for max(). Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_min > | Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_norm_1 > | Specialization of a scalar expression for norm_1. Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_norm_2 > | Specialization of a scalar expression for norm_2. Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_norm_frobenius > | Specialization of a scalar expression for norm_frobenius. Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_norm_inf > | Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU |
| Cscalar_expression< LHS, RHS, op_sum > | Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU |
| Cscalar_matrix | 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 |
| Cscalar_vector | 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 |
| Csliced_ell_matrix | Sparse matrix class using the sliced ELLPACK with parameters C, |
| Ctag_eigen | A tag class for identifying types from Eigen |
| Ctag_mtl4 | A tag class for identifying types from MTL4 |
| Ctag_none | A tag class for identifying 'unknown' types |
| Ctag_stl | A tag class for identifying types from the C++ STL |
| Ctag_ublas | A tag class for identifying types from uBLAS |
| Ctag_viennacl | A tag class for identifying types from ViennaCL |
| Ctoeplitz_matrix | A Toeplitz matrix class |
| Cunit_vector | Represents a vector consisting of 1 at a given index and zeros otherwise |
| Cunknown_norm_exception | |
| Cvandermonde_matrix | A Vandermonde matrix class |
| Cvector | |
| Cvector_base | Common base class for dense vectors, vector ranges, and vector slices |
| Cvector_expression | An expression template class that represents a binary operation that yields a vector |
| Cvector_iterator | A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! |
| Cvector_range | Class for representing non-strided subvectors of a bigger vector x |
| Cvector_range< vector_range< VectorType > > | |
| Cvector_slice | Class for representing strided subvectors of a bigger vector x |
| Cvector_slice< vector_slice< VectorType > > | |
| Cvector_tuple | Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie() |
| Czero_matrix | Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only |
| Czero_on_diagonal_exception | |
| Czero_vector | |
| Cdense_matrix | |
| Cmatrix_maker | |
| 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 > | |
| Cmy_inserter | |
| Cop_assign | |
| Cop_minus_assign | |
| Cop_plus_assign | |
| CtestData | |
| Cvector_proxy | |
| CViennaCLBackend_impl | Generic backend for CUDA, OpenCL, host-based stuff |
| CViennaCLCUDABackend_impl | |
| CViennaCLHostBackend_impl | |
| CViennaCLHostScalar_impl | |
| CViennaCLMatrix_impl | |
| CViennaCLOpenCLBackend_impl | |
| CViennaCLScalar_impl | |
| CViennaCLVector_impl | |