ViennaCL - The Vienna Computing Library
1.4.2
Main Page
Namespaces
Data Structures
Files
Data Structures
Class Hierarchy
Data Fields
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 >
Generated on Sun Apr 28 2013 21:44:56 for ViennaCL - The Vienna Computing Library by
1.7.6.1