ViennaCL - The Vienna Computing Library  1.5.0
Data Structures
Here are the data structures with brief descriptions:
accelerator_tagA tag identifying OpenCL devices as accelerators (e.g. Intel Xeon Phi)
advanced_cuthill_mckee_tagTag for the advanced Cuthill-McKee algorithm (i.e. running the 'standard' Cuthill-McKee algorithm for a couple of different seeds)
alignment< T >Retrieves the alignment from a vector. Deprecated - will be replaced by a pure runtime facility in the future
ambm_configConfiguration struct for generating OpenCL kernels for linear combinations of matrices
amg_nonzero_scalar< InternalType, IteratorType, ScalarType >A class for a scalar that can be written to the sparse matrix or sparse vector datatypes
amg_pointA class for the AMG points. Saves point index and influence measure Holds information whether point is undecided, C or F point. Holds lists of points that are influenced by or influencing this point
amg_pointvectorA class for the AMG points. Holds pointers of type amg_point in a vector that can be accessed using [point-index]. Additional list of pointers sorted by influence number and index to improve coarsening performance (see amg_coarse_classic_onepass() in amg_coarse.hpp) Constructs indices for C points on the coarse level, needed for interpolation
amg_precond< MatrixType >AMG preconditioner class, can be supplied to solve()-routines
amg_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >AMG preconditioner class, can be supplied to solve()-routines
amg_slicing< InternalType1, InternalType2 >A class for the matrix slicing for parallel coarsening schemes (RS0/RS3)
amg_sparsematrix< ScalarType >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
amg_sparsevector< ScalarType >A class for the sparse vector type
amg_sparsevector_iterator< InternalType >Defines an iterator for the sparse vector type
amg_tagA tag for algebraic multigrid (AMG). Used to transport information from the user to the implementation
array_deleter< U >Helper struct for deleting an pointer to an array
asbs_configConfiguration struct for generating OpenCL kernels for linear combinations of viennacl::scalar<> objects
auxInterface for the reference counter inside the shared_ptr
auximpl< U, Deleter >Implementation helper for the reference counting mechanism inside shared_ptr
avbv_configConfiguration struct for generating OpenCL kernels for linear combinations of vectors
backend< dummy >A backend that provides contexts for ViennaCL objects (vector, matrix, etc.)
basic_range< SizeType, DistanceType >A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded
basic_slice< SizeType, DistanceType >A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded
bicgstab_tagA tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function
block_ilu_precond< MatrixType, ILUTag >A block ILU preconditioner class, can be supplied to solve()-routines
block_ilu_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT >, ILUTag >ILUT preconditioner class, can be supplied to solve()-routines
block_matrixRepresents a contigious matrices on GPU
block_vectorRepresents a contigious vector on GPU
build_program_failureException thrown if the OpenCL program cannot be built, usually due to a syntax error in the OpenCL code
cg_tagA tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function
CHECK_SCALAR_TEMPLATE_ARGUMENT< T >A guard that checks whether the floating point type of GPU types is either float or double
circulant_matrix< SCALARTYPE, ALIGNMENT >A Circulant matrix class
cl_type< T >Metafunction for deducing the OpenCL type for a numeric type, e.g. float -> cl_float
classcompComparison class for the sorted set of points in amg_pointvector. Set is sorted by influence measure from lower to higher with the point-index as tie-breaker
code_generatorClass for handling code generation
col_iterationA tag indicating iteration along increasing columns index of a matrix
column_majorA tag for column-major storage of a dense matrix
column_major_tagTag class for indicating column-major layout of a matrix. Not passed to the matrix directly, see row_major type
command_queueA class representing a command queue
CompareSecondHelper functor for comparing std::pair<> based on the second member
compiler_not_availableException thrown if the OpenCL just-in-time compiler is not available
compressed_compressed_matrix< SCALARTYPE >A sparse square matrix in compressed sparse rows format optimized for the case that only a few rows carry nonzero entries
compressed_compressed_matrix< NumericT >Main kernel class for generating OpenCL kernels for compressed_compressed_matrix
compressed_matrix< SCALARTYPE, ALIGNMENT >A sparse square matrix in compressed sparse rows format
compressed_matrix< NumericT >Main kernel class for generating OpenCL kernels for compressed_matrix
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
CONST_REMOVER< T >Removes the const qualifier from a type
const_sparse_matrix_adapted_iterator< SCALARTYPE, SizeType, is_iterator1, is_forward >A const iterator for sparse matrices of type std::vector<std::map<SizeType, SCALARTYPE> >
const_sparse_matrix_adapter< SCALARTYPE, SizeType >Adapts a constant sparse matrix type made up from std::vector<std::map<SizeType, SCALARTYPE> > to basic ublas-compatibility
const_vector_iterator< SCALARTYPE, ALIGNMENT >A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be manipulated. VERY SLOW!!
contextRepresents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also suitable for CUDA and OpenMP
contextManages an OpenCL context and provides the respective convenience functions for creating buffers, etc
convert_to_opencl< T >Helper struct for converting a type to its OpenCL pendant
coordinate_matrix< SCALARTYPE, ALIGNMENT >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
coordinate_matrix< NumericT >Main kernel class for generating OpenCL kernels for coordinate_matrix
countReference counting class for the shared_ptr implementation
CPU_SCALAR_TYPE_DEDUCER< T >Obtain the cpu scalar type from a type, including a GPU type like viennacl::scalar<T>
cpu_tagA tag identifying OpenCL devices as CPUs
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
cuda_deleter< U >Functor for deleting a CUDA handle. Used within the smart pointer class
cuda_not_available_exception
cuthill_mckee_tagA tag class for selecting the Cuthill-McKee algorithm for reducing the bandwidth of a sparse matrix
database_typeRepresents vendor->device_type in the map hierarchy vendor->device_type->device_arch->device->expression->profile
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'
default_tagA tag denoting the default OpenCL device type (SDK-specific)
deviceA class representing a compute device (e.g. a GPU)
device_architecture_mapRepresents device_arch->device in the map hierarchy vendor->device_type->device_arch->device->expression->profile
device_name_mapRepresents device->expression in the map hierarchy vendor->device_type->device_arch->device->expression->profile
device_not_availableException thrown if the selected compute device is not available (maybe locked by another process)
device_not_foundException thrown in the case that a requested compute device was not found
device_type_mapRepresents device_type->device_arch in the map hierarchy vendor->device_type->device_arch->device->expression->profile
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
double_precision_not_provided_errorException thrown if the user wants to use double precision arithmetics, but the device does not support double precision
ell_matrix< NumericT >Main kernel class for generating OpenCL kernels for ell_matrix
ell_matrix< SCALARTYPE, ALIGNMENT >Sparse matrix class using the ELLPACK format for storing the nonzeros
enable_if< b, T >Simple enable-if variant that uses the SFINAE pattern
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
error_checker< T >An error reporting class. Template argument is used to avoid problems with external linkage
expression_descriptorA class for holding meta information such as the type or the underlying scalar type of an expression (such as x = inner_prod(y, z))
expression_generation_traversalFunctor for generating the expression string from a statement
expression_mapRepresents expression->profile in the map hierarchy vendor->device_type->device_arch->device->expression->profile
FastMatrix< SCALARTYPE >Internal helper class representing a row-major dense matrix used for the QR method for the purpose of computing eigenvalues
fetch_traversalFunctor for fetching the elements of a statement
fft< NumericT >Main kernel class for generating OpenCL kernels for the fast Fourier transform
fspai_precond< MatrixType >Implementation of the Factored SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type
fspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >Implementation of the Factored SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix
fspai_tagA tag for FSPAI. Experimental. Contains values for the algorithm. Must be passed to spai_precond constructor
gibbs_poole_stockmeyer_tagTag class for identifying the Gibbs-Poole-Stockmeyer algorithm for reducing the bandwidth of a sparse matrix
gmres_tagA tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function
gpu_tagA tag identifying OpenCL devices as GPUs
handle< OCL_TYPE >Handle class the effectively represents a smart pointer for OpenCL handles
handle_funFunctor for obtaining the OpenCL handle from ViennaCL objects (vector, matrix, etc.)
handle_inc_dec_helper< OCL_TYPE >Helper for OpenCL reference counting used by class handle
hankel_matrix< SCALARTYPE, ALIGNMENT >A Hankel matrix class
hyb_matrix< SCALARTYPE, ALIGNMENT >Sparse matrix class using a hybrid format composed of the ELL and CSR format for storing the nonzeros
hyb_matrix< NumericT >Main kernel class for generating OpenCL kernels for hyb_matrix
ichol0_precond< MatrixType >Incomplete Cholesky preconditioner class with static pattern (ICHOL0), can be supplied to solve()-routines
ichol0_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >ILU0 preconditioner class, can be supplied to solve()-routines
ichol0_tagA tag for incomplete Cholesky factorization with static pattern (ILU0)
identity_matrix< SCALARTYPE >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
ilu< NumericT >Main kernel class for generating OpenCL kernels for incomplete LU factorization preconditioners
ilu0_precond< MatrixType >ILU0 preconditioner class, can be supplied to solve()-routines
ilu0_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >ILU0 preconditioner class, can be supplied to solve()-routines
ilu0_tagA tag for incomplete LU factorization with static pattern (ILU0)
ilu_vector_range< VectorType, ValueType, SizeType >Helper range class for representing a subvector of a larger buffer
ilut_precond< MatrixType >ILUT preconditioner class, can be supplied to solve()-routines
ilut_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >ILUT preconditioner class, can be supplied to solve()-routines
ilut_tagA tag for incomplete LU factorization with threshold (ILUT)
image_format_mismatchException thrown if there is a mismatch in image formats for the operands
image_format_not_supportedException thrown if the requested image format is not supported
implicit_matrix_base< SCALARTYPE >Base class for representing matrices where the individual entries are not all stored explicitly, e.g. identity_matrix<>
implicit_vector_base< SCALARTYPE >Common base class for representing vectors where the entries are not all stored explicitly
internal_size1_funFunctor for obtaining the internal number of rows of a ViennaCL matrix
internal_size2_funFunctor for obtaining the internal number of columns of a ViennaCL matrix
internal_size_funFunctor for returning the internal size of a vector
invalid_arg_indexException thrown if the kernel argument index is invalid, e.g. an arg index larger than the number of kernel arguments was provided
invalid_arg_sizeException thrown if the arguments to an OpenCL kernel have an invalid size e.g. not sizeof(cl_mem))
invalid_arg_valueException thrown if the kernel argument provided has an invalid value
invalid_binaryException 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)
invalid_buffer_sizeException thrown if the provided buffer size is invalid (e.g. zero)
invalid_build_optionsException thrown if invalid build options are passed to the OpenCL just-in-time compiler
invalid_command_queueException thrown if an invalid OpenCL command queue is provided to an OpenCL function
invalid_contextException thrown if an invalid OpenCL context is provided to an OpenCL function
invalid_deviceException thrown if an invalid OpenCL device is provided to an OpenCL function
invalid_device_typeException thrown if an invalid device type is specified
invalid_eventException thrown if the provided event object (of type cl_event) is invalid
invalid_event_wait_listException thrown if the provided event wait list is invalid
invalid_gl_objectException thrown if the provided OpenGL (not OpenCL) object is invalid
invalid_global_offsetException thrown if the provided offset for get_global_id() in OpenCL kernels is invalid
invalid_global_work_sizeException thrown if the total number of work items is invalid (for example, not divisible by the number of work items per work group)
invalid_host_ptrException thrown if the provided pointer to host memory is invalid
invalid_image_format_descriptorException thrown if an invalid image format descriptor is provided
invalid_image_sizeException thrown if the image size provided is invalid (e.g. zero)
invalid_kernelException thrown if the provided kernel object (of type cl_kernel) is invalid (e.g. not initialized, from different context, or corrupted)
invalid_kernel_argsException thrown if the kernel arguments are invalid and/or do not fit the kernel parameter list
invalid_kernel_definitionException 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
invalid_kernel_nameException thrown if the provided kernel name is invalid (e.g. not part of the program provided)
invalid_mem_objectException thrown if an invalid OpenCL memory object (of type cl_mem) is passed to an OpenCL funciton
invalid_mip_levelException thrown if the provided miplevel is greater than zero, but the OpenGL implementation does not support creating from non-zero mipmap levels
invalid_operationException thrown if interoperability of OpenCL with other frameworks collide
invalid_platformException thrown if an invalid OpenCL platform is provided to an OpenCL function
invalid_programException thrown if an OpenCL program object handle is invalid (e.g. not initialized)
invalid_program_executableException thrown if there is no built program exectuable available for the device
invalid_propertyException thrown if an invalid property is provided to a function (vague value)
invalid_queue_propertiesException thrown if invalid OpenCL command queue properties are provided when creating a command queue
invalid_samplerException thrown if an invalid sampler is provided for an image
invalid_valueException thrown is an invalid value is provided to an OpenCL function
invalid_work_dimensionException thrown if the work dimension is invalid (usually this means that the work dimension was set to be larger than three
invalid_work_group_sizeException 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
invalid_work_item_sizeException 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
is_addition< T >Helper metafunction for checking whether the provided type is viennacl::op_add (for addition)
is_any_dense_matrix< T >Checks for either matrix_base or implicit_matrix_base
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.)
is_any_scalar< T >Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy)
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.)
is_any_vector< T >Checks for a type being either vector_base or implicit_vector_base
is_circulant_matrix< T >Helper class for checking whether a matrix is a circulant matrix
is_compressed_matrix< T >Helper class for checking whether a matrix is a compressed_matrix (CSR format)
is_coordinate_matrix< T >Helper class for checking whether a matrix is a coordinate_matrix (COO format)
is_cpu_scalar< T >Helper struct for checking whether a type is a host scalar type (e.g. float, double)
is_division< T >Helper metafunction for checking whether the provided type is viennacl::op_div (for division)
is_eigen< Tag >Meta function which checks whether a tag is tag_eigen
is_ell_matrix< T >Helper class for checking whether a matrix is an ell_matrix (ELL format)
is_flip_sign_scalar< T >Helper struct for checking whether a type represents a sign flip on a viennacl::scalar<>
is_hankel_matrix< T >Helper class for checking whether a matrix is a Hankel matrix
is_hyb_matrix< T >Helper class for checking whether a matrix is a hyb_matrix (hybrid format: ELL plus CSR)
is_mtl4< Tag >Meta function which checks whether a tag is tag_mtl4
is_primitive_type< T >Helper class for checking whether a type is a primitive type
is_product< T >Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication)
is_row_major< T >Helper class for checking whether a matrix has a row-major layout
is_same_type< T, U >Helper metafunction for checking whether two types are the same
is_scalar< T >Helper struct for checking whether a type is a viennacl::scalar<>
is_stl< Tag >Meta function which checks whether a tag is tag_ublas
is_subtraction< T >Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction)
is_toeplitz_matrix< T >Helper class for checking whether a matrix is a Toeplitz matrix
is_ublas< Tag >Meta function which checks whether a tag is tag_ublas
is_vandermonde_matrix< T >Helper class for checking whether a matrix is a Vandermonde matrix
is_viennacl< Tag >Meta function which checks whether a tag is tag_viennacl
jacobi_precond< MatrixType, is_viennacl >Jacobi preconditioner class, can be supplied to solve()-routines. Generic version for non-ViennaCL matrices
jacobi_precond< MatrixType, true >Jacobi preconditioner class, can be supplied to solve()-routines
jacobi_tagA tag for a jacobi preconditioner
kernelRepresents an OpenCL kernel within ViennaCL
kernel_generation_streamA stream class where the kernel sources are streamed to. Takes care of indentation of the sources
lanczos_tagA tag for the lanczos algorithm
layout_type_id< F >Helper metafunction for obtaining the memory layout (row-/column-major) for a matrix
lhs_rhs_elementA class representing the 'data' for the LHS or RHS operand of the respective node
local_memA class representing local (shared) OpenCL memory. Typically used as kernel argument
lower_tagA tag class representing a lower triangular matrix
majority_struct_for_orientation< T >Returns the row_major or column_major class of a dense matrix based on the majority-tag (layout-tag) provided
map_failureException thrown if the mapping of device memory to the host memory space failed
map_functorFunctor to map the statements to the types defined in mapped_objects.hpp
map_wrapper< KeyType, ValueType >Helper struct for mapping a std::map<KeyType, ValueType>. Used to avoids type length explosion when using nested std::map directly
mapped_binary_leafBase class for mapping binary leaves (inner product-based, matrix vector product-base, matrix-matrix product based...)
mapped_bufferBase class for mapping buffer-based objects to a generator class
mapped_handleBase class for datastructures passed by pointer
mapped_host_scalarMapping of a host scalar to a generator class
mapped_implicit_matrixMapping of a implicit matrix to a generator class
mapped_implicit_vectorMapping of a implicit vector to a generator class
mapped_matrixMapping of a matrix to a generator class
mapped_matrix_productMapping of a matrix product
mapped_objectBase class for mapping viennacl datastructure to generator-friendly structures
mapped_reductionBase class for mapping a reduction
mapped_scalarMapping of a scalar to a generator class
mapped_scalar_reductionMapping of a scalar reduction (based on inner product)
mapped_vectorMapping of a vector to a generator class
mapped_vector_reductionMapping of a vector reduction (based on matrix-vector product)
mat_mult_matrix_index< LayoutT >Helper struct for accessing an element of a row- or column-major matrix
matrix< NumericT, F >Main kernel class for generating OpenCL kernels for operations on/with dense matrix objects of type viennacl::matrix<>
matrix< SCALARTYPE, F, ALIGNMENT >A dense matrix class
matrix_array_wrapper< NumericT, MajorityCategory, is_transposed >Helper array for accessing a strided submatrix embedded in a larger matrix
matrix_base< SCALARTYPE, F, SizeType, DistanceType >A dense matrix class
matrix_element< NumericT, F >Main kernel class for generating OpenCL kernels for elementwise-operations such as element_sin() on/with dense matrix objects of type viennacl::matrix<>
matrix_expression< LHS, RHS, OP >Expression template class for representing a tree of expressions which ultimately result in a matrix
matrix_iterator< ROWCOL, MATRIXTYPE >UBLAS-like iterator class for iterating over the entries of a dense matrix
MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE >Helper class for incrementing an iterator in a dense matrix
matrix_prod< NumericT, F_A, F_B, F_C >Main kernel class for the generation of matrix-matrix product kernels C = A * B
matrix_productKernel generation class for matrix-matrix products
matrix_range< MatrixType >Class for representing non-strided submatrices of a bigger matrix A
matrix_saxpyOpenCL kernel generation class for matrix expressions of AXPY type, i.e. A = alpha * B + beta * C, where the number of summands can in principle be arbitrarily large
MATRIX_SIZE_DEDUCER< LHS, RHS, OP >Deduces the size of the resulting vector represented by a vector_expression from the operands
matrix_slice< MatrixType >Class for representing strided submatrices of a bigger matrix A
matrix_solve< NumericT, F1, F2 >Main kernel class for the generation of matrix solve kernels
mem_copy_overlapException thrown if the source buffer overlaps the destination buffer when copying from device memory to device memory
mem_handleMain abstraction class for multiple memory domains. Represents a buffer in either main RAM, an OpenCL context, or a CUDA device
mem_object_allocation_failureException thrown if a memory object cannot be allocated. Usually the requested memory buffer is simply too large
memory_exceptionException class in case of memory errors
mixed_precision_cg_tagA tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function
nmf< NumericT >Main kernel class for generating OpenCL kernels for nonnegative matrix factorization of a dense matrices
nmf_configConfiguration class for the nonnegative-matrix-factorization algorithm. Specify tolerances, maximum iteration counts, etc., here
no_precondA tag class representing the use of no preconditioner
num_nodes< T >Helper metafunction for obtaining the number of nodes of an expression template tree
numeric_type_id< T >Helper metafunction for obtaining the runtime type ID for a numerical type
one_vector< SCALARTYPE >Represents a vector consisting of ones only
op_absA tag class representing the modulus function for integers
op_acosA tag class representing the acos() function
op_addA tag class representing addition
op_applier< OP >Worker class for decomposing expression templates
op_asinA tag class representing the asin() function
op_assignA tag class representing assignment
op_atanA tag class representing the atan() function
op_atan2A tag class representing the atan2() function
op_ceilA tag class representing the ceil() function
op_columnA tag class representing the extraction of a matrix column to a vector
op_cosA tag class representing the cos() function
op_coshA tag class representing the cosh() function
op_divA tag class representing division
op_elementStruct for holding the type family as well as the type of an operation (could be addition, subtraction, norm, etc.)
op_element_binary< OP >A tag class representing element-wise binary operations (like multiplication) on vectors or matrices
op_element_unary< OP >A tag class representing element-wise unary operations (like sin()) on vectors or matrices
op_executor< A, OP, T >Worker class for decomposing expression templates
op_expA tag class representing the exp() function
op_fabsA tag class representing the fabs() function
op_fdimA tag class representing the fdim() function
op_flip_signA tag class representing sign flips (for scalars only. Vectors and matrices use the standard multiplication by the scalar -1.0)
op_floorA tag class representing the floor() function
op_fmaxA tag class representing the fmax() function
op_fminA tag class representing the fmin() function
op_fmodA tag class representing the fmod() function
op_inner_prodA tag class representing inner products of two vectors
op_inplace_addA tag class representing inplace addition
op_inplace_subA tag class representing inplace subtraction
op_logA tag class representing the log() function
op_log10A tag class representing the log10() function
op_mat_mat_prodA tag class representing matrix-matrix products
op_matrix_diagA tag class representing the (off-)diagonal of a matrix
op_multA tag class representing multiplication by a scalar
op_norm_1A tag class representing the 1-norm of a vector
op_norm_2A tag class representing the 2-norm of a vector
op_norm_frobeniusA tag class representing the Frobenius-norm of a matrix
op_norm_infA tag class representing the inf-norm of a vector
op_powA tag class representing the power function
op_prodA tag class representing matrix-vector products and element-wise multiplications
op_rowA tag class representing the extraction of a matrix row to a vector
op_sinA tag class representing the sin() function
op_sinhA tag class representing the sinh() function
op_sqrtA tag class representing the sqrt() function
op_subA tag class representing subtraction
op_tanA tag class representing the tan() function
op_tanhA tag class representing the tanh() function
op_transA tag class representing transposed matrices
op_type_info< T >Helper metafunction for obtaining the operation ID as well as the operation family for unary and binary operations on vectors and matrices
op_vector_diagA tag class representing a matrix given by a vector placed on a certain (off-)diagonal
orientation_functor< T >Returns the orientation functor tag (either row_major or column_major) of a matrix
out_of_host_memoryException thrown if the host cannot provide enough memory for the datastructures in the OpenCL backend (temporary arrays, etc.) to perform the requested operation
out_of_resourcesException thrown if the compute device is out of resources (either global memory, registers, etc.) for the requested operation
packed_cl_uintHelper class for packing four cl_uint numbers into a uint4 type for access inside an OpenCL kernel
platformWrapper class for an OpenCL platform
power_iter_tagA tag for the power iteration algorithm
profile_baseBase class for an operation profile
profiling_info_not_availableException 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
programWrapper class for an OpenCL program
prototype_generation_traversalFunctor for generating the prototype of a statement
row_iterationA tag indicating iteration along increasing row index of a matrix
row_majorA tag for row-major storage of a dense matrix
row_major_tagTag class for indicating row-major layout of a matrix. Not passed to the matrix directly, see row_major type
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
row_scaling< MatrixType, true >Jacobi preconditioner class, can be supplied to solve()-routines
row_scaling_tagA tag for a row scaling preconditioner which merely normalizes the equation system such that each row of the system matrix has unit norm
scalar< TYPE >Main kernel class for generating OpenCL kernels for operations involving viennacl::scalar<>, but not viennacl::vector<> or viennacl::matrix<>
scalar< SCALARTYPE >This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type like float or double
scalar_expression< LHS, RHS, OP >A proxy for scalar expressions (e.g. from inner vector products)
scalar_expression< LHS, RHS, op_inner_prod >Specialization of a scalar expression for inner products. Allows for a final reduction on the CPU
scalar_expression< LHS, RHS, op_norm_1 >Specialization of a scalar expression for norm_1. Allows for a final reduction on the CPU
scalar_expression< LHS, RHS, op_norm_2 >Specialization of a scalar expression for norm_2. Allows for a final reduction on the CPU
scalar_expression< LHS, RHS, op_norm_frobenius >Specialization of a scalar expression for norm_frobenius. Allows for a final reduction on the CPU
scalar_expression< LHS, RHS, op_norm_inf >Specialization of a scalar expression for norm_inf. Allows for a final reduction on the CPU
scalar_matrix< SCALARTYPE >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
scalar_reductionOpenCL kernel generation template for scalar reduction operations such as s = norm_2(x)
scalar_vector< SCALARTYPE >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
scalartype_size_funFunctor for returning the size of the underlying scalar type in bytes
set_arguments_functorHelper class for setting the arguments of a kernel
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
size_type< T >Generic meta-function for retrieving the size_type associated with type T
spai< NumericT >Main kernel class for generating OpenCL kernels for the sparse approximate inverse preconditioners
spai_precond< MatrixType >Implementation of the SParse Approximate Inverse Algorithm for a generic, uBLAS-compatible matrix type
spai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >Implementation of the SParse Approximate Inverse Algorithm for a ViennaCL compressed_matrix
spai_tagA tag for SPAI Contains values for the algorithm. Must be passed to spai_precond constructor
sparse_matrix_adapted_iterator< SCALARTYPE, SizeType, is_iterator1 >A non-const iterator for sparse matrices of type std::vector<std::map<SizeType, SCALARTYPE> >
sparse_matrix_adapter< SCALARTYPE, SizeType >Adapts a non-const sparse matrix type made up from std::vector<std::map<SizeType, SCALARTYPE> > to basic ublas-compatibility
sparse_vector< ScalarType >Represents sparse vector based on std::map<unsigned int, ScalarType>
statementThe main class for representing a statement such as x = inner_prod(y,z); at runtime
statement_nodeMain datastructure for an node in the statement tree
statement_not_supported_exceptionException for the case the scheduler is unable to deal with the operation
statement_representation_functorHelper class for the OpenCL kernel generator, representing a statement
svd< NumericT >Main kernel class for generating OpenCL kernels for singular value decomposition of dense matrices
tag_eigenA tag class for identifying types from Eigen
tag_mtl4A tag class for identifying types from MTL4
tag_noneA tag class for identifying 'unknown' types
tag_stlA tag class for identifying types from the C++ STL
tag_ublasA tag class for identifying types from uBLAS
tag_viennaclA tag class for identifying types from ViennaCL
timerSimple timer class based on gettimeofday (POSIX) or QueryPerformanceCounter (Windows)
toeplitz_matrix< SCALARTYPE, ALIGNMENT >A Toeplitz matrix class
traversal_functorBase functor class for traversing a statement
tuning_config< ConfigType >Tuning configuration
tuning_paramClass for a tuning parameter
typesafe_host_array< T, special >Helper class implementing an array on the host. Default case: No conversion necessary
typesafe_host_array< T, true >Special host array type for conversion between OpenCL types and pure CPU types
unit_lower_tagA tag class representing a lower triangular matrix with unit diagonal
unit_upper_tagA tag class representing an upper triangular matrix with unit diagonal
unit_vector< SCALARTYPE >Represents a vector consisting of 1 at a given index and zeros otherwise
unknown_errorException thrown if the returned error cannot be resolved to some defined error constant. Might result from invalid sources, invalid memory operations, etc
upper_tagA tag class representing an upper triangular matrix
value_type< T >Generic helper function for retrieving the value_type associated with type T
vandermonde_matrix< SCALARTYPE, ALIGNMENT >A Vandermonde matrix class
vector< SCALARTYPE, ALIGNMENT >A vector class representing a linear memory sequence on the GPU. Inspired by boost::numeric::ublas::vector
vector< TYPE >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
vector_array_wrapper< NumericT >Helper class for accessing a strided subvector of a larger vector
vector_base< SCALARTYPE, SizeType, DistanceType >Common base class for dense vectors, vector ranges, and vector slices
vector_element< TYPE >Main kernel class for generating OpenCL kernels for elementwise operations other than addition and subtraction on/with viennacl::vector<>
vector_expression< LHS, RHS, OP >An expression template class that represents a binary operation that yields a vector
vector_iterator< SCALARTYPE, ALIGNMENT >A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!!
vector_multi_inner_prod< TYPE >Main kernel class for generating OpenCL kernels for multiple inner products on/with viennacl::vector<>
vector_range< VectorType >Class for representing non-strided subvectors of a bigger vector x
vector_reductionOpenCL kernel template for reductions resulting in a vector. Example: Computing the row norms of a matrix concurrently
vector_saxpyOpenCL kernel generation class for vector expressions of AXPY type, i.e. x = alpha * y + beta * z, where the number of summands can in principle be arbitrarily large
vector_slice< VectorType >Class for representing strided subvectors of a bigger vector x
vector_tuple< ScalarT >Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from viennacl::tie()
zero_matrix< SCALARTYPE >Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only
zero_vector< SCALARTYPE >Represents a vector consisting of zeros only