| 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 |
| const_vector_iterator< SCALARTYPE, ALIGNMENT > | A STL-type const-iterator for vector elements. Elements can be accessed, but cannot be 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_matrix_adapter< SCALARTYPE > | Adapts a non-const sparse matrix type made up from std::vector<std::map<unsigned int, SCALARTYPE> > to basic ublas-compatibility |
| 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_iterator< SCALARTYPE, ALIGNMENT > | A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! |
| 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 > | |
