 accelerator_tag | |
 advanced_cuthill_mckee_tag | Tag for the advanced Cuthill-McKee algorithm |
 amg_nonzero_scalar< InternalType, IteratorType, ScalarType > | A class for a scalar that can be written to the sparse matrix or sparse vector datatypes |
 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 |
 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 |
 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_tag | A tag for algebraic multigrid (AMG). Used to transport information from the user to the implementation |
 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 |
 bicgstab_tag | A tag for the stabilized Bi-conjugate gradient solver. Used for supplying solver parameters and for dispatching the solve() function |
 block_matrix | Represents a contigious matrices on GPU |
 block_vector | Represents a contigious vector on GPU |
 build_program_failure | |
 cg_tag | A 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 |
 CHECK_SCALAR_TEMPLATE_ARGUMENT< double > | |
 CHECK_SCALAR_TEMPLATE_ARGUMENT< float > | |
 circulant_matrix< SCALARTYPE, ALIGNMENT > | A Circulant matrix class |
 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 |
 col_iteration | A tag indicating iteration along increasing columns index of a matrix |
 column_major | |
 command_queue | A class representing a command queue |
 CompareSecond | |
 compiler_not_available | |
 compressed_matrix< SCALARTYPE, ALIGNMENT > | A sparse square matrix in compressed sparse rows format |
 compressed_matrix< double, 1 > | |
 compressed_matrix< double, 4 > | |
 compressed_matrix< double, 8 > | |
 compressed_matrix< float, 1 > | |
 compressed_matrix< float, 4 > | |
 compressed_matrix< float, 8 > | |
 CONST_REMOVER< T > | Removes the const qualifier from a type |
 CONST_REMOVER< const T > | |
 const_sparse_matrix_adapted_iterator< SCALARTYPE, is_iterator1, is_forward > | A const iterator for sparse matrices of type std::vector<std::map<unsigned int, SCALARTYPE> > |
 const_sparse_matrix_adapter< SCALARTYPE > | Adapts a constant sparse matrix type made up from std::vector<std::map<unsigned int, SCALARTYPE> > to basic ublas-compatibility |
  sparse_matrix_adapter< SCALARTYPE > | Adapts a non-const sparse matrix type made up from std::vector<std::map<unsigned int, 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!! |
  vector_iterator< SCALARTYPE, ALIGNMENT > | A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! |
 context | |
 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< double, 1 > | |
 coordinate_matrix< double, 128 > | |
 coordinate_matrix< float, 1 > | |
 coordinate_matrix< float, 128 > | |
 CPU_SCALAR_TYPE_DEDUCER< T > | Obtain the cpu scalar type from a type, including a GPU type like viennacl::scalar<T> |
 CPU_SCALAR_TYPE_DEDUCER< double > | |
 CPU_SCALAR_TYPE_DEDUCER< float > | |
 CPU_SCALAR_TYPE_DEDUCER< viennacl::matrix< T, F, A > > | |
 CPU_SCALAR_TYPE_DEDUCER< viennacl::matrix_expression< const matrix< T, F, A >, const matrix< T, F, A >, op_trans > > | |
 CPU_SCALAR_TYPE_DEDUCER< viennacl::scalar< T > > | |
 CPU_SCALAR_TYPE_DEDUCER< viennacl::vector< T, A > > | |
 cpu_tag | |
 cpu_value_type< T > | |
 cpu_value_type< double > | |
 cpu_value_type< float > | |
 cpu_value_type< viennacl::matrix< T, F, ALIGNMENT > > | |
 cpu_value_type< viennacl::matrix_expression< T1, T2, OP > > | |
 cpu_value_type< viennacl::matrix_range< T > > | |
 cpu_value_type< viennacl::scalar< T > > | |
 cpu_value_type< viennacl::vector< T, ALIGNMENT > > | |
 cpu_value_type< viennacl::vector_expression< T1, T2, OP > > | |
 cpu_value_type< viennacl::vector_range< T > > | |
 cuthill_mckee_tag | |
 default_tag | |
 device | A class representing a compute device (e.g. a GPU) |
 device_not_available | |
 device_not_found | |
 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_CHECKER< double > | |
 double_precision_not_provided_error | |
 enable_if< b, T > | Simple enable-if variant that uses the SFINAE pattern |
 enable_if< false, T > | |
 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 |
 fft< double, 1 > | |
 fft< float, 1 > | |
 first_letter_of_type< T > | Helper meta class that returns the first letter of a particular type (float or double) |
 first_letter_of_type< double > | |
 first_letter_of_type< float > | |
 fspai_precond< MatrixType > | Implementation of the Factored SParse Approximate Inverse Algorithm |
 fspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > > | |
 fspai_tag | A tag for FSPAI. Experimental. Contains values for the algorithm. Must be passed to spai_precond constructor |
 gibbs_poole_stockmeyer_tag | |
 gmres_tag | A tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function |
 gpu_tag | |
 handle< OCL_TYPE > | Handle class the effectively represents a smart pointer for OpenCL handles |
 handle_inc_dec_helper< OCL_TYPE > | Helper for OpenCL reference counting used by class handle |
 handle_inc_dec_helper< cl_command_queue > | |
 handle_inc_dec_helper< cl_context > | |
 handle_inc_dec_helper< cl_kernel > | |
 handle_inc_dec_helper< cl_mem > | |
 handle_inc_dec_helper< cl_program > | |
 hankel_matrix< SCALARTYPE, ALIGNMENT > | A Hankel matrix class |
 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_tag | A tag for incomplete LU factorization with threshold (ILUT) |
 image_format_mismatch | |
 image_format_not_supported | |
 invalid_arg_index | |
 invalid_arg_size | |
 invalid_arg_value | |
 invalid_binary | |
 invalid_buffer_size | |
 invalid_build_options | |
 invalid_command_queue | |
 invalid_context | |
 invalid_device | |
 invalid_device_type | |
 invalid_event | |
 invalid_event_wait_list | |
 invalid_gl_object | |
 invalid_global_offset | |
 invalid_global_work_size | |
 invalid_host_ptr | |
 invalid_image_format_descriptor | |
 invalid_image_size | |
 invalid_kernel | |
 invalid_kernel_args | |
 invalid_kernel_definition | |
 invalid_kernel_name | |
 invalid_mem_object | |
 invalid_mip_level | |
 invalid_operation | |
 invalid_platform | |
 invalid_program | |
 invalid_program_executable | |
 invalid_property | |
 invalid_queue_properties | |
 invalid_sampler | |
 invalid_value | |
 invalid_work_dimension | |
 invalid_work_group_size | |
 invalid_work_item_size | |
 is_cpu_scalar< T > | |
 is_cpu_scalar< double > | |
 is_cpu_scalar< float > | |
 is_eigen< Tag > | Meta function which checks whether a tag is tag_eigen |
 is_eigen< viennacl::tag_eigen > | |
 is_matrix< T > | |
 is_matrix< viennacl::matrix< ScalarType, F, ALIGNMENT > > | |
 is_matrix< viennacl::matrix_range< T > > | |
 is_mtl4< Tag > | Meta function which checks whether a tag is tag_mtl4 |
 is_mtl4< viennacl::tag_mtl4 > | |
 is_scalar< T > | |
 is_scalar< viennacl::scalar< T > > | |
 is_stl< Tag > | Meta function which checks whether a tag is tag_ublas |
 is_stl< viennacl::tag_stl > | |
 is_ublas< Tag > | Meta function which checks whether a tag is tag_ublas |
 is_ublas< viennacl::tag_ublas > | |
 is_vector< T > | |
 is_vector< viennacl::vector< ScalarType, ALIGNMENT > > | |
 is_vector< viennacl::vector_range< T > > | |
 is_viennacl< Tag > | Meta function which checks whether a tag is tag_viennacl |
 is_viennacl< viennacl::tag_viennacl > | |
 jacobi_precond< MatrixType > | Jacobi preconditioner class, can be supplied to solve()-routines |
 jacobi_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > > | Jacobi preconditioner class, can be supplied to solve()-routines |
 jacobi_tag | A tag for a jacobi preconditioner |
 kernel | Represents an OpenCL kernel within ViennaCL |
 local_mem | A class representing local (shared) OpenCL memory. Typically used as kernel argument |
 lower_tag | A tag class representing a lower triangular matrix |
 map_failure | |
 matrix< SCALARTYPE, F, ALIGNMENT > | A dense matrix class |
 matrix_col< double, 1 > | |
 matrix_col< double, 16 > | |
 matrix_col< float, 1 > | |
 matrix_col< float, 16 > | |
 matrix_expression< LHS, RHS, OP > | |
 matrix_expression_internal_storage< T > | |
 matrix_expression_internal_storage< const double > | |
 matrix_expression_internal_storage< const float > | |
 matrix_iterator< ROWCOL, MATRIXTYPE > | |
 MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE > | |
 MATRIX_ITERATOR_INCREMENTER< viennacl::col_iteration, viennacl::matrix< SCALARTYPE, F, ALIGNMENT > > | |
 MATRIX_ITERATOR_INCREMENTER< viennacl::row_iteration, viennacl::matrix< SCALARTYPE, F, ALIGNMENT > > | Supply suitable increment functions for the iterators: |
 MATRIX_KERNEL_CLASS_DEDUCER< MatrixType1 > | Implementation of a helper meta class for deducing the correct kernels for the supplied matrix |
 MATRIX_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 MATRIX_KERNEL_CLASS_DEDUCER< viennacl::matrix_range< T > > | |
 matrix_prod_col_col_col< double, 1 > | |
 matrix_prod_col_col_col< float, 1 > | |
 matrix_prod_col_col_row< double, 1 > | |
 matrix_prod_col_col_row< float, 1 > | |
 matrix_prod_col_row_col< double, 1 > | |
 matrix_prod_col_row_col< float, 1 > | |
 matrix_prod_col_row_row< double, 1 > | |
 matrix_prod_col_row_row< float, 1 > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< MatrixType1, MatrixType2, MatrixType3 > | Deduces kernel type for C=A*B, where A, B, C are MatrixType1, MatrixType2 and MatrixType3 respectively |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_PROD_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 matrix_prod_row_col_col< double, 1 > | |
 matrix_prod_row_col_col< float, 1 > | |
 matrix_prod_row_col_row< double, 1 > | |
 matrix_prod_row_col_row< float, 1 > | |
 matrix_prod_row_row_col< double, 1 > | |
 matrix_prod_row_row_col< float, 1 > | |
 matrix_prod_row_row_row< double, 1 > | |
 matrix_prod_row_row_row< float, 1 > | |
 matrix_range< MatrixType > | |
 matrix_row< double, 1 > | |
 matrix_row< double, 16 > | |
 matrix_row< float, 1 > | |
 matrix_row< float, 16 > | |
 MATRIX_SIZE_DEDUCER< LHS, RHS, OP > | Deduces the size of the resulting vector represented by a vector_expression from the operands |
 MATRIX_SIZE_DEDUCER< const viennacl::matrix< ScalarType, F1, A1 >, const viennacl::matrix_expression< const viennacl::matrix< ScalarType, F2, A2 >, const viennacl::matrix< ScalarType, F2, A2 >, op_trans >, viennacl::op_prod > | |
 MATRIX_SIZE_DEDUCER< const viennacl::matrix_expression< const viennacl::matrix< ScalarType, F1, A1 >, const viennacl::matrix< ScalarType, F1, A1 >, op_trans >, const viennacl::matrix< ScalarType, F2, A2 >, viennacl::op_prod > | |
 MATRIX_SIZE_DEDUCER< viennacl::vector< ScalarType, A1 >, viennacl::vector< ScalarType, A2 >, viennacl::op_prod > | |
 matrix_solve_col_col< double, 1 > | |
 matrix_solve_col_col< float, 1 > | |
 matrix_solve_col_row< double, 1 > | |
 matrix_solve_col_row< float, 1 > | |
 MATRIX_SOLVE_KERNEL_CLASS_DEDUCER< MatrixType1, MatrixType2 > | Deduces kernel type for A \ B, where A, B, C are MatrixType1 and MatrixType2 |
 MATRIX_SOLVE_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_SOLVE_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 MATRIX_SOLVE_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::column_major, ALIGNMENT > > | |
 MATRIX_SOLVE_KERNEL_CLASS_DEDUCER< viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT >, viennacl::matrix< SCALARTYPE, viennacl::row_major, ALIGNMENT > > | |
 matrix_solve_row_col< double, 1 > | |
 matrix_solve_row_col< float, 1 > | |
 matrix_solve_row_row< double, 1 > | |
 matrix_solve_row_row< float, 1 > | |
 mem_copy_overlap | |
 mem_object_allocation_failure | |
 no_precond | A tag class representing the use of no preconditioner |
 out_of_host_memory | |
 out_of_resources | |
 parameter_database | A XML parameter database using PugiXML. Allows to add tests for different devices and the like |
 platform | |
 profiling_info_not_available | |
 program | |
 program_for_vcltype< T > | |
 program_for_vcltype< viennacl::compressed_matrix< T, ALIGNMENT > > | |
 program_for_vcltype< viennacl::matrix< T, column_major, ALIGNMENT > > | |
 program_for_vcltype< viennacl::matrix< T, row_major, ALIGNMENT > > | |
 program_for_vcltype< viennacl::vector< T, ALIGNMENT > > | |
 range | |
 row_iteration | A tag indicating iteration along increasing row index of a matrix |
 row_major | A tag for row-major storage of a dense matrix |
 row_scaling< MatrixType > | Jacobi preconditioner class, can be supplied to solve()-routines |
 row_scaling< compressed_matrix< ScalarType, MAT_ALIGNMENT > > | Jacobi preconditioner class, can be supplied to solve()-routines |
 row_scaling_tag | A tag for a row preconditioner |
 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 |
 scalar< double, 1 > | |
 scalar< float, 1 > | |
 scalar_expression< LHS, RHS, OP > | A proxy for scalar expressions (e.g. from inner vector products) |
 size_type< T > | |
 spai< double, 1 > | |
 spai< float, 1 > | |
 spai_precond< MatrixType > | Implementation of the SParse Approximate Inverse Algorithm |
 spai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > > | |
 spai_tag | A tag for SPAI Contains values for the algorithm. Must be passed to spai_precond constructor |
 sparse_matrix_adapted_iterator< SCALARTYPE, is_iterator1 > | A non-const iterator for sparse matrices of type std::vector<std::map<unsigned int, SCALARTYPE> > |
 sparse_vector< ScalarType > | Represents sparse vector based on std::map<unsigned int, ScalarType> |
 sub_matrix< MatrixType > | |
 tag_eigen | |
 tag_mtl4 | |
 tag_none | |
 tag_of< Sequence, Active > | |
 tag_of< std::vector< std::map< KEY, DATA, COMPARE, AMAP >, AVEC > > | |
 tag_of< std::vector< std::vector< T, A >, A > > | |
 tag_of< std::vector< T, A > > | |
 tag_of< viennacl::circulant_matrix< T, I > > | |
 tag_of< viennacl::compressed_matrix< T, I > > | |
 tag_of< viennacl::coordinate_matrix< T, I > > | |
 tag_of< viennacl::hankel_matrix< T, I > > | |
 tag_of< viennacl::matrix< T, F, alignment > > | |
 tag_of< viennacl::matrix_expression< T1, T2, OP > > | |
 tag_of< viennacl::matrix_range< T > > | |
 tag_of< viennacl::toeplitz_matrix< T, I > > | |
 tag_of< viennacl::vandermonde_matrix< T, I > > | |
 tag_of< viennacl::vector< T, alignment > > | |
 tag_stl | |
 tag_ublas | |
 tag_viennacl | |
 to_string< T > | Helper meta-class that converts a type to a string |
 to_string< double > | |
 to_string< float > | |
 toeplitz_matrix< SCALARTYPE, ALIGNMENT > | A Toeplitz matrix class |
 unit_lower_tag | A tag class representing a lower triangular matrix with unit diagonal |
 unit_upper_tag | A tag class representing an upper triangular matrix with unit diagonal |
 unknown_error | |
 upper_tag | A tag class representing an upper triangular matrix |
 value_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< double, 1 > | |
 vector< double, 16 > | |
 vector< double, 4 > | |
 vector< float, 1 > | |
 vector< float, 16 > | |
 vector< float, 4 > | |
 vector_expression< LHS, RHS, OP > | An expression template class that represents a binary operation that yields a vector |
 VECTOR_EXTRACTOR< LHS, RHS > | |
 VECTOR_EXTRACTOR_IMPL< LHS, RHS > | Extracts the vector type from one of the two arguments. Used for the vector_expression type |
 VECTOR_EXTRACTOR_IMPL< LHS, viennacl::vector< ScalarType, A > > | |
 VECTOR_EXTRACTOR_IMPL< viennacl::vector< ScalarType, A >, RHS > | |
 VECTOR_EXTRACTOR_IMPL< viennacl::vector< ScalarType, A >, viennacl::vector< ScalarType, A > > | |
 vector_range< VectorType > | |
 VECTOR_SIZE_DEDUCER< LHS, RHS, OP > | Deduces the size of the resulting vector represented by a vector_expression from the operands |
 VECTOR_SIZE_DEDUCER< const viennacl::circulant_matrix< ScalarType, Amat >, const viennacl::vector< ScalarType, A >, viennacl::op_prod > | |
 VECTOR_SIZE_DEDUCER< const viennacl::compressed_matrix< ScalarType, Amat >, const viennacl::vector< ScalarType, A >, viennacl::op_prod > | |
 VECTOR_SIZE_DEDUCER< const viennacl::coordinate_matrix< ScalarType, Amat >, const viennacl::vector< ScalarType, A >, viennacl::op_prod > | |
 VECTOR_SIZE_DEDUCER< const viennacl::matrix< ScalarType, F, Amat >, const viennacl::vector< ScalarType, A >, viennacl::op_prod > | |
 VECTOR_SIZE_DEDUCER< const viennacl::matrix_expression< const viennacl::matrix< ScalarType, F, Amat >, const viennacl::matrix< ScalarType, F, Amat >, op_trans >, const viennacl::vector< ScalarType, A >, viennacl::op_prod > | |
 VECTOR_SIZE_DEDUCER< const viennacl::vector< ScalarType, A >, RHS, viennacl::op_div > | |
 VECTOR_SIZE_DEDUCER< const viennacl::vector< ScalarType, A >, RHS, viennacl::op_prod > | |