Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

• accelerator_tag
• register_kernels< typelist< Head, Tail >, Res, CurrentIndex >::add_to_res< T, List, Index >
• add_type
• advanced_cuthill_mckee_tag
• alignment< T >
• amg_nonzero_scalar< InternalType, IteratorType, ScalarType >
• amg_point
• amg_pointvector
• amg_precond< MatrixType >
• amg_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >
• amg_slicing< InternalType1, InternalType2 >
• amg_sparsematrix< ScalarType >
• amg_sparsevector< ScalarType >
• amg_sparsevector_iterator< InternalType >
• amg_tag
• 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 >
• array_deleter< U >
• assign_type
• backend< dummy >
• bad_any_cast
• basic_range< SizeType, DistanceType >
• basic_slice< SizeType, DistanceType >
• bicgstab_tag
• block_ilu_precond< MatrixType, ILUTag >
• block_ilu_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT >, ILUTag >
• block_matrix
• block_vector
• body_code< ExpressionsList >
• build_program_failure
• cg_tag
• CHECK_ALIGNMENT_COMPATIBILITY< LHS, RHS >
• CHECK_ALIGNMENT_COMPATIBILITY< LHS, symbolic_constant< val > >
• CHECK_ALIGNMENT_COMPATIBILITY< symbolic_constant< val >, RHS >
• CHECK_SCALAR_TEMPLATE_ARGUMENT< T >
• CHECK_SCALAR_TEMPLATE_ARGUMENT< double >
• CHECK_SCALAR_TEMPLATE_ARGUMENT< float >
• circulant_matrix< SCALARTYPE, ALIGNMENT >
• cl_type< bool >
• cl_type< double >
• cl_type< float >
• cl_type< int >
• cl_type< long >
• classcomp
• col_iteration
• column_major
• column_major_tag
• command_queue
• compare1< T1, T2 >
• compare1< NullType, T >
• CompareSecond
• compiler_not_available
• compound_node< LHS_, OP_, RHS_ >
• compound_node< LHS_, inner_prod_type, RHS_ >
• compound_node< LHS_, prod_type, RHS_ >
• 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 >
• 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 >
• CONST_REMOVER< T >
• CONST_REMOVER< const T >
• const_sparse_matrix_adapted_iterator< SCALARTYPE, SizeType, is_iterator1, is_forward >
• const_sparse_matrix_adapter< SCALARTYPE, SizeType >
• const_sparse_matrix_adapter< SCALARTYPE >
  • sparse_matrix_adapter< SCALARTYPE, SizeType >
• const_vector_iterator< SCALARTYPE, ALIGNMENT >
  • vector_iterator< SCALARTYPE, ALIGNMENT >
• constant_expression< T >
• context
• convert_to_opencl< T >
• coordinate_matrix< SCALARTYPE, ALIGNMENT >
• coordinate_matrix< double, 1 >
• coordinate_matrix< double, 128 >
• coordinate_matrix< float, 1 >
• coordinate_matrix< float, 128 >
• count
• count_if< T, 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 >
• 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 >
• cpu_symbolic_scalar< ID, SCALARTYPE >
• cpu_tag
• cpu_value_type< T >
• cuda_deleter< U >
• custom_operation
• cuthill_mckee_tag
• default_tag
• device
• device_not_available
• device_not_found
• disable_if_c< B, T >
• disable_if_c< Cond::value, T >
  • disable_if< Cond, 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 >
• DOUBLE_PRECISION_CHECKER< double >
• double_precision_not_provided_error
• elementwise_div_type
• elementwise_modifier< T >
• elementwise_modifier_impl< T >
• elementwise_prod_type
• ell_matrix< SCALARTYPE, ALIGNMENT >
• ell_matrix< double, 1 >
• ell_matrix< float, 1 >
• enable_if< b, T >
• enable_if< false, T >
• enable_if_c< B, T >
• enable_if_c< Cond::value, T >
  • enable_if< Cond, T >
• enable_if_c< false, T >
• entry_proxy< SCALARTYPE >
• erase< NullType, T >
• erase< typelist< Head, Tail >, T >
• erase< typelist< Head, Tail >, typelist< Head2, Tail2 > >
• erase< typelist< T, Tail >, T >
• error_checker< T >
• expand< T >
• 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_right< LHS, OP, RHS_LHS, RHS_OP, RHS_RHS >
• expression_type< T >
• extract_if< T, Pred, Comp, TList >
• 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 >
• 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 >
• 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 >
• 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 >
• fspai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >
• fspai_tag
• 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
• gpu_symbolic_scalar< ID, SCALARTYPE >
• gpu_tag
• handle< OCL_TYPE >
• handle_inc_dec_helper< OCL_TYPE >
• handle_unary_minus< OP, RHS >
• handle_unary_minus< sub_type, RHS >
• hankel_matrix< SCALARTYPE, ALIGNMENT >
• program_infos< ARG >::fill_sources< Operations >::header_code< TList >
• hyb_matrix< SCALARTYPE, ALIGNMENT >
• hyb_matrix< double, 1 >
• hyb_matrix< float, 1 >
• ichol0_precond< MatrixType >
• ichol0_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >
• ichol0_tag
• identity_matrix< SCALARTYPE >
• ilu0_precond< MatrixType >
• ilu0_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >
• ilu0_tag
• ilu< double, 1 >
• ilu< float, 1 >
• ilu_vector_range< VectorType, ValueType, SizeType >
• ilut_precond< MatrixType >
• ilut_precond< compressed_matrix< ScalarType, MAT_ALIGNMENT > >
• ilut_tag
• 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
• 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 >
• 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 >
• is_double_type< T >
• is_double_type< NullType >
• is_eigen< Tag >
• 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 >
• is_mtl4< viennacl::tag_mtl4 >
• is_not< T >
• is_null_type< T >
• is_null_type< NullType >
• is_product< T >
• 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 > >
• is_same_expression_type< symbolic_constant< VAL >, Expr >
• 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 >
• is_stl< viennacl::tag_stl >
• is_subtraction< T >
• 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 >
• 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 >
• is_viennacl< viennacl::tag_viennacl >
• jacobi_precond< MatrixType, is_viennacl >
• jacobi_precond< MatrixType, true >
• jacobi_tag
• kernel
• lanczos_tag
• length< NullType >
• length< typelist< T, U > >
• local_mem
• lower_tag
• 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 >
• 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
• matrix_array_wrapper< NumericT, MajorityCategory, is_transposed >
• matrix_array_wrapper< NumericT, MajorityCategory, true >
• matrix_base< SCALARTYPE, F, SizeType, DistanceType >
• matrix_base< MatrixType::cpu_value_type, MatrixType::orientation_functor >
  • matrix_range< MatrixType >
  • matrix_slice< MatrixType >
• matrix_base< SCALARTYPE, F >
  • matrix< SCALARTYPE, F, ALIGNMENT >
• 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 >
• matrix_iterator< ROWCOL, MATRIXTYPE >
• MATRIX_ITERATOR_INCREMENTER< ROWCOL, MATRIXTYPE >
• MATRIX_KERNEL_CLASS_DEDUCER< MatrixType1 >
• 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 >
• 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_row< double, 1 >
• matrix_row< double, 16 >
• matrix_row< float, 1 >
• matrix_row< float, 16 >
• MATRIX_SIZE_DEDUCER< LHS, RHS, OP >
• 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 >
• 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_handle
• mem_object_allocation_failure
• mixed_precision_cg_tag
• nmf< double, 1 >
• nmf< float, 1 >
• nmf_config
• no_duplicates< NullType >
• no_duplicates< typelist< Head, Tail > >
• no_precond
• NullType
• or_is< S, T >
• orientation_functor< T >
• out_of_host_memory
• out_of_resources
• packed_cl_uint
• parameter_database
• platform
• power_iter_tag
• 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 >
• rand< double, 1 >
• rand< float, 1 >
• register_kernels< NullType, Res, CurrentIndex >
• register_kernels< typelist< Head, Tail >, Res, CurrentIndex >
• remove_if< T, Pred, inspect_nested >
• 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
• row_major
• row_major_tag
• row_scaling< MatrixType, is_viennacl >
• row_scaling< MatrixType, true >
• 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
• runtime_wrapper
  • matrix_runtime_wrapper< T, SIZE1_T, SIZE2_T >
  • scalar_runtime_wrapper< T >
  • scalar_runtime_wrapper< viennacl::generator::cpu_symbolic_scalar< ID, ScalarType > >
  • shared_memory_wrapper
  • vector_expression< T, SIZE_DESCRIPTOR >
  • vector_runtime_wrapper< T, SIZE_T >
• scal_div_type
• scal_mul_type
• scalar< SCALARTYPE >
• scalar< double, 1 >
• scalar< float, 1 >
• scalar_expression< LHS, RHS, OP >
• scalar_expression< T >
• scalar_expression< LHS, RHS, op_inner_prod >
• scalar_expression< LHS, RHS, op_norm_1 >
• scalar_expression< LHS, RHS, op_norm_2 >
• scalar_expression< LHS, RHS, op_norm_inf >
• scalar_matrix< SCALARTYPE >
• scalar_vector< SCALARTYPE >
• shared_ptr< T >
• size_type< T >
• spai< double, 1 >
• spai< float, 1 >
• spai_precond< MatrixType >
• spai_precond< viennacl::compressed_matrix< ScalarType, MAT_ALIGNMENT > >
• spai_tag
• sparse_matrix_adapted_iterator< SCALARTYPE, SizeType, is_iterator1 >
• sparse_vector< ScalarType >
• sub_type
• svd< double, 1 >
• svd< float, 1 >
• symbolic_constant< VAL >
• symbolic_matrix< ID, SCALARTYPE, F, ALIGNMENT >
• symbolic_vector< ID, SCALARTYPE, ALIGNMENT >
• 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 >
• to_string< double >
• to_string< float >
• toeplitz_matrix< SCALARTYPE, ALIGNMENT >
• Token< Expr_ >
• Token< Expr >
  • ArithmeticToken< Expr >
  • InProdToken< Expr, Step_ >
  • MatMatToken< Expr, OP_, Assigned_ >
  • MatVecToken< Expr, OP_, Assigned_ >
• transform_inner_prod< T >
• 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 >
• typesafe_host_array< T, true >
• unit_lower_tag
• unit_upper_tag
• unit_vector< SCALARTYPE >
• unknown_error
• upper_tag
• value_base
  • value< T >
• value_type< T >
• vandermonde_matrix< SCALARTYPE, ALIGNMENT >
• vcl_static_assert< true >
• 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 >
• vector_base< SCALARTYPE >
  • vector< SCALARTYPE, ALIGNMENT >
• vector_base< VectorType::cpu_value_type >
  • vector_range< VectorType >
  • vector_slice< VectorType >
• vector_expression< LHS, RHS, OP >
• VECTOR_EXTRACTOR< LHS, RHS >
• VECTOR_EXTRACTOR_IMPL< LHS, RHS >
• zero_matrix< SCALARTYPE >
• zero_vector< SCALARTYPE >