ViennaCL - The Vienna Computing Library: Class List

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

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234567]

►N viennacl | Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them
►N backend | Namespace providing routines for handling the different memory domains
►N cpu_ram | Provides implementations for handling memory buffers in CPU RAM
►N detail | Holds implementation details for handling memory buffers in CPU RAM. Not intended for direct use by library users
C array_deleter | Helper struct for deleting an pointer to an array
►N cuda | Provides implementations for handling CUDA memory buffers
►N detail | Holds implementation details for handling CUDA memory buffers. Not intended for direct use by library users
C cuda_deleter | Functor for deleting a CUDA handle. Used within the smart pointer class
C cuda_exception |
►N detail | Implementation details for the generic memory backend interface
C convert_to_opencl | Helper struct for converting a type to its OpenCL pendant
►N opencl | Provides implementations for handling OpenCL memory buffers
C mem_handle | Main abstraction class for multiple memory domains. Represents a buffer in either main RAM, an OpenCL context, or a CUDA device
C typesafe_host_array | Helper class implementing an array on the host. Default case: No conversion necessary
C typesafe_host_array< T, true > | Special host array type for conversion between OpenCL types and pure CPU types
►N detail | Holds implementation details for functionality in the main viennacl-namespace. Not intended for direct use by library users
►N fft | Helper namespace for fast Fourier transforms. Not to be used directly by library users
►N device_specific | Provides an OpenCL kernel generator
►N builtin_database |
►N devices |
►N accelerator |
►N cpu |
►N gpu |
►N amd |
►N evergreen |
►N northern_islands |
►N southern_islands |
►N volcanic_islands |
►N nvidia |
►N fermi |
►N kepler |
►N maxwell |
►N tesla |
►C database_type |
C device_architecture_t |
C device_name_t |
C device_type_t |
C expression_t |
C type |
►N tree_parsing |
C evaluate_expression_traversal | Functor for generating the expression string from a statement
C filter |
C filter_elements |
C process_traversal | Functor for fetching or writing-back the elements in a statement
C statement_representation_functor |
C traversal_functor | Base functor class for traversing a statement
►N utils | Contains various helper routines for kernel generation
C first_letter_of_type |
C first_letter_of_type< char > |
C first_letter_of_type< double > |
C first_letter_of_type< float > |
C first_letter_of_type< int > |
C first_letter_of_type< long > |
C first_letter_of_type< short > |
C first_letter_of_type< unsigned char > |
C first_letter_of_type< unsigned int > |
C first_letter_of_type< unsigned long > |
C first_letter_of_type< unsigned short > |
C handle_fun |
C internal_size1_fun |
C internal_size2_fun |
C internal_size_fun |
C is_same_type |
C is_same_type< T, T > |
C kernel_generation_stream |
C leading_start |
C leading_stride |
C row_major_fun |
C scalartype_size_fun |
C size1_fun |
C size2_fun |
C size_fun |
C start1_fun |
C start2_fun |
C stride1_fun |
C stride2_fun |
C stride_fun |
C type_to_string |
C type_to_string< char > |
C type_to_string< double > |
C type_to_string< float > |
C type_to_string< int > |
C type_to_string< long > |
C type_to_string< short > |
C type_to_string< unsigned char > |
C type_to_string< unsigned int > |
C type_to_string< unsigned long > |
C type_to_string< unsigned short > |
C binary_leaf | Binary leaf interface
C bind_all_unique |
C bind_to_handle |
C char_to_type |
C execution_handler |
C generator_not_supported_exception | Exception for the case the generator is unable to deal with the operation
C index_tuple |
C lazy_program_compiler |
C mapped_buffer | Buffered
C mapped_handle | Handle
C mapped_host_scalar | Host scalar
C mapped_implicit_matrix | Implicit matrix
C mapped_implicit_vector | Implicit vector
C mapped_matrix | Matrix
C mapped_matrix_column | Matrix column
C mapped_matrix_diag | Matrix diag
C mapped_matrix_product | Matrix product
C mapped_matrix_row | Matrix row
►C mapped_object | Mapped Object
C MorphBase |
C MorphBase1D |
C MorphBase2D |
C node_info |
C mapped_reduction | Reduction
C mapped_row_wise_reduction | Vector reduction
C mapped_scalar | Scalar
C mapped_scalar_reduction | Scalar reduction
C mapped_trans | Trans
C mapped_vector | Vector
C mapped_vector_diag | Vector diag
C matrix_product_parameters |
C matrix_product_template |
C statements_container |
C symbolic_binder |
►C template_base |
C invalid_template_exception |
C loop_body_base |
C parameters_type |
C template_base_impl |
►N io | Provides basic input-output functionality
►N linalg | Provides all linear algebra operations which are not covered by operator overloads
►N cuda | Holds all CUDA compute kernels used by ViennaCL
►N detail | Helper functions for the CUDA linear algebra backend
C spmv_alpha_beta |
C spmv_pure |
C type_to_type2 |
C type_to_type2< double > |
C type_to_type2< float > |
C mat_mult_matrix_index | Helper struct for accessing an element of a row- or column-major matrix
►N detail | Namespace holding implementation details for linear algebra routines. Usually not of interest for a library user
►N amg | Implementation namespace for algebraic multigrid preconditioner
C amg_level_context |
►N spai | Implementation namespace for sparse approximate inverse preconditioner
C block_matrix | Represents contigious matrices on GPU
C block_vector | Represents a contiguous vector on the GPU to represent a concatentation of small vectors
C CompareSecond | Helper functor for comparing std::pair<> based on the second member
C fspai_tag | A tag for FSPAI. Experimental
C spai_tag | A tag for SPAI
C sparse_vector | Represents a sparse vector based on std::map<unsigned int, NumericT>
C FastMatrix | Internal helper class representing a row-major dense matrix used for the QR method for the purpose of computing eigenvalues
C ilu_vector_range | Helper range class for representing a subvector of a larger buffer
C ilut_sparse_vector | Helper struct for holding a sparse vector in linear memory. For internal use only
C InputData | In this class the input matrix is stored
C op_applier | Worker class for decomposing expression templates
C op_executor | Worker class for decomposing expression templates
C ResultDataLarge | In this class the data of the result for large matrices is stored
C ResultDataSmall | In this class the data of the result for small matrices is stored
C z_handler | Handles the no_precond case at minimal overhead
C z_handler< VectorT, viennacl::linalg::no_precond > |
►N host_based | Holds all compute kernels with conventional host-based execution (buffers in CPU RAM)
►N amg |
C amg_id_influence | Helper struct for sequential classical one-pass coarsening
►N detail | Helper functions for the host-based linear algebra backend
►N fft |
C matrix_array_wrapper | Helper array for accessing a strided submatrix embedded in a larger matrix
C vector_array_wrapper | Helper class for accessing a strided subvector of a larger vector
C spgemm_output_write_disabled |
C spgemm_output_write_enabled |
►N opencl | Holds all routines providing OpenCL linear algebra operations
►N kernels | Contains the OpenCL kernel generation functions for a predefined set of functionality
C ambm_config | Configuration struct for generating OpenCL kernels for linear combinations of matrices
C amg | Main kernel class for generating OpenCL kernels for compressed_matrix
C asbs_config | Configuration struct for generating OpenCL kernels for linear combinations of viennacl::scalar<> objects
C avbv_config | Configuration struct for generating OpenCL kernels for linear combinations of vectors
C bisect_kernel | Main kernel class for the generation of the bisection kernels and utilities
C compressed_compressed_matrix | Main kernel class for generating OpenCL kernels for compressed_compressed_matrix
C compressed_matrix | Main kernel class for generating OpenCL kernels for compressed_matrix (except solvers)
C compressed_matrix_solve | Main kernel class for triangular solver OpenCL kernels for compressed_matrix
C coordinate_matrix | Main kernel class for generating OpenCL kernels for coordinate_matrix
C ell_matrix | Main kernel class for generating OpenCL kernels for ell_matrix
C fft | Main kernel class for generating OpenCL kernels for the fast Fourier transform
C hyb_matrix | Main kernel class for generating OpenCL kernels for hyb_matrix
C ilu | Main kernel class for generating OpenCL kernels for incomplete LU factorization preconditioners
C iterative | Main kernel class for generating specialized OpenCL kernels for fast iterative solvers
C matrix | Main kernel class for generating OpenCL kernels for operations on/with dense matrix objects of type viennacl::matrix<>
C matrix_convert | Main kernel class for vector conversion routines (e.g. convert vector<int> to vector<float>)
C matrix_element | Main kernel class for generating OpenCL kernels for elementwise-operations such as element_sin() on/with dense matrix objects of type viennacl::matrix<>
C matrix_legacy | Main kernel class for generating OpenCL kernels for operations on/with dense matrix objects of type viennacl::matrix<>
C matrix_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
C matrix_solve | Main kernel class for the generation of matrix solve kernels
C nmf | Main kernel class for generating OpenCL kernels for nonnegative matrix factorization of a dense matrices
C scalar | Main kernel class for generating OpenCL kernels for operations involving viennacl::scalar<>, but not viennacl::vector<> or viennacl::matrix<>
C scan | Main kernel class for generating OpenCL kernels for singular value decomposition of dense matrices
C sliced_ell_matrix | Main kernel class for generating OpenCL kernels for ell_matrix
C sliced_ell_matrix< NumericT, unsigned int > |
C spai | Main kernel class for generating OpenCL kernels for the sparse approximate inverse preconditioners
C svd | Main kernel class for generating OpenCL kernels for singular value decomposition of dense matrices
C vector | 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
C vector_convert | Main kernel class for vector conversion routines (e.g. convert vector<int> to vector<float>)
C vector_element | Main kernel class for generating OpenCL kernels for elementwise operations other than addition and subtraction on/with viennacl::vector<>
C vector_multi_inner_prod | Main kernel class for generating OpenCL kernels for multiple inner products on/with viennacl::vector<>
C amg_coarse_problem_too_large_exception |
C amg_precond | AMG preconditioner class, can be supplied to solve()-routines
C amg_precond< compressed_matrix< NumericT, AlignmentV > > | AMG preconditioner class, can be supplied to solve()-routines
C amg_tag | A tag for algebraic multigrid (AMG). Used to transport information from the user to the implementation
C bicgstab_solver |
C bicgstab_tag | A tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function
C block_ilu_precond | A block ILU preconditioner class, can be supplied to solve()-routines
C block_ilu_precond< compressed_matrix< NumericT, AlignmentV >, ILUTagT > | ILUT preconditioner class, can be supplied to solve()-routines
C cg_solver |
C cg_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function
C chow_patel_icc_precond | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines
C chow_patel_icc_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines
C chow_patel_ilu_precond | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines
C chow_patel_ilu_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | Parallel Chow-Patel ILU preconditioner class, can be supplied to solve()-routines
C chow_patel_tag | A tag for incomplete LU and incomplete Cholesky factorization with static pattern (Parallel-ILU0, Parallel ICC0)
C fspai_precond | Implementation of the Factored SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type
C fspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > > | Implementation of the Factored SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix
C gmres_solver |
C gmres_tag | A tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function
C ichol0_precond | Incomplete Cholesky preconditioner class with static pattern (ICHOL0), can be supplied to solve()-routines
C ichol0_precond< compressed_matrix< NumericT, AlignmentV > > | ILU0 preconditioner class, can be supplied to solve()-routines
C ichol0_tag | A tag for incomplete Cholesky factorization with static pattern (ILU0)
C ilu0_precond | ILU0 preconditioner class, can be supplied to solve()-routines
C ilu0_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | ILU0 preconditioner class, can be supplied to solve()-routines
C ilu0_tag | A tag for incomplete LU factorization with static pattern (ILU0)
C ilut_precond | ILUT preconditioner class, can be supplied to solve()-routines
C ilut_precond< viennacl::compressed_matrix< NumericT, AlignmentV > > | ILUT preconditioner class, can be supplied to solve()-routines
C ilut_tag | A tag for incomplete LU factorization with threshold (ILUT)
C jacobi_precond | Jacobi preconditioner class, can be supplied to solve()-routines. Generic version for non-ViennaCL matrices
C jacobi_precond< MatrixT, true > | Jacobi preconditioner class, can be supplied to solve()-routines
C jacobi_tag | A tag for a jacobi preconditioner
C lanczos_tag | A tag for the lanczos algorithm
C lower_tag | A tag class representing a lower triangular matrix
C mixed_precision_cg_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function
C nmf_config | Configuration class for the nonnegative-matrix-factorization algorithm. Specify tolerances, maximum iteration counts, etc., here
C no_precond | A tag class representing the use of no preconditioner
C power_iter_tag | A tag for the power iteration algorithm
C row_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
C row_scaling< MatrixType, true > | Jacobi preconditioner class, can be supplied to solve()-routines
C 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
C spai_precond | Implementation of the SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type
C spai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > > | Implementation of the SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix
C unit_lower_tag | A tag class representing a lower triangular matrix with unit diagonal
C unit_upper_tag | A tag class representing an upper triangular matrix with unit diagonal
C upper_tag | A tag class representing an upper triangular matrix
►N ocl | OpenCL backend. Manages platforms, contexts, buffers, kernels, etc
C accelerator_tag | A tag identifying OpenCL devices as accelerators (e.g. Intel Xeon Phi)
C backend | A backend that provides contexts for ViennaCL objects (vector, matrix, etc.)
C build_program_failure | Exception thrown if the OpenCL program cannot be built, usually due to a syntax error in the OpenCL code
C command_queue | A class representing a command queue
C compiler_not_available | Exception thrown if the OpenCL just-in-time compiler is not available
C context | Manages an OpenCL context and provides the respective convenience functions for creating buffers, etc
C cpu_tag | A tag identifying OpenCL devices as CPUs
C default_tag | A tag denoting the default OpenCL device type (SDK-specific)
C device | A class representing a compute device (e.g. a GPU)
C device_not_available | Exception thrown if the selected compute device is not available (maybe locked by another process)
C device_not_found | Exception thrown in the case that a requested compute device was not found
C DOUBLE_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
C double_precision_not_provided_error | Exception thrown if the user wants to use double precision arithmetics, but the device does not support double precision
C error_checker | An error reporting class. Template argument is used to avoid problems with external linkage
C gpu_tag | A tag identifying OpenCL devices as GPUs
C handle | Handle class the effectively represents a smart pointer for OpenCL handles
C handle_inc_dec_helper | Helper for OpenCL reference counting used by class handle
C image_format_mismatch | Exception thrown if there is a mismatch in image formats for the operands
C image_format_not_supported | Exception thrown if the requested image format is not supported
C 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
C invalid_arg_size | Exception thrown if the arguments to an OpenCL kernel have an invalid size e.g. not sizeof(cl_mem))
C invalid_arg_value | Exception thrown if the kernel argument provided has an invalid value
C 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)
C invalid_buffer_size | Exception thrown if the provided buffer size is invalid (e.g. zero)
C invalid_build_options | Exception thrown if invalid build options are passed to the OpenCL just-in-time compiler
C invalid_command_queue | Exception thrown if an invalid OpenCL command queue is provided to an OpenCL function
C invalid_context | Exception thrown if an invalid OpenCL context is provided to an OpenCL function
C invalid_device | Exception thrown if an invalid OpenCL device is provided to an OpenCL function
C invalid_device_type | Exception thrown if an invalid device type is specified
C invalid_event | Exception thrown if the provided event object (of type cl_event) is invalid
C invalid_event_wait_list | Exception thrown if the provided event wait list is invalid
C invalid_gl_object | Exception thrown if the provided OpenGL (not OpenCL) object is invalid
C invalid_global_offset | Exception thrown if the provided offset for get_global_id() in OpenCL kernels is invalid
C 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)
C invalid_host_ptr | Exception thrown if the provided pointer to host memory is invalid
C invalid_image_format_descriptor | Exception thrown if an invalid image format descriptor is provided
C invalid_image_size | Exception thrown if the image size provided is invalid (e.g. zero)
C invalid_kernel | Exception thrown if the provided kernel object (of type cl_kernel) is invalid (e.g. not initialized, from different context, or corrupted)
C invalid_kernel_args | Exception thrown if the kernel arguments are invalid and/or do not fit the kernel parameter list
C 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
C invalid_kernel_name | Exception thrown if the provided kernel name is invalid (e.g. not part of the program provided)
C invalid_mem_object | Exception thrown if an invalid OpenCL memory object (of type cl_mem) is passed to an OpenCL funciton
C 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
C invalid_operation | Exception thrown if interoperability of OpenCL with other frameworks collide
C invalid_platform | Exception thrown if an invalid OpenCL platform is provided to an OpenCL function
C invalid_program | Exception thrown if an OpenCL program object handle is invalid (e.g. not initialized)
C invalid_program_executable | Exception thrown if there is no built program exectuable available for the device
C invalid_property | Exception thrown if an invalid property is provided to a function (vague value)
C invalid_queue_properties | Exception thrown if invalid OpenCL command queue properties are provided when creating a command queue
C invalid_sampler | Exception thrown if an invalid sampler is provided for an image
C invalid_value | Exception thrown is an invalid value is provided to an OpenCL function
C 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
C 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
C 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
C kernel | Represents an OpenCL kernel within ViennaCL
C kernel_not_found |
C local_mem | A class representing local (shared) OpenCL memory. Typically used as kernel argument
C map_failure | Exception thrown if the mapping of device memory to the host memory space failed
C mem_copy_overlap | Exception thrown if the source buffer overlaps the destination buffer when copying from device memory to device memory
C mem_object_allocation_failure | Exception thrown if a memory object cannot be allocated. Usually the requested memory buffer is simply too large
C 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
C out_of_resources | Exception thrown if the compute device is out of resources (either global memory, registers, etc.) for the requested operation
C packed_cl_uint | Helper class for packing four cl_uint numbers into a uint4 type for access inside an OpenCL kernel
C platform | Wrapper class for an OpenCL platform
C 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
C program | Wrapper class for an OpenCL program
C program_not_found |
C queue_not_found |
C type_to_string | Helper class for converting a type to its string representation
C 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
►N result_of | Namespace containing many meta-functions
C alignment | Retrieves the alignment from a vector. Deprecated - will be replaced by a pure runtime facility in the future
C cl_type | Metafunction for deducing the OpenCL type for a numeric type, e.g. float -> cl_float
C cpu_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
C size_type | Generic meta-function for retrieving the size_type associated with type T
C value_type | Generic helper function for retrieving the value_type associated with type T
►N scheduler | Contains the scheduling functionality which allows for dynamic kernel generation as well as the fusion of multiple statements into a single kernel
►N result_of | Helper metafunctions used for the scheduler
C num_nodes |
C num_nodes< const matrix_expression< LHS, RHS, OP > > |
C num_nodes< const scalar_expression< LHS, RHS, OP > > |
C num_nodes< const vector_expression< LHS, RHS, OP > > |
C num_nodes< matrix_expression< LHS, RHS, OP > > |
C num_nodes< scalar_expression< LHS, RHS, OP > > |
C num_nodes< vector_expression< LHS, RHS, OP > > |
C numeric_type_id | Helper metafunction for obtaining the runtime type ID for a numerical type
C op_type_info | Metafunction for querying type informations
C lhs_rhs_element | A class representing the 'data' for the LHS or RHS operand of the respective node
C op_element | Struct for holding the type family as well as the type of an operation (could be addition, subtraction, norm, etc.)
C statement | The main class for representing a statement such as x = inner_prod(y,z); at runtime
C statement_node | Main datastructure for an node in the statement tree
C statement_not_supported_exception | Exception for the case the scheduler is unable to deal with the operation
►N tools | Namespace for various tools used within ViennaCL
►N detail | Contains implementation details for the tools. Usually not of interest for the library user
C aux | Interface for the reference counter inside the shared_ptr
C auximpl | Implementation helper for the reference counting mechanism inside shared_ptr
C count | Reference counting class for the shared_ptr implementation
C default_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'
C sha1 |
C CHECK_SCALAR_TEMPLATE_ARGUMENT | A guard that checks whether the floating point type of GPU types is either float or double
C CONST_REMOVER | Removes the const qualifier from a type
C const_sparse_matrix_adapted_iterator | A const iterator for sparse matrices of type std::vector<std::map<SizeT, NumericT> >
C const_sparse_matrix_adapter | Adapts a constant sparse matrix type made up from std::vector<std::map<SizeT, NumericT> > to basic ublas-compatibility
C CPU_SCALAR_TYPE_DEDUCER | Obtain the cpu scalar type from a type, including a GPU type like viennacl::scalar<T>
C MATRIX_ITERATOR_INCREMENTER | Helper class for incrementing an iterator in a dense matrix
C MATRIX_SIZE_DEDUCER | Deduces the size of the resulting vector represented by a vector_expression from the operands
C normal_random_numbers | Random number generator for returning normally distributed values
C shared_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
C sparse_matrix_adapted_iterator | A non-const iterator for sparse matrices of type std::vector<std::map<SizeT, NumericT> >
C sparse_matrix_adapter | Adapts a non-const sparse matrix type made up from std::vector<std::map<SizeT, NumericT> > to basic ublas-compatibility
C timer | Simple timer class based on gettimeofday (POSIX) or QueryPerformanceCounter (Windows)
C uniform_random_numbers | Random number generator for returning uniformly distributed values in the closed interval [0, 1]
►N traits | Namespace providing traits-information as well as generic wrappers to common routines for vectors and matrices such as size() or clear()
C tag_of | Generic base for wrapping other linear algebra packages
C 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)
C basic_range | A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded
C basic_slice | A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded
C circulant_matrix | A Circulant matrix class
C col_iteration | A tag indicating iteration along increasing columns index of a matrix
C column_major | A tag for column-major storage of a dense matrix
C column_major_tag | Tag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type
C compressed_compressed_matrix | A sparse square matrix in compressed sparse rows format optimized for the case that only a few rows carry nonzero entries
C compressed_matrix | A sparse square matrix in compressed sparse rows format
C const_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
C const_vector_iterator | A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!!
C context | Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also suitable for CUDA and OpenMP
C coordinate_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
C cuda_not_available_exception |
C cuthill_mckee_tag | A tag class for selecting the Cuthill-McKee algorithm for reducing the bandwidth of a sparse matrix
C ell_matrix | Sparse matrix class using the ELLPACK format for storing the nonzeros
C enable_if | Simple enable-if variant that uses the SFINAE pattern
C 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
C gibbs_poole_stockmeyer_tag | Tag class for identifying the Gibbs-Poole-Stockmeyer algorithm for reducing the bandwidth of a sparse matrix
C hankel_matrix | A Hankel matrix class
C hyb_matrix | Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros
C identity_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
C implicit_matrix_base | Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<>
C implicit_vector_base | Common base class for representing vectors where the entries are not all stored explicitly
C is_addition | Helper metafunction for checking whether the provided type is viennacl::op_add (for addition)
C is_any_dense_matrix | Checks for either matrix_base or implicit_matrix_base
C is_any_dense_structured_matrix | Helper class for checking whether the provided type is any of the dense structured matrix types (circulant, Hankel, etc.)
C is_any_scalar | Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy)
C is_any_sparse_matrix | Helper class for checking whether the provided type is one of the sparse matrix types (compressed_matrix, coordinate_matrix, etc.)
C is_any_vector | Checks for a type being either vector_base or implicit_vector_base
C is_circulant_matrix | Helper class for checking whether a matrix is a circulant matrix
C is_compressed_matrix | Helper class for checking whether a matrix is a compressed_matrix (CSR format)
C is_coordinate_matrix | Helper class for checking whether a matrix is a coordinate_matrix (COO format)
C is_cpu_scalar | Helper struct for checking whether a type is a host scalar type (e.g. float, double)
C is_division | Helper metafunction for checking whether the provided type is viennacl::op_div (for division)
C is_eigen | Meta function which checks whether a tag is tag_eigen
C is_ell_matrix | Helper class for checking whether a matrix is an ell_matrix (ELL format)
C is_flip_sign_scalar | Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<>
C is_hankel_matrix | Helper class for checking whether a matrix is a Hankel matrix
C is_hyb_matrix | Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR)
C is_mtl4 | Meta function which checks whether a tag is tag_mtl4
C is_primitive_type | Helper class for checking whether a type is a primitive type
C is_product | Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication)
C is_row_major | Helper class for checking whether a matrix has a row-major layout
C is_scalar | Helper struct for checking whether a type is a viennacl::scalar<>
C is_sliced_ell_matrix | Helper class for checking whether a matrix is a sliced_ell_matrix (SELL-C- format)
C is_stl | Meta function which checks whether a tag is tag_ublas
C is_subtraction | Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction)
C is_toeplitz_matrix | Helper class for checking whether a matrix is a Toeplitz matrix
C is_ublas | Meta function which checks whether a tag is tag_ublas
C is_vandermonde_matrix | Helper class for checking whether a matrix is a Vandermonde matrix
C is_viennacl | Meta function which checks whether a tag is tag_viennacl
C matrix | A dense matrix class
C matrix_base |
C matrix_expression | Expression template class for representing a tree of expressions which ultimately result in a matrix
C matrix_iterator | A dense matrix class
C matrix_range | Class for representing non-strided submatrices of a bigger matrix A
C matrix_range< matrix_range< MatrixType > > |
C matrix_slice | Class for representing strided submatrices of a bigger matrix A
C matrix_slice< matrix_range< MatrixType > > |
C memory_exception | Exception class in case of memory errors
C one_vector |
C op_abs | A tag class representing the modulus function for integers
C op_acos | A tag class representing the acos() function
C op_add | A tag class representing addition
C op_argmax | A tag class for representing the argmax() function
C op_argmin | A tag class for representing the argmin() function
C op_asin | A tag class representing the asin() function
C op_assign | A tag class representing assignment
C op_atan | A tag class representing the atan() function
C op_atan2 | A tag class representing the atan2() function
C op_ceil | A tag class representing the ceil() function
C op_col_sum | A tag class representing the summation of all columns of a matrix
C op_column | A tag class representing the extraction of a matrix column to a vector
C op_cos | A tag class representing the cos() function
C op_cosh | A tag class representing the cosh() function
C op_div | A tag class representing division
C op_element_binary | A tag class representing element-wise binary operations (like multiplication) on vectors or matrices
C op_element_cast | A tag class representing element-wise casting operations on vectors and matrices
C op_element_unary | A tag class representing element-wise unary operations (like sin()) on vectors or matrices
C op_eq | A tag class representing equality
C op_exp | A tag class representing the exp() function
C op_fabs | A tag class representing the fabs() function
C op_fdim | A tag class representing the fdim() function
C op_flip_sign | A tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0)
C op_floor | A tag class representing the floor() function
C op_fmax | A tag class representing the fmax() function
C op_fmin | A tag class representing the fmin() function
C op_fmod | A tag class representing the fmod() function
C op_geq | A tag class representing greater-than-or-equal-to
C op_greater | A tag class representing greater-than
C op_inner_prod | A tag class representing inner products of two vectors
C op_inplace_add | A tag class representing inplace addition
C op_inplace_sub | A tag class representing inplace subtraction
C op_leq | A tag class representing less-than-or-equal-to
C op_less | A tag class representing less-than
C op_log | A tag class representing the log() function
C op_log10 | A tag class representing the log10() function
C op_mat_mat_prod | A tag class representing matrix-matrix products
C op_matrix_diag | A tag class representing the (off-)diagonal of a matrix
C op_max | A tag class representing the maximum of a vector
C op_min | A tag class representing the minimum of a vector
C op_mult | A tag class representing multiplication by a scalar
C op_neq | A tag class representing inequality
C op_norm_1 | A tag class representing the 1-norm of a vector
C op_norm_2 | A tag class representing the 2-norm of a vector
C op_norm_frobenius | A tag class representing the Frobenius-norm of a matrix
C op_norm_inf | A tag class representing the inf-norm of a vector
C op_pow | A tag class representing the power function
C op_prod | A tag class representing matrix-vector products and element-wise multiplications
C op_row | A tag class representing the extraction of a matrix row to a vector
C op_row_sum | A tag class representing the summation of all rows of a matrix
C op_sin | A tag class representing the sin() function
C op_sinh | A tag class representing the sinh() function
C op_sqrt | A tag class representing the sqrt() function
C op_sub | A tag class representing subtraction
C op_sum | A tag class representing the summation of a vector
C op_tan | A tag class representing the tan() function
C op_tanh | A tag class representing the tanh() function
C op_trans | A tag class representing transposed matrices
C op_vector_diag | A tag class representing a matrix given by a vector placed on a certain (off-)diagonal
C row_iteration | A tag indicating iteration along increasing row index of a matrix
C row_major | A tag for row-major storage of a dense matrix
C row_major_tag | Tag class for indicating row-major layout of a matrix. Not passed to the matrix directly, see row_major type
C scalar | This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type like float or double
C scalar_expression | A proxy for scalar expressions (e.g. from inner vector products)
C scalar_expression< LHS, RHS, op_inner_prod > | Specialization of a scalar expression for inner products. Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_max > | Specialization of a scalar expression for max(). Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_min > | Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_norm_1 > | Specialization of a scalar expression for norm_1. Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_norm_2 > | Specialization of a scalar expression for norm_2. Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_norm_frobenius > | Specialization of a scalar expression for norm_frobenius. Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_norm_inf > | Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU
C scalar_expression< LHS, RHS, op_sum > | Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU
C scalar_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
C scalar_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
C sliced_ell_matrix | Sparse matrix class using the sliced ELLPACK with parameters C,
C tag_eigen | A tag class for identifying types from Eigen
C tag_mtl4 | A tag class for identifying types from MTL4
C tag_none | A tag class for identifying 'unknown' types
C tag_stl | A tag class for identifying types from the C++ STL
C tag_ublas | A tag class for identifying types from uBLAS
C tag_viennacl | A tag class for identifying types from ViennaCL
C toeplitz_matrix | A Toeplitz matrix class
C unit_vector | Represents a vector consisting of 1 at a given index and zeros otherwise
C unknown_norm_exception |
C vandermonde_matrix | A Vandermonde matrix class
C vector |
C vector_base | Common base class for dense vectors, vector ranges, and vector slices
C vector_expression | An expression template class that represents a binary operation that yields a vector
C vector_iterator | A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!!
C vector_range | Class for representing non-strided subvectors of a bigger vector x
C vector_range< vector_range< VectorType > > |
C vector_slice | Class for representing strided subvectors of a bigger vector x
C vector_slice< vector_slice< VectorType > > |
C vector_tuple | Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie()
C zero_matrix | Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only
C zero_on_diagonal_exception |
C zero_vector |
C dense_matrix |
C matrix_maker |
C matrix_maker< boost::numeric::ublas::matrix< T >, F > |
C matrix_maker< boost::numeric::ublas::matrix_range< MatrixT >, F > |
C matrix_maker< boost::numeric::ublas::matrix_slice< MatrixT >, F > |
C my_inserter |
C op_assign |
C op_minus_assign |
C op_plus_assign |
C testData |
C vector_proxy |
C ViennaCLBackend_impl | Generic backend for CUDA, OpenCL, host-based stuff
C ViennaCLCUDABackend_impl |
C ViennaCLHostBackend_impl |
C ViennaCLHostScalar_impl |
C ViennaCLMatrix_impl |
C ViennaCLOpenCLBackend_impl |
C ViennaCLScalar_impl |
C ViennaCLVector_impl |