| accelerator_tag | A tag identifying OpenCL devices as accelerators (e.g. Intel Xeon Phi) |
| register_kernels< typelist< Head, Tail >, Res, CurrentIndex >::add_to_res< T, List, Index > | |
| add_type | |
| advanced_cuthill_mckee_tag | Tag for the advanced Cuthill-McKee algorithm |
| alignment< T > | Retrieves the alignment from a vector. Deprecated - will be replaced by a pure runtime facility in the future |
| 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 |
| and_is< S, T > | |
| any | |
| append< NullType, NullType, Compare > | |
| append< NullType, T, Compare > | |
| append< typelist< Head, Tail >, NullType, Compare > | |
| append< typelist< Head, Tail >, T, Compare > | |
| are_same_type< T, U > | |
| are_same_type< T, T > | |
| ArithmeticToken< Expr > | |
| array_deleter< U > | Helper struct for deleting an pointer to an array |
| assign_type | |
| backend< dummy > | A backend that provides contexts for ViennaCL objects (vector, matrix, etc.) |
| bad_any_cast | |
| 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_tag | A 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_matrix | Represents a contigious matrices on GPU |
| block_vector | Represents a contigious vector on GPU |
| body_code< ExpressionsList > | Functor to generates the body code of a kernel from a typelist of expressions |
| build_program_failure | |
| cg_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function |
| CHECK_ALIGNMENT_COMPATIBILITY< LHS, RHS > | |
| CHECK_ALIGNMENT_COMPATIBILITY< LHS, symbolic_constant< val > > | |
| CHECK_ALIGNMENT_COMPATIBILITY< symbolic_constant< val >, RHS > | |
| 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 |
| cl_type< bool > | |
| cl_type< double > | |
| cl_type< float > | |
| cl_type< int > | |
| cl_type< long > | |
| 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 | |
| column_major_tag | |
| command_queue | A class representing a command queue |
| compare1< T1, T2 > | |
| compare1< NullType, T > | |
| CompareSecond | |
| compiler_not_available | |
| compound_node< LHS_, OP_, RHS_ > | Binary node class for storing expression trees |
| compound_node< LHS_, inner_prod_type, RHS_ > | |
| compound_node< LHS_, prod_type, RHS_ > | Specialization for the matrix-vector product |
| compound_to_simple< T > | |
| compound_to_simple< compound_node< LHS, OP, NullType > > | |
| compound_to_simple< compound_node< NullType, OP, NullType > > | |
| compound_to_simple< compound_node< NullType, OP, RHS > > | |
| 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_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_REMOVER< const T > | |
| 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!! |
| constant_expression< T > | |
| context | |
| convert_to_opencl< T > | |
| 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 > | |
| count | |
| count_if< T, Pred > | Functor for counting the number of elements satisfying a Pred |
| count_if< compound_node< LHS, OP, RHS >, Pred > | |
| count_if< elementwise_modifier< T >, Pred > | |
| count_if< inner_prod_impl_t< T >, Pred > | |
| count_if< typelist< Head, Tail >, Pred > | |
| count_if_type< T, Searched > | Functor for counting the number of elements equals to the type specified |
| count_if_type< compound_node< LHS, OP, RHS >, compound_node< LHS, OP, RHS > > | |
| count_if_type< compound_node< LHS, OP, RHS >, Searched > | |
| count_if_type< elementwise_modifier< T >, elementwise_modifier< T > > | |
| count_if_type< elementwise_modifier< T >, Searched > | |
| count_if_type< T, T > | |
| count_if_type< typelist< Head, Tail >, Searched > | |
| CPU_SCALAR_TYPE_DEDUCER< T > | Obtain the cpu scalar type from a type, including a GPU type like viennacl::scalar<T> |
| cpu_symbolic_scalar< ID, SCALARTYPE > | Symbolic scalar type. Will be passed by value |
| cpu_tag | A 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 > | |
| custom_operation | A class for making a custom operation |
| cuthill_mckee_tag | |
| default_tag | A tag denoting the default OpenCL device type (SDK-specific) |
| device | A class representing a compute device (e.g. a GPU) |
| device_not_available | |
| device_not_found | |
| disable_if< Cond, T > | |
| disable_if_c< B, T > | |
| disable_if_c< true, T > | |
| dot_product< LHS, RHS > | |
| dot_product< LHS, symbolic_constant< 1 > > | |
| dot_product_impl< LHS, RHS, Alignment > | |
| dot_product_impl< LHS, RHS, 16 > | |
| dot_product_impl< LHS, RHS, 8 > | |
| 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 | |
| elementwise_div_type | |
| elementwise_modifier< T > | |
| elementwise_modifier_impl< T > | Implementation of the elementwise_modifier |
| elementwise_prod_type | |
| ell_matrix< SCALARTYPE, ALIGNMENT > | |
| ell_matrix< double, 1 > | |
| ell_matrix< float, 1 > | |
| enable_if< Cond, T > | |
| enable_if< b, T > | Simple enable-if variant that uses the SFINAE pattern |
| enable_if< false, T > | |
| enable_if_c< B, T > | |
| enable_if_c< 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 |
| erase< NullType, T > | |
| erase< typelist< Head, Tail >, T > | |
| erase< typelist< Head, Tail >, typelist< Head2, Tail2 > > | |
| erase< typelist< T, Tail >, T > | |
| error_checker< T > | An error reporting class. Template argument is used to avoid problems with external linkage |
| expand< T > | Expands the particular tree |
| expand< compound_node< LHS, OP, RHS > > | |
| expand< elementwise_modifier< T > > | |
| expand< inner_prod_impl_t< T > > | |
| expand_left< LHS_LHS, LHS_OP, LHS_RHS, OP, RHS > | Expand a node on the left |
| expand_right< LHS, OP, RHS_LHS, RHS_OP, RHS_RHS > | Expand a node on the right |
| expression_type< T > | |
| extract_if< T, Pred, Comp, TList > | Extracts the types in the tree satisfying a certain predicate |
| extract_if< compound_node< LHS, OP, RHS >, Pred, Comp, TList > | |
| extract_if< elementwise_modifier< T >, Pred, Comp, TList > | |
| extract_if< inner_prod_impl_t< T >, Pred, Comp, TList > | |
| extract_if< typelist< Head, Tail >, Pred, Comp, TList > | |
| extract_if_unique< T, Pred, Comp > | Like extract_if but ignores duplicates |
| FastMatrix< SCALARTYPE > | |
| fft< double, 1 > | |
| fft< float, 1 > | |
| program_infos< ARG >::fill_args< Operations > | |
| program_infos< ARG >::fill_sources< Operations > | |
| find_first_if< NullType, Pred > | |
| find_first_if< typelist< Head, Tail >, Pred > | |
| find_if< NullType, Pred > | |
| find_if< typelist< Head, Tail >, Pred > | |
| 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 > | |
| flip_operator< OP, flip > | |
| flip_operator<add_type, true > | |
| flip_operator<sub_type, true > | |
| flip_tree< T, flip > | Removes parenthesis keeping flipping coherent with the - signs |
| flip_tree< compound_node< LHS, OP, RHS >, flip > | |
| flip_tree< elementwise_modifier< T >, flip > | |
| ForEach< NullType, Functor > | |
| ForEach< typelist< T, U >, Functor > | |
| ForEachType< NullType, Functor > | |
| ForEachType< typelist< Head, Tail >, Functor > | |
| 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 |
| body_code< ExpressionsList >::fill_expression_updates< TList, Pred >::functor< Tree > | |
| program_infos< ARG >::fill_args< Operations >::functor< U > | |
| program_infos< ARG >::fill_sources< Operations >::header_code< TList >::functor< T > | |
| fuse< TList, T, Compare > | |
| fuse< NullType, typelist< Head2, Tail2 >, Compare > | |
| fuse< typelist< Head1, Tail1 >, typelist< Head2, Tail2 >, Compare > | |
| make_code< InProdToken< T, 0 > >::generate_code< U > | |
| make_code< InProdToken< T, 1 > >::generate_code_reduction< U > | |
| make_code< InProdToken< T, 1 > >::generate_code_sum< U > | |
| get_head< T > | |
| get_head< typelist< Head, Tail > > | |
| get_new_operator< OP, RHS, Enable > | |
| get_new_operator<sub_type, compound_node< NullType, RHS_OP, RHS_RHS > > | |
| get_operations_from_expressions< NullType > | |
| get_operations_from_expressions< typelist< Head, Tail > > | |
| get_operations_from_expressions< typelist< repeater_impl< Bound, Operations >, Tail > > | |
| get_operations_lhs< T, Enable > | |
| get_operations_lhs< T, typename viennacl::enable_if< result_of::is_assignment_compound< T >::value >::type > | |
| get_operations_lhs< typelist< Head, Tail > > | |
| get_type_if< TypeTrue, TypeFalse, cond > | |
| get_type_if< TypeTrue, TypeFalse, false > | |
| gibbs_poole_stockmeyer_tag | |
| gmres_tag | A tag for the solver GMRES. Used for supplying solver parameters and for dispatching the solve() function |
| gpu_symbolic_scalar< ID, SCALARTYPE > | Symbolic scalar type. Will be passed by pointer |
| gpu_tag | A tag identifying OpenCL devices as GPUs |
| 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_unary_minus< OP, RHS > | |
| handle_unary_minus< sub_type, RHS > | |
| hankel_matrix< SCALARTYPE, ALIGNMENT > | A Hankel matrix class |
| program_infos< ARG >::fill_sources< Operations >::header_code< TList > | |
| hyb_matrix< SCALARTYPE, ALIGNMENT > | |
| hyb_matrix< double, 1 > | |
| hyb_matrix< float, 1 > | |
| 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_tag | A 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 |
| 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_tag | A tag for incomplete LU factorization with static pattern (ILU0) |
| ilu< double, 1 > | |
| ilu< float, 1 > | |
| ilu_vector_range< VectorType, ValueType, SizeType > | |
| 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 | |
| index_of< NullType, T > | |
| index_of< typelist< Head, Tail >, T > | |
| index_of< typelist< T, Tail >, T > | |
| inner_prod_impl_t< T > | |
| inner_prod_type | |
| inplace_add_type | |
| inplace_scal_div_type | |
| inplace_scal_mul_type | |
| inplace_sub_type | |
| InProdToken< Expr, Step_ > | Base structure for representing Inner Product token |
| Int2Type< v > | |
| 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 | |
| invert_flip< OP, flip > | |
| invert_flip< sub_type, flip > | |
| is_addition< T > | Helper metafunction for checking whether the provided type is viennacl::op_add (for addition) |
| is_any_dense_structured_matrix< T > | |
| is_any_scalar< T > | |
| is_any_sparse_matrix< T > | |
| is_arithmetic_compound< T > | |
| is_arithmetic_compound< compound_node< LHS, OP, RHS > > | |
| is_arithmetic_operator< OP > | |
| is_assignment< OP > | |
| is_assignment_compound< T > | |
| is_assignment_compound< compound_node< LHS, OP, RHS > > | |
| is_circulant_matrix< T > | |
| is_compound< T > | |
| is_compound< compound_node< LHS, OP, RHS > > | |
| is_cpu_scalar< T > | |
| is_division< T > | Helper metafunction for checking whether the provided type is viennacl::op_div (for division) |
| is_double_type< T > | |
| is_double_type< NullType > | |
| is_eigen< Tag > | Meta function which checks whether a tag is tag_eigen |
| is_eigen< viennacl::tag_eigen > | |
| is_empty< TList > | |
| is_empty< NullType > | |
| is_flip_sign_scalar< T > | |
| is_hankel_matrix< T > | |
| is_inner_product_impl< T > | |
| is_inner_product_impl< inner_prod_impl_t< T > > | |
| is_inner_product_leaf< T > | |
| is_inner_product_leaf< compound_node< LHS, inner_prod_type, RHS > > | |
| is_kernel_argument< T > | |
| is_kernel_argument< compound_node< LHS, inner_prod_type, RHS > > | |
| is_kernel_argument< cpu_symbolic_scalar< ID, SCALARTYPE > > | |
| is_kernel_argument< gpu_symbolic_scalar< ID, SCALARTYPE > > | |
| is_kernel_argument< inner_prod_impl_t< T > > | |
| is_kernel_argument< repeater_impl< Bound, Expr > > | |
| is_kernel_argument< symbolic_matrix< ID, SCALARTYPE, F, ALIGNMENT > > | |
| is_kernel_argument< symbolic_vector< ID, SCALARTYPE, ALIGNMENT > > | |
| is_matrix_expression< T > | |
| is_matrix_expression_impl< T > | |
| is_matrix_expression_impl< result_of::matrix_expression< T, SIZE1_D, SIZE2_D > > | |
| is_mtl4< Tag > | Meta function which checks whether a tag is tag_mtl4 |
| is_mtl4< viennacl::tag_mtl4 > | |
| is_not< T > | |
| is_null_type< T > | |
| is_null_type< NullType > | |
| is_product< T > | Helper metafunction for checking whether the provided type is viennacl::op_prod (for products/multiplication) |
| is_product_leaf< T > | |
| is_product_leaf< compound_node< LHS, prod_type, RHS > > | |
| is_product_leaf< compound_node< LHS, scal_mul_type, RHS > > | |
| is_row_major< T > | |
| is_row_major< T > | |
| is_row_major< symbolic_matrix< ID, ScalarType, viennacl::row_major, Alignment > > | |
| is_same_expression_type< EXPR1, EXPR2 > | |
| is_same_expression_type< Expr, symbolic_constant< VAL > > | Special case: symbolic constant for elementwise can be used as every type |
| is_same_expression_type< symbolic_constant< VAL >, Expr > | Special case: symbolic constant for elementwise can be used as every type |
| is_scalar< T > | |
| is_scalar_assignment< T > | |
| is_scalar_assignment< compound_node< LHS, OP, RHS > > | |
| is_scalar_expression< T > | |
| is_scalar_expression_impl< T > | |
| is_scalar_expression_impl< result_of::scalar_expression< T > > | |
| is_stl< Tag > | Meta function which checks whether a tag is tag_ublas |
| is_stl< viennacl::tag_stl > | |
| is_subtraction< T > | Helper metafunction for checking whether the provided type is viennacl::op_sub (for subtraction) |
| is_symbolic_constant< T > | |
| is_symbolic_cpu_scalar< T > | |
| is_symbolic_cpu_scalar< cpu_symbolic_scalar< Id, ScalarType > > | |
| is_symbolic_expression< T > | |
| is_symbolic_gpu_scalar< T > | |
| is_symbolic_gpu_scalar< gpu_symbolic_scalar< Id, ScalarType > > | |
| is_symbolic_matrix< T > | |
| is_symbolic_matrix< symbolic_matrix< Id, ScalarType, Layout, Alignment > > | |
| is_symbolic_vector< T > | |
| is_symbolic_vector< symbolic_vector< Id, ScalarType, Alignment > > | |
| is_toeplitz_matrix< T > | |
| is_transposed< T > | |
| is_typelist< T > | |
| is_typelist< typelist< Head, Tail > > | |
| is_ublas< Tag > | Meta function which checks whether a tag is tag_ublas |
| is_ublas< viennacl::tag_ublas > | |
| is_vandermonde_matrix< T > | |
| is_vector_assignment< T > | |
| is_vector_assignment< compound_node< LHS, OP, RHS > > | |
| is_vector_assignment< repeater_impl< Bound, Expr > > | |
| is_vector_expression< T > | |
| is_vector_expression_impl< T > | |
| is_vector_expression_impl< result_of::vector_expression< T, SIZE_D > > | |
| is_viennacl< Tag > | Meta function which checks whether a tag is tag_viennacl |
| is_viennacl< viennacl::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_tag | A tag for a jacobi preconditioner |
| kernel | Represents an OpenCL kernel within ViennaCL |
| lanczos_tag | A tag for the lanczos algorithm |
| length< NullType > | |
| length< typelist< T, U > > | |
| local_mem | A class representing local (shared) OpenCL memory. Typically used as kernel argument |
| lower_tag | A tag class representing a lower triangular matrix |
| majority_struct_for_orientation< T > | |
| majority_struct_for_orientation< viennacl::column_major_tag > | |
| majority_struct_for_orientation< viennacl::row_major_tag > | |
| make_code< ArithmeticToken< EXPR > > | |
| make_code< InProdToken< T, 0 > > | |
| make_code< InProdToken< T, 1 > > | |
| make_code< MatMatToken< T, OP, Assigned > > | |
| make_code< MatVecToken< T, OP, Assigned > > | |
| make_code< NullType > | |
| make_expression_code< T > | Inline code for an expression from scalars |
| make_expression_code< compound_node< LHS, inner_prod_type, RHS > > | |
| make_expression_code< compound_node< LHS, OP, RHS > > | |
| make_expression_code< compound_node< LHS, prod_type, RHS > > | |
| make_expression_code< cpu_symbolic_scalar< ID, SCALARTYPE > > | |
| make_expression_code< elementwise_modifier< T > > | |
| make_expression_code< gpu_symbolic_scalar< ID, SCALARTYPE > > | |
| make_expression_code< inner_prod_impl_t< T > > | |
| make_expression_code< NullType > | |
| make_expression_code< symbolic_constant< VAL > > | |
| make_inplace< T > | |
| make_inplace< add_type > | |
| make_inplace< scal_div_type > | |
| make_inplace< scal_mul_type > | |
| make_inplace< sub_type > | |
| make_typelist< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 > | |
| make_typelist<> | |
| map_failure | |
| MatMatToken< Expr, OP_, Assigned_ > | Base structure for representing Matrix-Matrix Product token |
| matrix< SCALARTYPE, F, ALIGNMENT > | A dense matrix class |
| matrix_array_wrapper< NumericT, MajorityCategory, is_transposed > | |
| matrix_array_wrapper< NumericT, MajorityCategory, true > | |
| matrix_base< SCALARTYPE, F, SizeType, DistanceType > | A dense matrix class |
| matrix_col< double, 1 > | |
| matrix_col< double, 16 > | |
| matrix_col< float, 1 > | |
| matrix_col< float, 16 > | |
| matrix_expression< T, SIZE1_DESCRIPTOR, SIZE2_DESCRIPTOR > | |
| matrix_expression< LHS, RHS, OP > | |
| MATRIX_EXTRACTOR< LHS, RHS > | |
| MATRIX_EXTRACTOR_IMPL< LHS, RHS > | Extracts the vector type from one of the two arguments. Used for the vector_expression type |
| matrix_iterator< ROWCOL, MATRIXTYPE > | |
| MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE > | |
| MATRIX_KERNEL_CLASS_DEDUCER< MatrixType1 > | Implementation of a helper meta class for deducing the correct kernels for the supplied matrix |
| 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_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_runtime_wrapper< T, SIZE1_T, SIZE2_T > | |
| MATRIX_SIZE_DEDUCER< LHS, RHS, OP > | Deduces the size of the resulting vector represented by a vector_expression from the operands |
| matrix_slice< MatrixType > | |
| 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_row_col< double, 1 > | |
| matrix_solve_row_col< float, 1 > | |
| matrix_solve_row_row< double, 1 > | |
| matrix_solve_row_row< float, 1 > | |
| MatVecToken< Expr, OP_, Assigned_ > | Base structure for representing Matrix-Vector Product token |
| mem_copy_overlap | |
| mem_handle | Main abstraction class for multiple memory domains. Represents a buffer in either main RAM, an OpenCL context, or a CUDA device |
| mem_object_allocation_failure | |
| mixed_precision_cg_tag | A tag for the conjugate gradient Used for supplying solver parameters and for dispatching the solve() function |
| nmf< double, 1 > | |
| nmf< float, 1 > | |
| nmf_config | |
| no_duplicates< NullType > | |
| no_duplicates< typelist< Head, Tail > > | |
| no_precond | A tag class representing the use of no preconditioner |
| NullType | |
| or_is< S, T > | |
| orientation_functor< T > | Returns the orientation functor tag (either row_major or column_major) of a matrix |
| out_of_host_memory | |
| out_of_resources | |
| packed_cl_uint | |
| parameter_database | A XML parameter database using PugiXML. Allows to add tests for different devices and the like |
| platform | |
| power_iter_tag | A tag for the power iteration algorithm |
| and_is< S, T >::Pred< U > | |
| is_not< T >::Pred< U > | |
| or_is< S, T >::Pred< U > | |
| print_align1_type< double > | |
| print_align1_type< float > | |
| print_align1_type< int > | |
| print_align1_type< long > | |
| print_align1_type< unsigned int > | |
| print_align1_type< unsigned long > | |
| print_aligned_type< T, ALIGNMENT > | |
| print_aligned_type< T, 1 > | |
| print_type< T, ALIGNMENT > | |
| print_type< T *, ALIGNMENT > | |
| prod_type | |
| 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 > > | |
| program_infos< ARG > | Functor to get the information necessary to create a program |
| rand< double, 1 > | |
| rand< float, 1 > | |
| register_kernels< NullType, Res, CurrentIndex > | |
| register_kernels< typelist< Head, Tail >, Res, CurrentIndex > | |
| remove_if< T, Pred, inspect_nested > | Removes the nodes satisfying a predicate from the tree |
| remove_if< compound_node< LHS, OP, RHS >, Pred, inspect_nested > | |
| remove_if< elementwise_modifier< T >, Pred, inspect_nested > | |
| repeater_impl< Bound_, Operations_ > | |
| replace< NullType, Previous, New > | |
| replace< typelist< Head, Tail >, Previous, New > | |
| replace< typelist< Previous, Tail >, Previous, New > | |
| 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_major_tag | |
| 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_for_viennacl< T > | |
| row_scaling_for_viennacl< viennacl::compressed_matrix< ScalarType, ALIGNMENT > > | |
| row_scaling_for_viennacl< viennacl::coordinate_matrix< ScalarType, ALIGNMENT > > | |
| row_scaling_tag | A tag for a row preconditioner |
| runtime_wrapper | |
| scal_div_type | |
| scal_mul_type | |
| 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< double, 1 > | |
| scalar< float, 1 > | |
| scalar_expression< LHS, RHS, OP > | A proxy for scalar expressions (e.g. from inner vector products) |
| scalar_expression< T > | |
| 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_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_runtime_wrapper< T > | |
| scalar_runtime_wrapper< viennacl::generator::cpu_symbolic_scalar< ID, ScalarType > > | |
| 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 |
| shared_memory_wrapper | |
| 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< 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, 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> |
| sub_type | |
| svd< double, 1 > | |
| svd< float, 1 > | |
| symbolic_constant< VAL > | Symbolic constant. Used for elementwise operations |
| symbolic_matrix< ID, SCALARTYPE, F, ALIGNMENT > | Symbolic matrix type |
| symbolic_vector< ID, SCALARTYPE, ALIGNMENT > | Symbolic vector type |
| 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::ell_matrix< T, I > > | |
| tag_of< viennacl::hankel_matrix< T, I > > | |
| tag_of< viennacl::hyb_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 |
| Token< Expr_ > | Base structure for representing Token |
| transform_inner_prod< T > | Helper for register_kernels. Transform inner_product into phase 1 of inner_product implementation |
| transform_inner_prod< compound_node< LHS, inner_prod_type, RHS > > | |
| true_comp< T1, T2 > | |
| true_pred< T > | |
| type_at< NullType, i > | |
| type_at< typelist< Head, Tail >, 0 > | |
| type_at< typelist< Head, Tail >, i > | |
| typelist< T, U > | |
| 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_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 |
| unit_vector< 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 |
| unknown_error | |
| upper_tag | A tag class representing an upper triangular matrix |
| value< T > | |
| value_base | |
| value_type< T > | Generic helper function for retrieving the value_type associated with type T |
| vandermonde_matrix< SCALARTYPE, ALIGNMENT > | A Vandermonde matrix class |
| vcl_static_assert< true > | |
| 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_array_wrapper< NumericT > | |
| vector_base< SCALARTYPE, SizeType, DistanceType > | Common base class for dense vectors, vector ranges, and vector slices |
| vector_expression< LHS, RHS, OP > | An expression template class that represents a binary operation that yields a vector |
| vector_expression< T, SIZE_DESCRIPTOR > | |
| 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_iterator< SCALARTYPE, ALIGNMENT > | A STL-type iterator for vector elements. Elements can be accessed and manipulated. VERY SLOW!! |
| vector_range< VectorType > | |
| vector_runtime_wrapper< T, SIZE_T > | |
| vector_slice< VectorType > | |
| 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. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only |
