Cviennacl::ocl::accelerator_tag | A tag identifying OpenCL devices as accelerators (e.g. Intel Xeon Phi) |
Cviennacl::advanced_cuthill_mckee_tag | Tag 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_config | Configuration 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_point | A 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_pointvector | A 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_tag | A 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_config | Configuration struct for generating OpenCL kernels for linear combinations of viennacl::scalar<> objects |
►Cviennacl::tools::detail::aux | Interface for the reference counter inside the shared_ptr |
Cviennacl::tools::detail::auximpl< U, Deleter > | Implementation helper for the reference counting mechanism inside 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_tag | A tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function |
►Cviennacl::device_specific::binary_leaf | Binary leaf interface |
Cviennacl::device_specific::mapped_matrix_column | Matrix column |
Cviennacl::device_specific::mapped_matrix_diag | Matrix diag |
Cviennacl::device_specific::mapped_matrix_product | Matrix product |
Cviennacl::device_specific::mapped_matrix_row | Matrix row |
►Cviennacl::device_specific::mapped_reduction | Reduction |
Cviennacl::device_specific::mapped_row_wise_reduction | Vector reduction |
Cviennacl::device_specific::mapped_scalar_reduction | Scalar reduction |
Cviennacl::device_specific::mapped_trans | Trans |
Cviennacl::device_specific::mapped_vector_diag | Vector diag |
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_matrix | Represents contigious matrices on GPU |
Cviennacl::linalg::detail::spai::block_vector | Represents a contiguous vector on the GPU to represent a concatentation of small vectors |
Cviennacl::linalg::cg_tag | A 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::classcomp | Comparison 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_iteration | A tag indicating iteration along increasing columns index of a matrix |
Cviennacl::column_major | A tag for column-major storage of a dense matrix |
Cviennacl::column_major_tag | Tag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type |
Cviennacl::ocl::command_queue | A class representing a command queue |
Cviennacl::linalg::detail::spai::CompareSecond | Helper 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::tools::sparse_matrix_adapter< NumericT, SizeT > | Adapts a non-const 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::vector_iterator< SCALARTYPE, ALIGNMENT > | A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! |
Cviennacl::context | Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also suitable for CUDA and OpenMP |
Cviennacl::ocl::context | Manages 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::count | Reference 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_tag | A 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_tag | A 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_tag | A tag denoting the default OpenCL device type (SDK-specific) |
Cdense_matrix< T > | |
Cviennacl::ocl::device | A 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::cuda_not_available_exception | |
Cviennacl::device_specific::generator_not_supported_exception | Exception for the case the generator is unable to deal with the operation |
Cviennacl::device_specific::template_base::invalid_template_exception | |
Cviennacl::memory_exception | Exception class in case of memory errors |
Cviennacl::ocl::build_program_failure | Exception thrown if the OpenCL program cannot be built, usually due to a syntax error in the OpenCL code |
Cviennacl::ocl::compiler_not_available | Exception thrown if the OpenCL just-in-time compiler is not available |
Cviennacl::ocl::device_not_available | Exception thrown if the selected compute device is not available (maybe locked by another process) |
Cviennacl::ocl::device_not_found | Exception thrown in the case that a requested compute device was not found |
Cviennacl::ocl::double_precision_not_provided_error | Exception thrown if the user wants to use double precision arithmetics, but the device does not support double precision |
Cviennacl::ocl::image_format_mismatch | Exception thrown if there is a mismatch in image formats for the operands |
Cviennacl::ocl::image_format_not_supported | Exception thrown if the requested image format is not supported |
Cviennacl::ocl::invalid_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 |
Cviennacl::ocl::invalid_arg_size | Exception thrown if the arguments to an OpenCL kernel have an invalid size e.g. not sizeof(cl_mem)) |
Cviennacl::ocl::invalid_arg_value | Exception thrown if the kernel argument provided has an invalid value |
Cviennacl::ocl::invalid_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) |
Cviennacl::ocl::invalid_buffer_size | Exception thrown if the provided buffer size is invalid (e.g. zero) |
Cviennacl::ocl::invalid_build_options | Exception thrown if invalid build options are passed to the OpenCL just-in-time compiler |
Cviennacl::ocl::invalid_command_queue | Exception thrown if an invalid OpenCL command queue is provided to an OpenCL function |
Cviennacl::ocl::invalid_context | Exception thrown if an invalid OpenCL context is provided to an OpenCL function |
Cviennacl::ocl::invalid_device | Exception thrown if an invalid OpenCL device is provided to an OpenCL function |
Cviennacl::ocl::invalid_device_type | Exception thrown if an invalid device type is specified |
Cviennacl::ocl::invalid_event | Exception thrown if the provided event object (of type cl_event) is invalid |
Cviennacl::ocl::invalid_event_wait_list | Exception thrown if the provided event wait list is invalid |
Cviennacl::ocl::invalid_gl_object | Exception thrown if the provided OpenGL (not OpenCL) object is invalid |
Cviennacl::ocl::invalid_global_offset | Exception thrown if the provided offset for get_global_id() in OpenCL kernels is invalid |
Cviennacl::ocl::invalid_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) |
Cviennacl::ocl::invalid_host_ptr | Exception thrown if the provided pointer to host memory is invalid |
Cviennacl::ocl::invalid_image_format_descriptor | Exception thrown if an invalid image format descriptor is provided |
Cviennacl::ocl::invalid_image_size | Exception thrown if the image size provided is invalid (e.g. zero) |
Cviennacl::ocl::invalid_kernel | Exception thrown if the provided kernel object (of type cl_kernel) is invalid (e.g. not initialized, from different context, or corrupted) |
Cviennacl::ocl::invalid_kernel_args | Exception thrown if the kernel arguments are invalid and/or do not fit the kernel parameter list |
Cviennacl::ocl::invalid_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 |
Cviennacl::ocl::invalid_kernel_name | Exception thrown if the provided kernel name is invalid (e.g. not part of the program provided) |
Cviennacl::ocl::invalid_mem_object | Exception thrown if an invalid OpenCL memory object (of type cl_mem) is passed to an OpenCL funciton |
Cviennacl::ocl::invalid_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 |
Cviennacl::ocl::invalid_operation | Exception thrown if interoperability of OpenCL with other frameworks collide |
Cviennacl::ocl::invalid_platform | Exception thrown if an invalid OpenCL platform is provided to an OpenCL function |
Cviennacl::ocl::invalid_program | Exception thrown if an OpenCL program object handle is invalid (e.g. not initialized) |
Cviennacl::ocl::invalid_program_executable | Exception thrown if there is no built program exectuable available for the device |
Cviennacl::ocl::invalid_property | Exception thrown if an invalid property is provided to a function (vague value) |
Cviennacl::ocl::invalid_queue_properties | Exception thrown if invalid OpenCL command queue properties are provided when creating a command queue |
Cviennacl::ocl::invalid_sampler | Exception thrown if an invalid sampler is provided for an image |
Cviennacl::ocl::invalid_value | Exception thrown is an invalid value is provided to an OpenCL function |
Cviennacl::ocl::invalid_work_dimension | Exception thrown if the work dimension is invalid (usually this means that the work dimension was set to be larger than three |
Cviennacl::ocl::invalid_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 |
Cviennacl::ocl::invalid_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 |
Cviennacl::ocl::map_failure | Exception thrown if the mapping of device memory to the host memory space failed |
Cviennacl::ocl::mem_copy_overlap | Exception thrown if the source buffer overlaps the destination buffer when copying from device memory to device memory |
Cviennacl::ocl::mem_object_allocation_failure | Exception thrown if a memory object cannot be allocated. Usually the requested memory buffer is simply too large |
Cviennacl::ocl::out_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 |
Cviennacl::ocl::out_of_resources | Exception thrown if the compute device is out of resources (either global memory, registers, etc.) for the requested operation |
Cviennacl::ocl::profiling_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 |
Cviennacl::ocl::unknown_error | Exception thrown if the returned error cannot be resolved to some defined error constant. Might result from invalid sources, invalid memory operations, etc |
Cviennacl::scheduler::statement_not_supported_exception | Exception for the case the scheduler is unable to deal with the operation |
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_tag | A tag for FSPAI. Experimental |
Cviennacl::gibbs_poole_stockmeyer_tag | Tag class for identifying the Gibbs-Poole-Stockmeyer algorithm for reducing the bandwidth of a sparse matrix |
Cviennacl::linalg::gmres_tag | A tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function |
Cviennacl::ocl::gpu_tag | A 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_tag | A 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_tag | A 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_tag | A 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::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 |
Cviennacl::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 |
Cviennacl::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 |
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::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 |
Cviennacl::zero_vector< NumericT > | |
Cviennacl::unit_vector< NumericT > | Represents a vector consisting of 1 at a given index and zeros otherwise |
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- 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_tag | A tag for a jacobi preconditioner |
Cviennacl::ocl::kernel | Represents an OpenCL kernel within ViennaCL |
Cviennacl::linalg::lanczos_tag | A 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_element | A class representing the 'data' for the LHS or RHS operand of the respective node |
Cviennacl::ocl::local_mem | A class representing local (shared) OpenCL memory. Typically used as kernel argument |
Cviennacl::device_specific::template_base::loop_body_base | |
Cviennacl::linalg::lower_tag | A tag class representing a lower triangular matrix |
►Cviennacl::device_specific::mapped_object | Mapped Object |
►Cviennacl::device_specific::mapped_handle | Handle |
►Cviennacl::device_specific::mapped_buffer | Buffered |
Cviennacl::device_specific::mapped_matrix | Matrix |
Cviennacl::device_specific::mapped_vector | Vector |
Cviennacl::device_specific::mapped_scalar | Scalar |
Cviennacl::device_specific::mapped_host_scalar | Host scalar |
Cviennacl::device_specific::mapped_implicit_matrix | Implicit matrix |
Cviennacl::device_specific::mapped_implicit_vector | Implicit vector |
Cviennacl::device_specific::mapped_matrix_column | Matrix column |
Cviennacl::device_specific::mapped_matrix_diag | Matrix diag |
Cviennacl::device_specific::mapped_matrix_product | Matrix product |
Cviennacl::device_specific::mapped_matrix_row | Matrix row |
Cviennacl::device_specific::mapped_reduction | Reduction |
Cviennacl::device_specific::mapped_trans | Trans |
Cviennacl::device_specific::mapped_vector_diag | Vector diag |
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_range< MatrixType > | Class for representing non-strided submatrices of a bigger matrix A |
Cviennacl::matrix_range< matrix_range< MatrixType > > | |
Cviennacl::matrix_slice< MatrixType > | Class for representing strided submatrices of a bigger matrix A |
Cviennacl::matrix_slice< matrix_range< MatrixType > > | |
►Cviennacl::matrix_base< NumericT > | |
Cviennacl::matrix< SCALARTYPE, F, ALIGNMENT > | A dense matrix class |
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_handle | Main 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_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function |
►Cviennacl::device_specific::mapped_object::MorphBase | |
Cviennacl::device_specific::mapped_object::MorphBase1D | |
Cviennacl::device_specific::mapped_object::MorphBase2D | |
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_config | Configuration class for the nonnegative-matrix-factorization algorithm. Specify tolerances, maximum iteration counts, etc., here |
Cviennacl::linalg::no_precond | A 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_abs | A tag class representing the modulus function for integers |
Cviennacl::op_acos | A tag class representing the acos() function |
Cviennacl::op_add | A tag class representing addition |
Cviennacl::linalg::detail::op_applier< OpT > | Worker class for decomposing expression templates |
Cviennacl::op_argmax | A tag class for representing the argmax() function |
Cviennacl::op_argmin | A tag class for representing the argmin() function |
Cviennacl::op_asin | A tag class representing the asin() function |
Cop_assign | |
Cviennacl::op_assign | A tag class representing assignment |
Cviennacl::op_atan | A tag class representing the atan() function |
Cviennacl::op_atan2 | A tag class representing the atan2() function |
Cviennacl::op_ceil | A tag class representing the ceil() function |
Cviennacl::op_column | A tag class representing the extraction of a matrix column to a vector |
Cviennacl::op_cos | A tag class representing the cos() function |
Cviennacl::op_cosh | A tag class representing the cosh() function |
Cviennacl::op_div | A tag class representing division |
Cviennacl::scheduler::op_element | Struct 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_eq | A tag class representing equality |
Cviennacl::linalg::detail::op_executor< A, OP, T > | Worker class for decomposing expression templates |
Cviennacl::op_exp | A tag class representing the exp() function |
Cviennacl::op_fabs | A tag class representing the fabs() function |
Cviennacl::op_fdim | A tag class representing the fdim() function |
Cviennacl::op_flip_sign | A tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0) |
Cviennacl::op_floor | A tag class representing the floor() function |
Cviennacl::op_fmax | A tag class representing the fmax() function |
Cviennacl::op_fmin | A tag class representing the fmin() function |
Cviennacl::op_fmod | A tag class representing the fmod() function |
Cviennacl::op_geq | A tag class representing greater-than-or-equal-to |
Cviennacl::op_greater | A tag class representing greater-than |
Cviennacl::op_inner_prod | A tag class representing inner products of two vectors |
Cviennacl::op_inplace_add | A tag class representing inplace addition |
Cviennacl::op_inplace_sub | A tag class representing inplace subtraction |
Cviennacl::op_leq | A tag class representing less-than-or-equal-to |
Cviennacl::op_less | A tag class representing less-than |
Cviennacl::op_log | A tag class representing the log() function |
Cviennacl::op_log10 | A tag class representing the log10() function |
Cviennacl::op_mat_mat_prod | A tag class representing matrix-matrix products |
Cviennacl::op_matrix_diag | A tag class representing the (off-)diagonal of a matrix |
Cviennacl::op_max | A tag class representing the maximum of a vector |
Cviennacl::op_min | A tag class representing the minimum of a vector |
Cop_minus_assign | |
Cviennacl::op_mult | A tag class representing multiplication by a scalar |
Cviennacl::op_neq | A tag class representing inequality |
Cviennacl::op_norm_1 | A tag class representing the 1-norm of a vector |
Cviennacl::op_norm_2 | A tag class representing the 2-norm of a vector |
Cviennacl::op_norm_frobenius | A tag class representing the Frobenius-norm of a matrix |
Cviennacl::op_norm_inf | A tag class representing the inf-norm of a vector |
Cop_plus_assign | |
Cviennacl::op_pow | A tag class representing the power function |
Cviennacl::op_prod | A 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_row | A tag class representing the extraction of a matrix row to a vector |
Cviennacl::op_sin | A tag class representing the sin() function |
Cviennacl::op_sinh | A tag class representing the sinh() function |
Cviennacl::op_sqrt | A tag class representing the sqrt() function |
Cviennacl::op_sub | A tag class representing subtraction |
Cviennacl::op_tan | A tag class representing the tan() function |
Cviennacl::op_tanh | A tag class representing the tanh() function |
Cviennacl::op_trans | A 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_diag | A tag class representing a matrix given by a vector placed on a certain (off-)diagonal |
►Costream | |
Cviennacl::device_specific::utils::kernel_generation_stream | |
Cviennacl::ocl::packed_cl_uint | Helper 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::device_specific::matrix_axpy_parameters_type | |
Cviennacl::device_specific::matrix_product_parameters | |
Cviennacl::device_specific::reduction_parameters | |
Cviennacl::device_specific::row_wise_reduction_parameters | |
Cviennacl::device_specific::vector_axpy_parameters | |
Cviennacl::ocl::platform | Wrapper class for an OpenCL platform |
Cviennacl::linalg::power_iter_tag | A tag for the power iteration algorithm |
Cviennacl::ocl::program | Wrapper 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_iteration | A tag indicating iteration along increasing row index of a matrix |
Cviennacl::row_major | A tag for row-major storage of a dense matrix |
Cviennacl::device_specific::utils::row_major_fun | |
Cviennacl::row_major_tag | Tag 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_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 |
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, |
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_tag | A 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::statement | The main class for representing a statement such as x = inner_prod(y,z); at runtime |
Cviennacl::scheduler::statement_node | Main 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::device_specific::bind_all_unique | |
Cviennacl::device_specific::bind_to_handle | |
Cviennacl::tag_eigen | A tag class for identifying types from Eigen |
Cviennacl::tag_mtl4 | A tag class for identifying types from MTL4 |
Cviennacl::tag_none | A tag class for identifying 'unknown' types |
Cviennacl::traits::tag_of< T, Active > | Generic base for wrapping other linear algebra packages |
Cviennacl::tag_stl | A tag class for identifying types from the C++ STL |
Cviennacl::tag_ublas | A tag class for identifying types from uBLAS |
Cviennacl::tag_viennacl | A tag class for identifying types from ViennaCL |
►Cviennacl::device_specific::template_base | |
►Cviennacl::device_specific::template_base_impl< matrix_axpy_template, matrix_axpy_parameters_type > | |
Cviennacl::device_specific::matrix_axpy_template | |
►Cviennacl::device_specific::template_base_impl< matrix_product_template, matrix_product_parameters > | |
Cviennacl::device_specific::matrix_product_template | |
►Cviennacl::device_specific::template_base_impl< reduction_template, reduction_parameters > | |
Cviennacl::device_specific::reduction_template | |
►Cviennacl::device_specific::template_base_impl< row_wise_reduction_template, row_wise_reduction_parameters > | |
Cviennacl::device_specific::row_wise_reduction_template | |
►Cviennacl::device_specific::template_base_impl< vector_axpy_template, vector_axpy_parameters > | |
Cviennacl::device_specific::vector_axpy_template | |
Cviennacl::device_specific::template_base_impl< TemplateType, ParametersType > | |
CtestData | |
Cviennacl::tools::timer | Simple 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_functor | Base functor class for traversing a statement |
Cviennacl::device_specific::tree_parsing::evaluate_expression_traversal | Functor for generating the expression string from a statement |
Cviennacl::device_specific::tree_parsing::filter | |
Cviennacl::device_specific::tree_parsing::filter_elements | |
Cviennacl::device_specific::tree_parsing::process_traversal | Functor for fetching or writing-back the elements in a statement |
Cviennacl::device_specific::tree_parsing::statement_representation_functor | |
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_tag | A tag class representing a lower triangular matrix with unit diagonal |
Cviennacl::linalg::unit_upper_tag | A tag class representing an upper triangular matrix with unit diagonal |
Cviennacl::linalg::upper_tag | A 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< NumericT > | |
Cviennacl::vector< NumericT, AlignmentV > | |
Cviennacl::vector< NumericType > | |
Cviennacl::vector< ScalarType > | |
Cviennacl::vector< unsigned int > | |
Cviennacl::vector< SCALARTYPE, ALIGNMENT > | |
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::vector_range< VectorType > | Class for representing non-strided subvectors of a bigger vector x |
Cviennacl::vector_range< vector_range< VectorType > > | |
Cviennacl::vector_slice< VectorType > | Class for representing strided subvectors of a bigger vector x |
Cviennacl::vector_slice< vector_slice< VectorType > > | |
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_impl | Generic 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 > | |