OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 Ccub::AgentHistogram< AgentHistogramPolicyT, PRIVATIZED_SMEM_BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, PrivatizedDecodeOpT, OutputDecodeOpT, OffsetT, PTX_ARCH >::_TempStorageShared memory type required by this thread block
 Ccub::AgentReduce< AgentReducePolicy, InputIteratorT, OutputIteratorT, OffsetT, ReductionOp >::_TempStorageShared memory type required by this thread block
 Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::_TempStorage
 Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage
 Ccub::AgentScan< AgentScanPolicyT, InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::_TempStorage
 Ccub::AgentSegmentFixup< AgentSegmentFixupPolicyT, PairsInputIteratorT, AggregatesOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::_TempStorage
 Ccub::AgentSelectIf< AgentSelectIfPolicyT, InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::_TempStorage
 Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::_TempStorageShared memory type required by this thread block
 Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type (last element from each thread's input)
 Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type (last element from each thread's input)
 Ccub::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory
 Ccub::BlockRadixSort< KeyT, BLOCK_DIM_X, ITEMS_PER_THREAD, ValueT, RADIX_BITS, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::BlockReduceRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::BlockReduceRakingCommutativeOnly< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::BlockReduceWarpReductions< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::BlockScanRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, MEMOIZE, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::BlockShuffle< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type (last element from each thread's input)
 Ccub::TilePrefixCallbackOp< T, ScanOpT, ScanTileStateT, PTX_ARCH >::_TempStorage
 Ccub::WarpExchange< T, ITEMS_PER_THREAD, LOGICAL_WARP_THREADS, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::WarpReduceSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >::_TempStorageShared memory storage layout type (1.5 warps-worth of elements for each warp)
 Cgrid_dist_amr_key_iterator< dim, device_grid, device_sub_it, it_type >::actual_itActual it type
 CAdaptiveCylinderCone< dim, T >This class represent an Adaptive cylinder cone
 Cadd_< Tdst, Tsrc >This structure define the operation add to use with copy general
 Cadd_atomic_< Tdst, Tsrc >This structure define the operation add to use with copy general
 Cadd_const_reference< T, is_reference >
 Cadd_const_reference< T, true >
 Cadd_const_reference< vector_orig >
 Copenfpm::add_prp_device_impl< is_ok_cuda, T, Memory, layout_base, grow_p >
 Copenfpm::add_prp_device_impl< true, T, Memory, layout_base, grow_p >
 Cadd_prp_impl< objv, vect_dst >Struct to merge two vectors
 Cadd_prp_impl< OBJECT_ADD, vect_dst >Struct to merge two vectors
 CAexampleExample structure
 Ccub::AgentHistogram< AgentHistogramPolicyT, PRIVATIZED_SMEM_BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, PrivatizedDecodeOpT, OutputDecodeOpT, OffsetT, PTX_ARCH >AgentHistogram implements a stateful abstraction of CUDA thread blocks for participating in device-wide histogram
 ►Ccub::AgentHistogramPolicy< _BLOCK_THREADS, _PIXELS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _RLE_COMPRESS, _MEM_PREFERENCE, _WORK_STEALING >< Whether to dequeue tiles from a global work queue
 Ccub::AgentRadixSortDownsweep< AgentRadixSortDownsweepPolicy, IS_DESCENDING, KeyT, ValueT, OffsetT >AgentRadixSortDownsweep implements a stateful abstraction of CUDA thread blocks for participating in device-wide radix sort downsweep
 Ccub::AgentRadixSortDownsweepPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _RANK_ALGORITHM, _SCAN_ALGORITHM, _RADIX_BITS >< The number of radix bits, i.e., log2(bins)
 Ccub::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >AgentRadixSortUpsweep implements a stateful abstraction of CUDA thread blocks for participating in device-wide radix sort upsweep
 Ccub::AgentRadixSortUpsweepPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_MODIFIER, _RADIX_BITS >< The number of radix bits, i.e., log2(bins)
 Ccub::AgentReduce< AgentReducePolicy, InputIteratorT, OutputIteratorT, OffsetT, ReductionOp >AgentReduce implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduction
 Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >AgentReduceByKey implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduce-value-by-key
 ►Ccub::AgentReduceByKeyPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _SCAN_ALGORITHM >< The BlockScan algorithm to use
 Ccub::AgentReducePolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _VECTOR_LOAD_LENGTH, _BLOCK_ALGORITHM, _LOAD_MODIFIER >< Cache load modifier for reading input elements
 Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >AgentRle implements a stateful abstraction of CUDA thread blocks for participating in device-wide run-length-encode
 ►Ccub::AgentRlePolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _STORE_WARP_TIME_SLICING, _SCAN_ALGORITHM >< The BlockScan algorithm to use
 Ccub::AgentScan< AgentScanPolicyT, InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >AgentScan implements a stateful abstraction of CUDA thread blocks for participating in device-wide prefix scan
 ►Ccub::AgentScanPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _STORE_ALGORITHM, _SCAN_ALGORITHM >< The BlockScan algorithm to use
 Ccub::AgentSegmentFixup< AgentSegmentFixupPolicyT, PairsInputIteratorT, AggregatesOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >AgentSegmentFixup implements a stateful abstraction of CUDA thread blocks for participating in device-wide reduce-value-by-key
 ►Ccub::AgentSegmentFixupPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _SCAN_ALGORITHM >< The BlockScan algorithm to use
 Ccub::AgentSelectIf< AgentSelectIfPolicyT, InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >AgentSelectIf implements a stateful abstraction of CUDA thread blocks for participating in device-wide selection
 ►Ccub::AgentSelectIfPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _LOAD_ALGORITHM, _LOAD_MODIFIER, _SCAN_ALGORITHM >< The BlockScan algorithm to use
 Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >AgentSpmv implements a stateful abstraction of CUDA thread blocks for participating in device-wide SpMV
 ►Ccub::AgentSpmvPolicy< _BLOCK_THREADS, _ITEMS_PER_THREAD, _ROW_OFFSETS_SEARCH_LOAD_MODIFIER, _ROW_OFFSETS_LOAD_MODIFIER, _COLUMN_INDICES_LOAD_MODIFIER, _VALUES_LOAD_MODIFIER, _VECTOR_VALUES_LOAD_MODIFIER, _DIRECT_LOAD_NONZEROS, _SCAN_ALGORITHM >< The BlockScan algorithm to use
 Cagg_arr< n_ele >It store the offsets of the interpolation points
 Caggregate< list >Aggregate of properties, from a list of object if create a struct that follow the OPENFPM native structure
 ►Caggregate< T >
 Caggregate< vector_dist_expression< double > >
 Caggregate< vector_dist_expression< double >, vector_dist_expression< double > >
 Caggregate< vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double > >
 Caggregate< vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double > >
 Caggregate< vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double > >
 Caggregate_add< aggr >
 Caggregate_add< aggregate< types ... > >
 Caggregate_bfv< T >An aggregate that accept a boost fusion vector as type
 Caggregate_convert< dim, blockEdgeSize, aggr >
 Caggregate_convert< dim, blockEdgeSize, aggregate< types ... > >
 Caggregate_or_known_type< layout_base, T, impl, args >
 Caggregate_or_known_type< layout_base, T, 2, args ... >
 Caggregate_or_known_type< layout_base, T, 4, args ... >
 Caggregate_transform_datablock_impl< dim, blockEdgeSize, aggr_list >
 CAggregateAppend< BlockT, T >
 CAggregateAppend< BlockT, aggregate< list ... > >
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type >
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1]>
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1][N2]>
 CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1][N2][N3]>
 Ccub::AgentHistogram< AgentHistogramPolicyT, PRIVATIZED_SMEM_BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, PrivatizedDecodeOpT, OutputDecodeOpT, OffsetT, PTX_ARCH >::_TempStorage::Aliasable
 Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage::Aliasable
 Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::_TempStorage::Aliasable
 Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage::Aliasable
 ►Ccub::AlignBytes< T >Structure alignment
 Callocate< S >This class is a functor for "for_each" algorithm
 Calpa_base_structs
 CAMG_time_err_coarsIt contain information about the performance of the AMG
 Camr_launch_sparse
 Canyname_field[Constant fields struct definition]
 Canyname_field_with_posDefine a non-constant (in space) field
 Capply_kernel_is_number_or_expression< impl, T, vector, exp, NN_type, Kernel, rtype, is_exp >Apply the kernel to particle differently that is a number or is an expression
 Capply_kernel_is_number_or_expression_gen< impl, T, vector, exp, NN_type, Kernel, rtype, is_exp >Apply the kernel to particle differently that is a number or is an expression
 Capply_kernel_is_number_or_expression_sim< impl, vector, exp, NN_type, Kernel, rtype >Apply the kernel to particle differently that is a number or is an expression
 Capply_kernel_rtype< exp, is_exp >It give the return type of the expression if applicable
 Capply_kernel_rtype< exp, false >It give the return type of the expression if applicable
 Capply_transform< layout_base, T >
 Capply_trasform_impl< layout_base, T, args >
 Capply_trasform_impl< layout_base, T, boost::fusion::vector< args... > >
 Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, HAS_PARAM >Specialization for when FlagOp has third index param
 Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, HAS_PARAM >Specialization for when FlagOp has third index param
 Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, false >Specialization for when FlagOp does not have a third index param
 Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, false >Specialization for when FlagOp does not have a third index param
 Ccub::ArgIndexInputIterator< InputIteratorT, OffsetT, OutputValueT >A random-access input wrapper for pairing dereferenced values with their corresponding indices (forming KeyValuePair tuples)
 Ccub::ArgMaxArg max functor (keeps the value and offset of the first occurrence of the larger item)
 Ccub::ArgMinArg min functor (keeps the value and offset of the first occurrence of the smallest item)
 Carr_arr_ptr< n_it, n_prp >
 Carr_arr_ptr< 1, sizeof...(prp)>
 Carr_arr_ptr< n_it, sizeof...(prp)>
 Carr_ptr< n_it >
 Copenfpm::array< T, N, ids_type >
 Copenfpm::array< ids_type, dim, cnt_type >
 Copenfpm::array< index, NumDims >
 Copenfpm::array< size_type, NumDims >
 Copenfpm::array< T, 0 >
 Copenfpm::array< T, dim, cnt_type >
 Carray_asc< dim >
 Carray_asc< 2 >
 Carray_asc< 3 >
 Carray_asc< 4 >
 Carray_extents< T >Struct that give functionalities on array extensions
 Carray_extents< T[N1]>Struct that give functionalities on array extensions
 Carray_extents< T[N1][N2]>Struct that give functionalities on array extensions
 Carray_extents< T[N1][N2][N3]>Struct that give functionalities on array extensions
 Cboost::array_openfpm< T, N, ids_type >
 Cboost::array_openfpm< T, 0 >
 Carray_ord< dim, size_type >
 Carray_ord< 2, size_type >
 Carray_ord< 3, size_type >
 Carray_ord< 4, size_type >
 Carray_to_vmpl< T >Partial specialization for scalar N=0
 Carray_to_vmpl< T[N1]>Partial specialization for N=1
 Carray_to_vmpl< T[N1][N2]>Partial specialization for N=2
 Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vector, TPtr >::array_view< NDims >
 Copenfpm::detail::multi_array::sub_array_openfpm< T, NumDims, vector >::array_view< NDims >
 Copenfpm::array_view_gen_openfpm< Array, N >
 Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector >::array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims >::array_view_openfpm< NDims >
 CArrayHolder< T, args >Array itself
 CArrayHolder_constexpr< T, args >Array itself
 CArrayHolder_indexes< T, args >Array itself
 CArrayWrapper< BaseT >
 Ccub::ArrayWrapper< T, COUNT >A wrapper for passing simple static arrays as kernel parameters
 CArrayWrapper< BaseType[N1]>
 CArrayWrapper< BaseType[N1][N2]>
 Cas_array_nnc< dim >Set a dimension threshold
 Cmemory_c< multi_array< T >, MEMORY_C_STANDARD, D >::ascending< index, N >In combination with generate_array is used to produce array at compile-time
 Cat_impl< vector, p, bool >
 Cat_impl< vector, p, true >
 Ced::attributesAttributes name
 Cne_cp::attributesDefine attributes names
 Cnm_e::attributesAttributes name
 Cnm_part_e::attributesAttributes name
 Cnm_part_v::attributesAttributes name
 Cnm_v< dim >::attributesAttributes name
 Cnode_cp::attributesAttributes name
 CPoint_test_prp< T >::attributesAttributes name
 CPoint_test_scal< T >::attributesAttributes name
 Ctest_has_attributes::attributesDefine attribute names
 Cvertex2::attributesAttributes name
 Cvertex3::attributesAttributes name
 Cvertex::attributesAttributes name
 Cvx::attributesAttributes name
 CAvg< d, Field, Sys_eqs, impl >Average
 CAvg< d, arg, Sys_eqs, BACKWARD >First order BACKWARD derivative on direction i
 CAvg< d, arg, Sys_eqs, CENTRAL >Central average scheme on direction i
 CAvg< d, arg, Sys_eqs, FORWARD >FORWARD average on direction i
 Cb_cast_helper< is_lin_or_inte >
 Cb_cast_helper< false >
 Cbase_copy< has_base, base_obj, v_obj >
 Cbase_copy< true, base_obj, v_obj >
 CVcluster< InternalMemory >::base_info< Memory >Base info
 CVcluster< InternalMemory >::base_info< HeapMemory >
 ►Ccub::BaseTraits< _CATEGORY, _PRIMITIVE, _NULL_TYPE, _UnsignedBits, T >Basic type traits
 Ccub::BaseTraits< FLOATING_POINT, true, false, _UnsignedBits, T >
 ►Ccub::BaseTraits< FLOATING_POINT, true, false, unsigned int, float >
 ►Ccub::BaseTraits< FLOATING_POINT, true, false, unsigned long long, double >
 Ccub::BaseTraits< NOT_A_NUMBER, false, false, RemoveQualifiers< T >::Type, RemoveQualifiers< T >::Type >
 ►Ccub::BaseTraits< NOT_A_NUMBER, false, false, T, T >
 ►Ccub::BaseTraits< NOT_A_NUMBER, false, true, NullType, NullType >
 Ccub::BaseTraits< SIGNED_INTEGER, true, false, _UnsignedBits, T >
 ►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned char, signed char >
 ►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned int, int >
 ►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned long long, long long >
 ►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned long, long >
 ►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned short, short >
 Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, _UnsignedBits, T >
 ►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, UnitWord< bool >::VolatileWord, bool >
 ►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned char, unsigned char >
 ►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned int, unsigned int >
 ►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned long long, unsigned long long >
 ►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned long, unsigned long >
 ►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned short, unsigned short >
 ►Ccub::BaseTraits<(std::numeric_limits< char >::is_signed) ? SIGNED_INTEGER :UNSIGNED_INTEGER, true, false, unsigned char, char >
 Cbcast_inte_impl< vect >This class is a functor for "for_each" algorithm
 Cbest_conv< source1, source2 >
 Cbest_conv_impl< source1, source2 >
 Cbest_conv_impl< int, source2 >
 Cbest_conv_impl< long int, source2 >
 Cbest_conv_impl< source1, int >
 Cbest_conv_impl< source1, long int >
 Cbest_conv_impl< source1, unsigned int >
 Cbest_conv_impl< source1, unsigned long int >
 Cbest_conv_impl< unsigned int, source2 >
 Cbest_conv_impl< unsigned long int, source2 >
 ►Cstd::binary_function
 Ccub::BinaryOpHasIdxParam< T, BinaryOp >Determine whether or not BinaryOp's functor is of the form bool operator()(const T& a, const T&b) or bool operator()(const T& a, const T&b, unsigned int idx)
 Cbisect_unroll< dim, ORB >This class is a functor for "for_each" algorithm
 Cblock_offset< indexT >
 Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >
 Ccub::CachingDeviceAllocator::BlockDescriptor
 Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockDiscontinuity class provides collective methods for flagging discontinuities within an ordered set of items partitioned across a CUDA thread block
 Ccub::BlockExchange< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, WARP_TIME_SLICING, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockExchange class provides collective methods for rearranging data partitioned across a CUDA thread block
 Ccub::BlockHistogram< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockHistogram class provides collective methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block
 Ccub::BlockHistogramAtomic< BINS >The BlockHistogramAtomic class provides atomic-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block
 Ccub::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockHistogramSort class provides sorting-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockLoad class provides collective data movement methods for loading a linear segment of items from memory into a blocked arrangement across a CUDA thread block
 ►CBlockMapGpu< AggregateBlockT, threadBlockSize, indexT, layout_base >
 CBlockMapGpu< aggregate_convert< dim, default_edge< dim >::type::value, AggregateT >::type, default_edge< dim >::tb::value, long int, memory_traits_inte >
 CBlockMapGpu_ker< AggregateBlockT, indexT, layout_base >
 ►CBlockMapGpu_ker< AggregateBlockT, indexT, layout_base >
 Ccub::BlockRadixRank< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >BlockRadixRank provides operations for ranking unsigned integer types within a CUDA thread block
 Ccub::BlockRadixRankMatch< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, INNER_SCAN_ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >
 Ccub::BlockRadixSort< KeyT, BLOCK_DIM_X, ITEMS_PER_THREAD, ValueT, RADIX_BITS, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockRadixSort class provides collective methods for sorting items partitioned across a CUDA thread block using a radix sorting method
 Ccub::BlockRakingLayout< T, BLOCK_THREADS, PTX_ARCH >BlockRakingLayout provides a conflict-free shared memory layout abstraction for 1D raking across thread block data
 Ccub::BlockReduce< T, BLOCK_DIM_X, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockReduce class provides collective methods for computing a parallel reduction of items partitioned across a CUDA thread block
 Ccub::BlockReduceRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >BlockReduceRaking provides raking-based methods of parallel reduction across a CUDA thread block. Supports non-commutative reduction operators
 Ccub::BlockReduceRakingCommutativeOnly< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >BlockReduceRakingCommutativeOnly provides raking-based methods of parallel reduction across a CUDA thread block. Does not support non-commutative reduction operators. Does not support block sizes that are not a multiple of the warp size
 Ccub::BlockReduceWarpReductions< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >BlockReduceWarpReductions provides variants of warp-reduction-based parallel reduction across a CUDA thread block. Supports non-commutative reduction operators
 Ccub::BlockScan< T, BLOCK_DIM_X, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockScan class provides collective methods for computing a parallel prefix sum/scan of items partitioned across a CUDA thread block
 Ccub::BlockScanRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, MEMOIZE, PTX_ARCH >BlockScanRaking provides variants of raking-based parallel prefix scan across a CUDA thread block
 Ccub::BlockScanRunningPrefixOp< T, ScanOpT >< Wrapped scan operator type
 Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >BlockScanWarpScans provides warpscan-based variants of parallel prefix scan across a CUDA thread block
 Ccub::BlockShuffle< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockShuffle class provides collective methods for shuffling data partitioned across a CUDA thread block
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >The BlockStore class provides collective data movement methods for writing a blocked arrangement of items partitioned across a CUDA thread block to a linear segment of memory
 CBoundaryStencilSetX< dim, p_src, p_dst >
 CBoundaryStencilSetXRescaled< dim, p_src, p_dst, ScalarT >
 ►CBox< dim, T >This class represent an N-dimensional box
 CBox< 3, float >
 CBox< Decomposition::dims, typename Decomposition::stype >
 CBox< dim, dT >
 CBox< dim, int >
 CBox< dim, long int >
 ►CBox< dim, size_t >
 CBox< dim, St >
 CBox< dim, typename grid_in_type::stype >
 CBox< dim, typename last::stype >
 CBox< dim, typename Sys_eqs::stype >
 CBox< grid::dims, size_t >
 CBox< Grid::dims, size_t >
 CBox< N, size_t >
 CBox< SparseGridType::dims, size_t >
 CBox< vector::dims, size_t >
 CBox< vector::dims, typename vector::stype >
 CBox_check< dim, T >
 CBox_dom< dim, T >Case for external ghost box
 CBox_fix< dim >Internal ghost box sent to construct external ghost box into the other processors
 CCartDecomposition< dim, T, Memory, layout_base, Distribution >::box_idClass to select the returned id by ghost_processorID
 CBox_loc_sub< dim, T >For each sub-domain box sub contain the real the sub-domain id
 CBox_proc< dim, T >Case for local external ghost box
 CBox_sub< dim, T >
 CBox_sub_k< dim, T >Particular case for local internal ghost boxes
 Cinterpolate< vector, grid, kernel >::Box_vol
 CBoxDistribution< dim, T >Class that distribute sub-sub-domains across processors using Metis Library
 Cbrt_test
 Cbump< dim >
 Copenfpm::c_storage_order
 Ccub::CacheModifiedInputIterator< MODIFIER, ValueType, OffsetT >A random-access input wrapper for dereferencing array values using a PTX cache load modifier
 Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::COLUMN_INDICES_LOAD_MODIFIER, OffsetT, OffsetT >
 Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::ROW_OFFSETS_LOAD_MODIFIER, OffsetT, OffsetT >
 Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::VALUES_LOAD_MODIFIER, ValueT, OffsetT >
 Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::VECTOR_VALUES_LOAD_MODIFIER, ValueT, OffsetT >
 Ccub::CacheModifiedInputIterator< LOAD_MODIFIER, UnsignedBits, OffsetT >
 Ccub::CacheModifiedInputIterator< LOAD_MODIFIER, ValueT, OffsetT >
 Ccub::CacheModifiedOutputIterator< MODIFIER, ValueType, OffsetT >A random-access output wrapper for storing array values using a PTX cache-modifier
 Ccub::CachingDeviceAllocatorA simple caching allocator for device memory allocations
 Ccalculate_aint< dims, vector, np >Calculate aint
 Ccalculate_aint< 2, vector, np >Calculate aint 2D
 Ccalculate_aint< 3, vector, np >Calculate aint
 CCalcVelocity< DX, DY, DXX, DXY, DYY >
 Ccall_aggregatePack< obj_type, Mem, prp >Calls a packer in nested way
 Ccall_aggregatePackRequest< obj_type, Mem, prp >
 Ccall_aggregatePackRequestChunking< obj_type, Mem, prp >
 Ccall_aggregateUnpack< obj_type, Mem, prp >Calls an unpacker in nested way
 Ccall_encapPack< encap, Mem, prp >
 Ccall_encapPackChunking< encap, Mem, prp >
 Ccall_encapPackRequest< encap, Mem, prp >
 Ccall_encapUnpack< encap, Mem, prp >
 Ccall_encapUnpackChunking< encap, Mem, prp >
 Ccall_init_if_needed< T, has_init >Call the init function if a type T has the function init
 Ccall_init_if_needed< T, false >Call the init function if a type T has the function init
 Ccall_pack_agg_functor< obj_type, Mem >
 Ccall_pack_enc_functor< encap, Mem >
 Ccall_pack_enc_functor_chunking< encap, Mem >
 Ccall_pack_enc_functor_chunking_impl_arr< Timp >
 Ccall_pack_enc_functor_chunking_impl_arr< Timp[N1]>
 Ccall_packRequest_agg_functor< obj_type, Mem >
 Ccall_packRequest_agg_functor_cnk< obj_type, Mem >
 Ccall_packRequest_enc_functor< encap, Mem >
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, is_vector >
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 0 >
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 3 >
 Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 4 >
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, is_vector >
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 0 >
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 3 >
 Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 4 >
 Ccall_serialize_variadic< T >
 Ccall_serialize_variadic< index_tuple< prp... > >
 Ccall_unpack_agg_functor< obj_type, Mem >
 Ccall_unpack_encap_functor< encap, Mem, prp >
 Ccall_unpack_encap_functor_chunking< encap, Mem, prp >
 Ccall_unpack_encap_functor_chunking_array_selector< T >
 Ccall_unpack_encap_functor_chunking_array_selector< T[N1]>
 CCartesianGraphFactory< dim, Graph >This class construct a cartesian graph
 Ccub::CastOp< B >Default cast functor
 Ccell_grid< Grid >For each combination in the cell grid you can have different grids
 Ccell_list_selector< vector, impl >
 Ccell_list_selector< vector, comp_host >
 ►CCellDecomposer_gpu_ker< dim, T, cnt_type, ids_type, transform >
 ►CCellDecomposer_sm
 ►CCellIterator< Cell >It iterate through the elements of a cell
 ►CCellList< dim, T, Mem_fast<>, no_transform< dim, T >, openfpm::vector< Point< dim, T > > >
 ►CCellList< dim, T, Mem_fast<>, shift< dim, T > >
 ►CCellNNIterator< dim, Cell, NNc_size, impl >Iterator for the neighborhood of the cell structures
 ►CCellNNIterator< dim, Cell, RUNTIME, impl >Iterator for the neighborhood of the cell structures
 CCellNNIteratorRadius< dim, Cell, impl >Iterator for the neighborhood of the cell structures with free radius
 Ccub::ChainedPolicy< PTX_VERSION, PolicyT, PrevPolicyT >Helper for dispatching into a policy chain
 ►Ccub::ChainedPolicy< 130, Policy130, Policy130 >
 ►Ccub::ChainedPolicy< 200, Policy200, Policy130 >
 ►Ccub::ChainedPolicy< 200, Policy200, Policy200 >
 ►Ccub::ChainedPolicy< 300, Policy300, Policy200 >
 ►Ccub::ChainedPolicy< 350, Policy350, Policy300 >
 ►Ccub::ChainedPolicy< 500, Policy500, Policy350 >
 ►Ccub::ChainedPolicy< 600, Policy600, Policy350 >
 ►Ccub::ChainedPolicy< 600, Policy600, Policy500 >
 ►Ccub::ChainedPolicy< 610, Policy610, Policy600 >
 ►Ccub::ChainedPolicy< 620, Policy620, Policy610 >
 ►Ccub::ChainedPolicy< 700, Policy700, Policy620 >
 Ccub::ChainedPolicy< PTX_VERSION, PolicyT, PolicyT >Helper for dispatching into a policy chain (end-of-chain specialization)
 Ccheader< dim >This structure contain the information of a chunk
 Ccheck_all_apply_ker< impl >
 Ccheck_all_apply_ker< comp_dev >
 Ccheck_all_apply_ker_sort
 Ccheck_all_expressions< impl >
 Ccheck_all_expressions< comp_dev >
 Ccheck_device_ptr< data_type >This class is a functor for "for_each" algorithm
 Ccheck_nan< T >
 Ccheck_nan< double >
 Ccheck_nan< float >
 Ccheck_no_pointers< T >This class check if the type T has pointers inside
 Ccheck_no_pointers_impl< T, has_pointer >Check if the type T has pointers inside
 Ccheck_no_pointers_impl< T, false >Check if the type T has pointers inside
 Ccheck_type< T, type_of_t >
 Ccheck_type< T, 1 >
 Ccheck_types< v >Functor for for_each algorithm
 CCheckExistenceClass to check if the edge can be created or not
 Copenfpm::detail::multi_array::choose_value_accessor_n_openfpm< T, NumDims, vector >
 Copenfpm::detail::multi_array::choose_value_accessor_one_openfpm< T, vector >
 Ccid_< dim, cnt_type, ids_type, transform >
 Ccid_< 1, cnt_type, ids_type, transform >
 Ccid_< 2, cnt_type, ids_type, transform >
 Ccid_< 3, cnt_type, ids_type, transform >
 Ccl_selector_impl< cl_type, impl >
 Ccl_selector_impl< cl_type, 1 >
 Ccl_selector_impl< cl_type, 2 >
 Ccomb< dim >Position of the element of dimension d in the hyper-cube of dimension dim
 Ccomb< 0 >
 Ccomb< Grid::dims >
 Ccomb< Sys_eqs::dims >
 Ccompare_aggregate< S >Structure to compare aggregates
 Ccompare_cpu_encap_encap< e_src, e_dst >This class is a functor for "for_each" algorithm
 Ccompare_fusion_vector< bfv >This class is a functor for "for_each" algorithm
 Ccompare_general< T, agg >Structure to copy aggregates
 Ccompare_general< T, 0 >
 Ccompare_general< T, 2 >
 Ccompare_host_device< base_type, prp >
 Ccompare_host_device< base_type[N1], prp >
 Ccompare_host_device< base_type[N1][N2], prp >
 Ccompare_host_device< Point< N1, base_type >, prp >
 CComposeArrayType< BaseT >
 CComposeArrayType< BaseType[N1]>
 CComposeArrayType< BaseType[N1][N2]>
 Cconditional_push< v, p_ele, to_push >Push p_ele into v only of to_push is true
 Cconditional_push< v, p_ele, false >Push p_ele into v only of to_push is true
 Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vector, TPtr >::const_array_view< NDims >
 Copenfpm::detail::multi_array::sub_array_openfpm< T, NumDims, vector >::const_array_view< NDims >
 Copenfpm::const_array_view_gen_openfpm< Array, N >
 Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector >::const_array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::const_array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims >::const_array_view_openfpm< NDims >
 Cconst_mul_functor_value< v_expr >Multiplication expression
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::const_subarray< NDims >
 Copenfpm::const_subarray_gen_openfpm< Array, N, vector >
 CFD_scheme< Sys_eqs, grid_type >::constant_bEncapsulation of the b term as constant
 CFDScheme< Sys_eqs >::constant_bEncapsulation of the b term as constant
 Ccub::ConstantInputIterator< ValueType, OffsetT >A random-access input generator for dereferencing a sequence of homogeneous values
 CConstField
 Cconstruct_expression< T >
 Cconstruct_expression< double >Construct a vector expression from a double
 Cconstruct_expression< float >Construct a vector expression from a float
 Cgpu::context_t
 CConv3x3x3< dim, p_src, p_dst >
 CConv3x3x3_noshared< dim, p_src, p_dst >
 Cconv_coeff
 Cconv_impl< dim >
 Cconv_impl< 3 >
 CConv_tol_change< phi_type >Optional convergence criterium checking the total change
 CConv_tol_change< double >
 CConv_tol_residual< phi_type >Optional convergence criterium checking the residual
 CConv_tol_residual< double >
 Cconvert< A >Set a conversion map between A and B
 Cconvert< std::string >Partial specialization when A is a string
 Ccopy_acc< S >This class is a functor for "for_each" algorithm
 Ccopy_aggregate< S >Structure to copy aggregates
 Ccopy_aggregate_dual< S, S2 >Structure to copy aggregates
 Ccopy_aggregate_op< op, S >Structure to copy aggregates applying an operation
 Ccopy_all_prop_sparse< e_src, e_dst, indexT >
 Ccopy_bck< Tsrc, Tdst >
 Ccopy_corner_3< layout_type, prop, stencil_size, chunking, is_cross >Copy point in 3D
 Ccopy_corner_3< layout_type, prop, 1, chunking, is_cross >Copy point in 3D
 Ccopy_corner_3< layout_type, prop, stencil_size, chunking, true >Copy point in 3D
 Ccopy_cpu_encap< dim, S, Memory >This class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_encap< e_src, e_dst >This class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_encap_general< e_src, e_dst >This class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_encap_op_prp< op, e_src, e_dst, prp >It copy two encap object
 Ccopy_cpu_encap_encap_prp< e_src, e_dst, prp >This class is a functor for "for_each" algorithm
 Ccopy_cpu_encap_single< e_src >This class is a functor for "for_each" algorithm
 Ccopy_ele< Eqs_sys, S, Ev >This class is a functor for "for_each" algorithm
 Ccopy_ele_sca_array< copy_type, T, Ev, Eqs_sys, sa >Copy scalar elements
 Ccopy_ele_sca_array< copy_type, T, Ev, Eqs_sys, 1 >Copy 1D array elements
 Ccopy_encap_vector_fusion< enc, bfv >This class is a functor for "for_each" algorithm
 Ccopy_fast_1d_device_memory< lin_or_inte, data_type, S >This class is a functor for "for_each" algorithm
 Ccopy_fast_1d_device_memory< true, data_type, S >This class is a functor for "for_each" algorithm
 Ccopy_fusion_vector< bfv >This class is a functor for "for_each" algorithm
 Ccopy_fusion_vector_encap< bfv, enc >This class is a functor for "for_each" algorithm
 Ccopy_general< T, agg >Structure to copy aggregates
 Ccopy_general< T, 1 >Specialization for if dst type is copy assignable from src type
 Ccopy_general< T, 2 >Specialization for aggregate type object
 Ccopy_general< T, 3 >Specialization for aggregate type object that define an operator=
 Ccopy_general_op< op, T, agg >Structure to copy aggregates applying an operation
 Ccopy_general_op< op, T, 1 >Specialization for object that can be assigned with an operator copy
 Ccopy_general_op< op, T, 3 >Specialization for aggregate type objects
 Ccopy_grid_fast< is_complex, N, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< false, 2, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< false, 3, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< true, 1, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< true, 2, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast< true, 3, grid, ginfo >This is a way to quickly copy a grid into another grid
 Ccopy_grid_fast_caller< T >
 Ccopy_grid_fast_caller< index_tuple_sq< prp ... > >
 Ccopy_grid_fast_layout_switch< is_inte, dim, grid, ginfo >
 Ccopy_grid_fast_layout_switch< true, dim, grid, ginfo >
 Ccopy_ndim_fast_selector< dim >
 Ccopy_ndim_fast_selector< 2 >
 Ccopy_ndim_fast_selector< 3 >
 Ccopy_packer_chunk< e_src, e_dst >It copy one element of the chunk for each property
 Ccopy_packer_chunk_arr_impl< Timpl >
 Ccopy_packer_chunk_arr_impl< Timpl[N1]>
 Ccopy_prop_to_vector< Tsrc, Tdst >
 Ccopy_prop_to_vector_block< Tsrc, Tdst >
 Ccopy_prop_to_vector_block_impl< copy_type >
 Ccopy_prop_to_vector_block_impl< copy_type[N1]>
 Ccopy_sparse_to_sparse< dim, Tsrc, Tdst >
 Ccopy_sparse_to_sparse_bb< dim, Tsrc, Tdst, aggrType >
 Ccopy_sparse_to_sparse_bb_impl< T >
 Ccopy_sparse_to_sparse_bb_impl< T[N1]>
 Ccopy_sparse_to_sparse_bb_impl< T[N1][N2]>
 Ccopy_sparse_to_sparse_op< op, dim, Tsrc, Tdst, prp >
 Ccopy_switch_memory_c_no_cpy< T_type_src, T_type_dst >This class is a functor for "for_each" algorithm
 Ccopy_sz< dim, mpl_v >This class is a functor for "for_each" algorithm
 Copenfpm::copy_two_vectors_activate_impl< active >
 Copenfpm::copy_two_vectors_activate_impl< true >
 Ccopy_unpacker_chunk< e_src, e_dst >It copy one element of the chunk for each property
 Ccopy_x_3< layout_type, prop, stencil_size, chunking, is_cross >Copy x edge in 3D
 Ccopy_x_3< layout_type, prop, 1, chunking, is_cross >Copy x edge in 3D
 Ccopy_x_3< layout_type, prop, stencil_size, chunking, true >Copy x edge in 3D
 Ccopy_xy_3< layout_type, prop, stencil_size, chunking, is_cross >Copy XY surface in 3D
 Ccopy_xy_3< 1, prop, stencil_size, chunking, is_cross >Copy XY surface in 3D
 Ccopy_xyz< layout_type, prop, stencil_size, chunking, is_cross >Copy block in 3D
 Ccopy_xyz< 1, prop, stencil_size, chunking, is_cross >Copy block in 3D vectorized
 Ccopy_xz_3< layout_type, prop, stencil_size, chunking, is_cross >Copy XZ surface in 3D
 Ccopy_xz_3< layout_type, prop, 1, chunking, is_cross >Copy XZ surface in 3D
 Ccopy_y_3< layout_type, prop, stencil_size, chunking, is_cross >Copy y edge in 3D
 Ccopy_y_3< layout_type, prop, 1, chunking, is_cross >Copy y edge in 3D
 Ccopy_y_3< layout_type, prop, stencil_size, chunking, true >Copy y edge in 3D
 Ccopy_yz_3< layout_type, prop, stencil_size, chunking, is_cross >Copy YZ surface in 3D
 Ccopy_yz_3< layout_type, prop, 1, chunking, is_cross >Copy YZ surface in 3D
 Ccopy_z_3< layout_type, prop, stencil_size, chunking, is_cross >Copy z edge in 3D
 Ccopy_z_3< layout_type, prop, 1, chunking, is_cross >Copy z edge in 3D
 Ccopy_z_3< layout_type, prop, stencil_size, chunking, true >Copy z edge in 3D
 Ccub::CountingInputIterator< ValueType, OffsetT >A random-access input generator for dereferencing a sequence of incrementing integer values
 ►Ccp_block_base< T, stencil_size, vector_vmpl, dim >
 ►Ccp_block_base< T, stencil_size, vector_vmpl, 2 >
 ►Ccp_block_base< T, stencil_size, vector_vmpl, 3 >
 Copenfpm::cpu_block_process< reduction_type, impl >
 Copenfpm::cpu_block_process< reduction_type, 3 >
 Copenfpm::cpu_block_process< reduction_type, VECTOR_SPARSE_BLOCK >
 Ccross_stencil< dim, T >
 Ccross_stencil_v< prop_type >
 Ccsv_col< Tobj, attr >This class is a functor for "for_each" algorithm
 Ccsv_col< Tobj, false >This class is a functor for "for_each" algorithm
 Ccsv_col_str< T >This class is an helper to produce csv headers from multi-array
 Ccsv_col_str< T[N1]>Partial specialization for N=1 1D-Array
 Ccsv_col_str< T[N1][N2]>Partial specialization for N=2 2D-Array
 Ccsv_col_str< T[N1][N2][N3]>Partial specialization for N=3
 Ccsv_col_str< T[N1][N2][N3][N4]>Partial specialization for N=4
 Ccsv_prp< Tobj >This class is a functor for "for_each" algorithm
 Ccsv_value_str< T, is_writable >This class is an helper to produce csv data from multi-array
 Ccsv_value_str< T, false >Partial specialization for unknown property
 Ccsv_value_str< T[N1], is_writable >Partial specialization for N=1 1D-Array
 Ccsv_value_str< T[N1][N2], is_writable >Partial specialization for N=2 2D-Array
 Ccsv_value_str< T[N1][N2][N3], is_writable >Partial specialization for N=3
 Ccsv_value_str< T[N1][N2][N3][N4], is_writable >Partial specialization for N=4
 CCSVWriter< v_pos, v_prp, impl >CSV Writer
 Cct_par< nNN_, nLoop_ >
 Ccub::CubVector< T, vec_elements >Exposes a member typedef Type that names the corresponding CUDA vector type if one exists. Otherwise Type refers to the CubVector structure itself, which will wrap the corresponding x, y, etc. vector fields
 Ccub::CubVector< OffsetT, 2 >
 Ccub::CubVector< T, 1 >
 Ccub::CubVector< T, 2 >
 Ccub::CubVector< T, 3 >
 Ccub::CubVector< T, 4 >
 Ccval< T >It store the non zero elements of the matrix
 CD< d, Field, Sys_eqs, impl >Derivative second order on h (spacing)
 CD< d, arg, Sys_eqs, BACKWARD >First order BACKWARD derivative on direction i
 CD< d, arg, Sys_eqs, CENTRAL >Second order central Derivative scheme on direction i
 CD< d, arg, Sys_eqs, CENTRAL_B_ONE_SIDE >Second order one sided Derivative scheme on direction i
 CD< d, arg, Sys_eqs, FORWARD >First order FORWARD derivative on direction i
 Cdata_il< l >
 Cdata_il< 1 >
 Cdata_il< 2 >
 Cdata_il< 4 >
 Cdata_il< 8 >
 Cdata_ptr_fill< AggregateT, n_it, prp >
 CDataBlock< ScalarT, DataBlockSize >
 CdataDiv< T >Class that store Internal part external and border part of a dataset
 CDcpseDiagonalScalingMatrix< dim, monomialBasis_type >
 CDcpseRhs< dim >
 CDEBUG< T >
 CDebug< typename >
 Copenfpm::Debug< typename >
 CDEBUG< float & >
 Cdec_optimizer< dim, Graph >This class take a graph representing the space decomposition and produce a simplified version
 CDecomposition< T, S >This class define the domain decomposition interface
 CDecomposition_encap< Decomposition, garray >
 Cdeconstruct_impl< T_type, layout_base, Memory >This class is a functor for "for_each" algorithm
 Cdecrement_memory< vector_type >
 Cdefault_chunking< dim >
 Cdefault_chunking< 1 >
 Cdefault_chunking< 2 >
 Cdefault_chunking< 3 >
 Cdefault_chunking< 4 >
 Cdefault_chunking< 5 >
 Cdefault_chunking< 6 >
 Cdefault_chunking< 7 >
 Cdefault_chunking< 8 >
 Cdefault_edge< dim >
 Cdefault_edge< 1 >
 Cdefault_edge< 2 >
 Cdefault_edge< 3 >
 Cboost::numeric::odeint::ofp_operations::default_rel_error< Fac1 >
 CFD::Derivative< dir, ord_d, ord, impl >
 CFD::Derivative_impl< dir, ord_d, ord, impl >
 CFD::Derivative_impl< dir, 1, 2, CENTRAL >
 CFD::Derivative_impl< dir, 1, 2, CENTRAL_ONE_SIDE_BACKWARD >
 CFD::Derivative_impl< dir, 1, 2, CENTRAL_ONE_SIDE_FORWARD >
 CFD::Derivative_impl< dir, 1, 2, CENTRAL_STAG >
 CFD::Derivative_impl< dir, 1, 2, CENTRAL_STAG_ONE_SIDE_BACKWARD >
 CFD::Derivative_impl< dir, 1, 2, CENTRAL_STAG_ONE_SIDE_FORWARD >
 CFD::Derivative_impl< dir, 2, 2, CENTRAL >
 CFD::Derivative_impl< dir, 2, 2, CENTRAL_ONE_SIDE_BACKWARD >
 CFD::Derivative_impl< dir, 2, 2, CENTRAL_ONE_SIDE_FORWARD >
 Cdevice_grid< dim >
 Cdevice_grid_copy< is_sparse >
 Cdevice_grid_copy< true >
 Cdevice_to_host_impl< T_type, layout_base, prp >This class is a functor for "for_each" algorithm
 Cdevice_to_host_start_stop_impl< T_type, layout_base, prp >This class is a functor for "for_each" algorithm
 Ccub::DeviceHistogramDeviceHistogram provides device-wide parallel operations for constructing histogram(s) from a sequence of samples data residing within device-accessible memory
 Ccub::DevicePartitionDevicePartition provides device-wide, parallel operations for partitioning sequences of data items residing within device-accessible memory
 Ccub::DeviceRadixSortDeviceRadixSort provides device-wide, parallel operations for computing a radix sort across a sequence of data items residing within device-accessible memory
 ►Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >< Signed integer type for global offsets
 Ccub::DeviceReduceDeviceReduce provides device-wide, parallel operations for computing a reduction across a sequence of data items residing within device-accessible memory
 Ccub::DeviceReducePolicy< OuputT, OffsetT, ReductionOpT >< Binary reduction functor type having member T operator()(const T &a, const T &b)
 ►Ccub::DeviceReducePolicy< If<(Equals< std::iterator_traits< OutputIteratorT >::value_type, void >::VALUE), std::iterator_traits< InputIteratorT >::value_type, std::iterator_traits< OutputIteratorT >::value_type >::Type, OffsetT, ReductionOpT >
 ►Ccub::DeviceReducePolicy< std::iterator_traits< InputIteratorT >::value_type, OffsetT, ReductionOpT >
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >< Signed integer type for global offsets
 Ccub::DeviceRunLengthEncodeDeviceRunLengthEncode provides device-wide, parallel operations for demarcating "runs" of same-valued items within a sequence residing within device-accessible memory
 Ccub::DeviceScanDeviceScan provides device-wide, parallel operations for computing a prefix scan across a sequence of data items residing within device-accessible memory
 Ccub::DeviceSegmentedRadixSortDeviceSegmentedRadixSort provides device-wide, parallel operations for computing a batched radix sort across multiple, non-overlapping sequences of data items residing within device-accessible memory
 Ccub::DeviceSegmentedReduceDeviceSegmentedReduce provides device-wide, parallel operations for computing a reduction across multiple sequences of data items residing within device-accessible memory
 Ccub::DeviceSelectDeviceSelect provides device-wide, parallel operations for compacting selected items from sequences of data items residing within device-accessible memory
 Ccub::DeviceSpmvDeviceSpmv provides device-wide parallel operations for performing sparse-matrix * dense-vector multiplication (SpMV)
 Cdim3_
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >< Signed integer type for global offsets
 Ccub::DiscardOutputIterator< OffsetT >A discard iterator
 Ccub::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::DiscontinuityOp
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >< Signed integer type for global offsets
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >< Signed integer type for global offsets
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >< Whether or not we push rejected items to the back of the output
 Ccub::DispatchSpmv< ValueT, OffsetT >< Signed integer type for global offsets
 Cdist_prop_out_edge< Graph >This class is a functor for "for_each" algorithm
 Cdist_prop_out_vertex< Graph >This class is a functor for "for_each" algorithm
 Cdist_prop_output< has_attributes, Graph, i >This class specialize functions in the case the type T has or not defined attributes
 Cdist_prop_output< false, Graph, i >This class specialize functions in the case the type T has not defined attributes
 Cdist_prop_output_array_scalar_selector_edge< is_array >Property writer for scalar and vector
 Cdist_prop_output_array_scalar_selector_edge< true >Property writer for vector
 Cdist_prop_output_array_scalar_selector_edge_fill_vertex< is_array >Property writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk)
 Cdist_prop_output_array_scalar_selector_edge_fill_vertex< true >Property writer for vector
 Cdist_prop_output_array_scalar_selector_vertex< is_array >Property writer for scalar and vector
 Cdist_prop_output_array_scalar_selector_vertex< true >Property writer for vector
 CDistFromSol< phi_type >Bundles total residual and total change over all the grid points
 CDistFromSol< double >
 CDistGraph_constr_impl< dim, Graph, se, T, dim_c, pos >Graph constructor function specialization
 CDistGraph_constr_impl< dim, Graph, NO_EDGE, T, dim_c, pos... >Graph constructor function specialization
 CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >Structure that store a graph in CSR format or basically in compressed adjacency matrix format
 CDistGraph_CSR< nm_v< dim >, nm_e >
 ►CDistGraph_CSR< V, E >
 CDistGraphFactory< dim, Graph >This class construct a cartesian graph
 CDistParmetis< Graph >Helper class to define Metis graph
 CDistParmetis< DistGraph_CSR< nm_v< dim >, nm_e > >
 CDistParMetisDistribution< dim, T >
 CDLB
 Cdo_not_print_warning_on_adjustment< dim, linearizer >
 Cdo_when_dim_gr_i< dim, i, ORB, Enable >This structure use SFINAE to avoid instantiation of invalid code
 Cdo_when_dim_gr_i< dim, i, ORB, typename boost::enable_if< boost::mpl::bool_<(i< dim)> >::type >
 ►Cdomain_icell_calculator< dim, T, layout_base, Memory >
 Cdomain_icell_calculator< dim, St, layout_base, Memory >
 Cdomain_icell_calculator< dim, T, memory_traits_lin, HeapMemory >
 Cdomain_icell_calculator< dim, typename grid_in_type::stype, layout_base, Memory >
 ►Cdomain_nn_calculator_cart< dim >This class calculate processor domains and neighborhood of each processor domain
 Ccub::DoubleBuffer< T >Double-buffer storage wrapper for multi-pass stream transformations that require more than one storage array for streaming intermediate results back and forth
 Ccub::DoubleBuffer< KeyT >
 Ccub::DoubleBuffer< ValueT >
 CVTKWriter< pair, VECTOR_POINTS >::doubleint
 CDrawParticlesA class to draw/create particles based on simple shaped
 Ce_box_id< dim >It store the information about the external ghost box
 Ce_box_multi< dim >For each external ghost id, it contain a set of sub-domain at which this external box is linked
 Ce_info
 Ce_lbox_grid< dim >Per-processor external ghost box
 Ce_lbox_id< dim >It store the information about the local external ghost box
 Ce_mapStructure used inside GraphCSR an edge
 CE_p< T >Edge class that encapsulate an object T
 Ced
 Cedge_iterator< Graph >Graph edge iterator
 Cedge_key
 Cedge_node< G >This class is a functor for "for_each" algorithm
 Cedge_prop< G >This class is a functor for "for_each" algorithm
 CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::EdgeReqStructure to store a add request of an edge
 Cele
 Cele_g< Grid, St >It store one grid
 Cele_g_st< Grid, St >Convert a staggered element into a string for vtk write
 Cele_vpp< Vpp >Store a reference to the vector properties
 Cele_vps< Vps >Store a reference to the vector position
 CEllipseParameters
 Ccub::EnableIf< Condition, T >Simple enable-if (similar to Boost)
 Ccub::EnableIf< false, T >
 Cenc_num< encap >
 Cencap_data_block< enc_type >
 Cencap_shmem< sz >Memcpy it split the copy across threads
 Cencapc< dim, T, layout >
 Cencapc< 1, obj_type, Memory >
 Cencapc< dim, T, typename memory_traits_inte< T >::type >This structure encapsulate an object of the grid
 Cencapc< dim, T, typename memory_traits_lin< T >::type >This structure encapsulate an object of the grid
 Cencapc< dim, void, Mem >This structure specialize the class for a void object or null
 Cencapsulated_type< T >
 Cep_box_grid< dim >Per-processor external ghost box
 CEq< expr1, expr2, Sys_eqs >Equation
 Ceq_id
 ►Cboost::mpl::equal_to
 ►Cstd::equal_to
 Ccub::EqualityDefault equality functor
 Ccub::Equals< A, B >Type equality test
 Ccub::Equals< A, A >
 Cequations2d1Specify the general characteristic of system to solve
 Cequations2d1_stagSpecify the general characteristic of system to solve
 Cequations2d1ESpecify the general characteristic of system to solve
 Cequations2d1p
 Cequations2d1pE
 Cequations2d2
 Cequations2d2E
 Cequations2d2p
 Cequations2d2pE
 Cequations2d3
 Cequations2d3E
 Cequations2d3p
 Cequations2d3pE
 Cequations2d4
 Cequations2d4E
 Cequations3d1
 Cequations3d1E
 Cequations3d1EPxy
 Cequations3d1Pxy
 Cequations3d1Pz
 Cequations3d3
 Cequations3d3E
 Cequations3d3EPxz
 Cequations3d3EPz
 Cequations3d3Pxz
 Cequations3d3Pyz
 Cequations3d3Pz
 CErrorOut-of-bound policy kill the program
 Ceta[Definition of the system]
 ►Cstd::exception
 Cexecute_cl_test< impl >
 Cexecute_cl_test< 1 >
 Cexecute_cl_test< 2 >
 Cexist_sub_v_impl< v >
 Cexist_sub_v_impl< 2 >
 Cexist_sub_v_impl< 4 >
 Cexist_sub_v_impl< 8 >
 Cexp_kernelExponential kernel
 Cextends< T >Classes to get the number of components of the properties
 Cextends< T[N1]>Partial specialization for N=1 1D-Array
 Cextends< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cextends< T[N1][N2][N3]>Partial specialization for N=3
 Cextends< T[N1][N2][N3][N4]>Partial specialization for N=4
 Cextends< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Cextends< T[N1][N2][N3][N4][N5][N6]>Partial specialization for N=6
 Cextends< T[N1][N2][N3][N4][N5][N6][N7]>Partial specialization for N=7
 Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8]>Partial specialization for N=8
 Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>Partial specialization for N=9
 Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>Partial specialization for N=10
 CF< T >[v_transform metafunction]
 ►Cstd::false_type
 CFD_scheme< Sys_eqs, grid_type >Finite Differences
 CFDScheme< Sys_eqs >Finite Differences
 CField< f, Sys_eqs >
 Cfill_id< dim, G_v, prp >Operator to fill the property 'prp' with the linearization of indexes
 Cfill_id< dim, G_v, NO_VERTEX_ID >Operator to fill the property in case there are no properties
 CFill_one< index, N >{1,1,1,1,....}
 Cfill_prop< dim, lin_id, dT, G_v, v, impl >This class work as a functor
 Cfill_prop< dim, lin_id, dT, G_v, v, 0 >This class work as a functor
 Cfill_prop< dim, lin_id, dT, G_v, v, 2 >This class work as a functor
 Cfill_prop_by_type< dim, i, p, Graph, pos >Operator for vector and scalar property
 Cfill_prop_by_type< dim, 0, p, Graph, pos... >Operator for vector and scalar property in the case there are no properties
 Cfill_prop_v< dim, dT, G_v, v, impl >This class work as a functor
 Cfill_prop_v< dim, dT, G_v, v, 0 >This class work as a functor
 Cfill_prop_v< dim, dT, G_v, v, 2 >This class work as a functor
 Cfill_prop_v_by_type< i, p, Graph, pos >Operator for vector and scalar property
 Cfill_prop_v_by_type< 0, p, Graph, pos... >Operator for vector and scalar property in the case there are no properties
 CFill_three< index, N >Compile time array functor needed to generate array at compile-time of type
 CFill_two< index, N >{2,2,2,2,....}
 CFill_zero< index, N >{0,0,0,0,....}
 CFD::first_or_second< cond, exp1, exp2 >
 Cfirst_or_second< cond, exp1, exp2 >
 CFD::first_or_second< true, exp1, exp2 >
 Cfirst_or_second< true, exp1, exp2 >
 Cfirst_or_second_pt< cond, exp1, exp2 >
 Cfirst_or_second_pt< true, exp1, exp2 >
 Cfirst_variadic< T1, T >
 CFitz< DX, DY >
 Cboost::numeric::odeint::vector_space_algebra_ofp::for_each_norm< vector_type, index_type, norm_result_type >
 Cboost::numeric::odeint::vector_space_algebra_ofp_gpu::for_each_norm< vector_type, index_type, norm_result_type >
 Cboost::numeric::odeint::for_each_prop1< vector_type, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop10< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop11< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop12< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop13< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop14< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop15< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop2< S1, S2, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop3< S1, S2, S3, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop4< S1, S2, S3, S4, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop5< S1, S2, S3, S4, S5, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop6< S1, S2, S3, S4, S5, S6, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop7< S1, S2, S3, S4, S5, S6, S7, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop8< S1, S2, S3, S4, S5, S6, S7, S8, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop9< S1, S2, S3, S4, S5, S6, S7, S8, S9, index_type, op_type >
 Cboost::numeric::odeint::for_each_prop_resize< S1, S2 >
 Cboost::mpl::aux::for_each_ref_cpu_impl< done >
 Cboost::mpl::aux::for_each_ref_cpu_impl< false >
 Cboost::mpl::aux::for_each_ref_host_impl< done >
 Cboost::mpl::aux::for_each_ref_host_impl< false >
 Cboost::mpl::aux::for_each_ref_impl< done >
 Cboost::mpl::aux::for_each_ref_impl< false >
 Copenfpm::fortran_storage_order
 Ccub::FpLimits< _T >
 Ccub::FpLimits< double >
 Ccub::FpLimits< float >
 Cfrswap< s_m >This class is a functor for "for_each" algorithm
 Cfrswap_nomode< s_m, Mem_type >This class is a functor for "for_each" algorithm
 CFt_chunk< n_ele, T >Transform T=aggregate<float,double,int> into aggregate<std::array<float,n_ele>,std::array<double,n_ele>,std::array<int,n_ele>>
 CFt_chunk< n_ele, const T(&)[N1]>Special case for vector
 CFtwo< arg0, T >[v_transform metafunction]
 Cfunction< arg_f1, arg_f2, s >
 CFD_scheme< Sys_eqs, grid_type >::function_bEncapsulation of the b term as a function
 CFD::g_comp
 CGaussianDLB
 CGBoxes< dim >This structure store the Box that define the domain inside the Ghost + domain box
 Cgcl< dim, St, CellL, Vector, impl, prp >General function t get a cell-list
 Cgcl< dim, St, CellL, Vector, GCL_HILBERT >General function t get a cell-list
 Cgcl< dim, St, CellL, Vector, GCL_SYMMETRIC >General function t get a cell-list
 Cgcl_An< dim, St, CellL, Vector, impl >General function t get a cell-list
 Cgcl_standard_no_symmetric_impl< is_gpu_celllist, prp >
 Cgcl_standard_no_symmetric_impl< true, prp... >
 CGCoptionsGoogle chart options
 CFD::gdb_ext_plus_g_info< dim >
 Copenfpm::general_storage_order< NumDims >
 CgeneralDimensionFunctor< T1 >
 CgeneralDimensionFunctor< T1[N1]>
 Cgenerate_array< T, N, F >Main class to generate compile-time array
 Cgenerate_array_constexpr< T, N, F >Main class to generate constexpr compile-time array
 Cgenerate_array_constexpr_impl< T, N, orig_N, F, args >Recursive meta-function to generate compile-time array
 Cgenerate_array_constexpr_impl< T, 0, orig_N, F, args... >Terminator of the variadic template
 Cgenerate_array_impl< T, N, orig_N, F, args >Generate the array specializing ArrayHolder
 Cgenerate_array_impl< T, 0, orig_N, F, args... >Terminator of the variadic template
 Cgenerate_array_vector< T, F >Main class to generate an array from a boost::mpl::vector of numbers
 Cgenerate_array_vector_impl< T, N, F, args >Generate the array specializing ArrayHolder
 Cgenerate_array_vector_impl< T, 0, F, args... >Terminator of the variadic template
 Cgenerate_indexes< T, N, F >Main class to generate indexes data structure
 Cgenerate_indexes_impl< T, N, orig_N, F, args >Generate compile time index array
 Cgenerate_indexes_impl< T, 0, orig_N, F, args... >Terminator of the variadic template
 Cgenerate_indexes_impl< T,-1, orig_N, F, args... >In case of an empty list
 Cger< dim, T >
 Cget_base_type_for_object_creator_chunking< type >
 Cget_base_type_for_object_creator_chunking< std::array< T, N2 >[N1] >
 Cget_block_sizes< dim, stencil_size, vector_blocks_ext, vector_ext >This class is a functor for "for_each" algorithm
 CFD::get_grid_dist_expression_op< int, is_valid >
 CFD::get_grid_dist_expression_op< 1, false >
 CFD::get_grid_dist_expression_op< 1, true >
 CFD::get_grid_dist_expression_op< 2, false >
 CFD::get_grid_dist_expression_op< 2, true >
 CFD::get_grid_dist_expression_op< 3, true >
 Cget_pointer< dim_prp, prp, grid_type >
 Cget_pointer< 1, prp, grid_type >
 Cget_pointer< 2, prp, grid_type >
 Cget_pointer_unpack< T, is_array >
 Cget_pointer_unpack< T, true >
 Cget_selector< T >
 Cget_selector< T[N1]>
 Cget_striding< dim, dim_prp, prp, grid_type >
 CGoogleChart::get_value_type< arg_0, args >
 Cget_vcl< Memory >
 Cget_vcl< CudaMemory >
 Cget_vector_dist_expression_op< int, is_valid >
 Cget_vector_dist_expression_op< 1, false >
 Cget_vector_dist_expression_op< 1, true >
 Cget_vector_dist_expression_op< 2, true >
 CGetAddBlockType< SGridGpu >Get the type of the insertBlock
 CgetAttrName< ele_g, has_attributes >Return the Attributes name from the type
 CgetAttrName< ele_g, false >Return the Attributes name from the type
 CGetCpBlockType< SGridGpu, prp, stencil_size >Get the type of the block
 CGetSetBlockType< SGridGpu >Get the type of the SetBlock
 CGGraphGoogle Graph
 Cghost_exchange_comm_impl< impl, layout_base, prp >Template selector for asynchronous or not asynchronous
 Cghost_exchange_comm_impl< GHOST_ASYNC, layout_base, prp ... >
 Cgid
 CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::GlobalVInfoStructure needed to get vertex position by global id
 CGoogleChartSmall class to produce graph with Google chart in HTML
 Cgrid_dist_id_iterator_dec_skin< Decomposition >::gp_subInternal struct
 CGraph_constructor_impl< dim, lin_id, Graph, se, T, dim_c, pos >Graph constructor function specialization
 CGraph_constructor_impl< dim, lin_id, Graph, NO_EDGE, T, dim_c, pos... >Graph constructor function specialization
 ►CGraph_CSR< V, E, Memory, layout_v_base, layout_e_base, grow_p >Structure that store a graph in CSR format or basically in compressed adjacency matrix format
 CGraph_CSR< nm_v< dim >, nm_e >
 CGraph_CSR< ORB_node< T >, no_edge >
 ►CGraph_CSR< V, E >
 CGraphMLWriter< Graph >
 Cgrid< T >
 CFDScheme< Sys_eqs >::grid_b< grid, prp >Encapsulation of the b term as grid
 Cgrid_base< dim, T, S, layout, linearizer >
 Cgrid_base< 1, T, Memory, typename layout_base< T >::type >
 Cgrid_base< dim, aggregate< size_t > >
 Cgrid_base< dim, Tg >
 Cgrid_base_impl< dim, T, S, layout_base, ord_type >Implementation of a N-dimensional grid
 ►Cgrid_base_impl< dim, T, S, memory_traits_inte, linearizer >
 ►Cgrid_base_impl< dim, T, S, memory_traits_lin, linearizer >
 Cgrid_call_serialize_variadic< device_grid, Memory, T >Unpack selector
 Cgrid_call_serialize_variadic< device_grid, Memory, index_tuple< prp... > >Unpack selector
 CFD::GRID_DERIVATIVE< dir_, ord_d_, ord_, impl_ >
 Cgrid_dist_amr< dim, St, T, impl, Decomposition, Memory, device_grid >
 Cgrid_dist_amr< dim, St, T, AMR_IMPL_TRIVIAL, Decomposition, Memory, device_grid >AMR Adaptive Multi Resolution Grid
 Cgrid_dist_amr_key< dim >Amr grid distributed key
 Cgrid_dist_amr_key_iterator< dim, device_grid, device_sub_it, it_type >
 CFD::grid_dist_expression< prp, grid, impl >
 CFD::grid_dist_expression< 0, grid_patches< grid_cpu< dim, aggregate< double > > >, NORM_EXPRESSION >Main class that encapsulate a grid properties operand to be used for expressions construction
 CFD::grid_dist_expression< dim, double, NORM_EXPRESSION >Main class that encapsulate a double constant
 CFD::grid_dist_expression< dim, double, STAG_EXPRESSION >Main class that encapsulate a double constant
 CFD::grid_dist_expression< dim, float, impl >Main class that encapsulate a float constant
 CFD::grid_dist_expression< prp, grid, NORM_EXPRESSION >Main class that encapsulate a grid properties operand to be used for expressions construction
 CFD::grid_dist_expression< prp, grid, STAG_EXPRESSION >
 CFD::grid_dist_expression_iterator_to_make_algebra_work< dim >
 CFD::grid_dist_expression_op< exp1, exp2, impl >
 CFD::grid_dist_expression_op< exp1, boost::mpl::int_< n >, g_comp >It take an expression and create the negatove of this expression
 CFD::grid_dist_expression_op< exp1, exp2, mul >
 CFD::grid_dist_expression_op< exp1, exp2, sub >
 CFD::grid_dist_expression_op< exp1, exp2, sum >
 CFD::grid_dist_expression_op< exp1, void, GRID_DERIVATIVE< dir, ord_d, ord, impl > >
 CFD::grid_dist_expression_op< exp1, void, subuni >
 CFD::grid_dist_expression_value_impl< base_type >
 CFD::grid_dist_expression_value_impl< base_type[N1]>
 CFD::grid_dist_expression_value_impl< base_type[N1][N2]>
 CFD::grid_dist_expression_value_impl< base_type[N1][N2][N3]>
 CFD::grid_dist_expression_value_impl< Point< N1, base_type > >
 CFD::grid_dist_expression_value_impl_func_scal< i >
 CFD::grid_dist_expression_value_impl_func_scal< 0 >
 CFD::grid_dist_expression_value_impl_func_vec< i >
 CFD::grid_dist_expression_value_impl_func_vec< 0 >
 CFD::grid_dist_expression_value_impl_vnz< i >
 CFD::grid_dist_expression_value_impl_vnz< 0 >
 Cgrid_dist_g_dx< device_grid >Distributed linearized key
 ►Cgrid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid >This class is an helper for the communication of grid_dist_id
 Cgrid_dist_id_comm< dim, St, T, CartDecomposition< dim, St >, HeapMemory, grid_cpu< dim, T > >
 Cgrid_dist_id_comm< dim, typename grid_in_type::stype, props_temp, CartDecomposition< dim, typename grid_in_type::stype >, HeapMemory, grid_cpu< dim, props_temp > >
 Cgrid_dist_id_comm< dim, typename last::stype, aggregate< size_t >, typename last::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > >
 Cgrid_dist_id_comm< dim, typename Sys_eqs::stype, aggregate< size_t >, typename grid_type::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > >
 Cgrid_dist_id_comm< dim, typename Sys_eqs::stype, aggregate< size_t >, typename Sys_eqs::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > >
 ►Cgrid_dist_id_iterator_dec< Decomposition, ghost_or_domain >Given the decomposition it create an iterator
 Cgrid_dist_id_iterator_gpu< Decomposition, deviceGrids, ghost_or_domain >Given the decomposition it create an iterator
 Cgrid_dist_iterator< dim, device_grid, device_sub_it, impl, stencil >Distributed grid iterator
 Cgrid_dist_iterator< dim, device_grid, device_sub_it, FREE >
 Cgrid_dist_iterator_sub< dim, device_grid >Distributed grid iterator
 Cgrid_dist_key_dx< dim, base_key >Grid key for a distributed grid
 Cgrid_dist_key_dx< dim >
 Cgrid_dist_key_dx< Eqs_sys::dims >
 Cgrid_dist_key_dx< Grid_dst::dims >
 Cgrid_dist_key_dx< last::dims >
 Cgrid_dist_lin_dxDistributed linearized key
 Cgrid_dist_testing< dim >
 Cgrid_gpu_ker< dim, T, layout_base, linearizer >Grid interface available when on gpu
 Cgrid_gpu_ker< 1, T_, layout_base, grid_sm< 1, void > >
 Cgrid_gpu_ker< 1, T_, memory_traits_inte, grid_sm< 1, void > >
 Cgrid_gpu_ker< 1, T_, memory_traits_lin, grid_sm< 1, void > >
 Cgrid_gpu_ker_constructor_impl< inte_or_lin, T >
 Cgrid_gpu_ker_constructor_impl< false, T >
 Cgrid_gpu_ker_ref< dim, T, layout_base, linearizer >
 Cgrid_key< p >
 Cgrid_key_1< p >
 Cgrid_key_2< p >
 Cgrid_key_3< p >
 Cgrid_key_4< p >
 Cgrid_key_c3< p >
 Cgrid_key_d< dim, p >Grid_key_d is the key to access any element in the grid
 Cgrid_key_dx< dim, index_type >Grid_key_dx is the key to access any element in the grid
 Cgrid_key_dx< Decomposition::dims >
 Cgrid_key_dx< dim >
 Cgrid_key_dx< dim, ids_type >
 Cgrid_key_dx< dim, int >
 Cgrid_key_dx< dim, long int >
 Cgrid_key_dx< Sys_eqs::dims >
 Cgrid_key_dx_expression< dim, exp >Expression template for grid_key_dx
 ►Cgrid_key_dx_expression< dim, grid_key_dx_sub< dim, exp1, exp2 > >
 ►Cgrid_key_dx_expression< dim, grid_key_dx_sum< dim, exp1, exp2 > >
 ►Cgrid_key_dx_iterator< dim, stencil, linearizer >
 Cgrid_key_dx_iterator< dim, no_stencil, grid_sm< dim, void > >
 ►Cgrid_key_dx_iterator< dim, stencil, linearizer >
 Cgrid_key_dx_iterator_hilbert< dim >
 Cgrid_key_dx_iterator_sub< 0, warn >
 Cgrid_key_dx_rEmulate grid_key_dx with runtime dimensionality
 Cgrid_key_sparse_dx_iterator< dim, n_ele >Grid key sparse iterator
 Cgrid_key_sparse_dx_iterator_sub< dim, n_ele >Grid key sparse iterator on a sub-part of the domain
 Cgrid_key_sparse_lin_dxIt store the position in space of the sparse grid
 CFD::grid_patches< patches >
 CFD::grid_patches< grid_base< dim, aggregate< double > > >
 Cgrid_skin_iterator_bc< dim >
 ►Cgrid_skin_iterator_bc< Decomposition::dims >
 ►Cgrid_sm< N, T >Declaration grid_sm
 Cgrid_sm< 1, void >
 Cgrid_sm< dim, aggregate< size_t > >
 Cgrid_sm< dim, int >
 Cgrid_sm< dim, props_temp >
 Cgrid_sm< dim, T >
 Cgrid_sm< dim, void >
 Cgrid_sm< last::dims, void >
 Cgrid_sm< Sys_eqs::dims, void >
 Cgrid_smb< dim, blockEdgeSize, indexT >
 ►Cgrid_smb< dim, blockEdgeSize, indexT >
 Cgrid_smb< dim, default_edge< dim >::type::value, long int >
 Cgrid_toKernelImpl< inte_or_lin, base_grid, dim, T >
 Cgrid_toKernelImpl< true, base_grid, dim, T >
 Cgrid_unpack_selector_with_prp< result, T, device_grid, Memory >Unpack selector
 Cgrid_unpack_selector_with_prp< true, T, device_grid, Memory >Unpack selector
 Cgrid_unpack_with_prp< op, T, device_grid, Memory >Unpack selector
 ►Ccub::GridBarrierGridBarrier implements a software global barrier among thread blocks within a CUDA grid
 Ccub::GridEvenShare< OffsetT >GridEvenShare is a descriptor utility for distributing input among CUDA thread blocks in an "even-share" fashion. Each thread block gets roughly the same number of input tiles
 Ccub::GridQueue< OffsetT >GridQueue is a descriptor utility for dynamic queue management
 CGridRawReader< dim, T, idx_type >
 Copenfpm::grow_policy_doubleGrow policy define how the vector should grow every time we exceed the size
 Copenfpm::grow_policy_identityGrow policy define how the vector should grow every time we exceed the size
 Copenfpm::grow_policy_pageGrow policy define how the vector should grow every time we exceed the size
 ►CGrowthPolicy
 Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::GuardedInequalityWrapper< _EqualityOpT >
 CH5_prop_out< ele_v, has_name >This class is a functor for "for_each" algorithm
 CH5_prop_out< ele_v, false >This class is a functor for "for_each" algorithm
 CH5_write< T, pid, V >Write an HDF5 dataset in case of scalars and vectors
 CH5_write< T[N1], pid, V >Partial specialization for N=1 1D-Array
 CH5_write< T[N1][N2], pid, V >Partial specialization for N=2 2D-Array
 CH5_write< T[N1][N2][N3], pid, V >Partial specialization for N=3
 CH5_write< T[N1][N2][N3][N4], pid, V >Partial specialization for N=4
 Chas_max_prop< T, hvt >
 Chas_max_prop< T, false >
 Chas_pack_agg< T, prp >Return if true the aggregate type T has a property that has a complex packing(serialization) method
 Chas_pack_agg_impl< T, N, result_p, vprp >Generate the array specializing ArrayHolder
 Chas_pack_agg_impl< T, 0, result_p, vprp >Terminator of the variadic template
 Chas_pack_encap< T, prp >
 Chas_pack_gen< T, sel >It return true if the object T require complex serialization
 Chas_pack_gen< T, false >It return true if the object T require complex serialization
 Chas_val< int, T >Evaluate the constant field function
 Chas_val< HAS_VAL, T >Evaluate the constant field function
 ►CHash
 ►Cstd::hash
 Cstd::hash< gid >
 Cstd::hash< lid >
 Cstd::hash< rid >
 CHDF5_reader< type >
 CHDF5_reader< GRID_DIST >
 CHDF5_reader< VECTOR_DIST >
 CHDF5_writer< type >
 CHDF5_writer< GRID_DIST >
 CHDF5_writer< VECTOR_DIST >
 CHDF5_XdmfWriter< imp >
 CHDF5_XdmfWriter< H5_POINTSET >HDF5 writer for a point set
 CHeatStencil< dim, p_src, p_dst >
 CHeatStencilGet< dim, p_src, p_dst >
 ►Ctsl::detail_hopscotch_hash::hopscotch_bucket_hash< StoreHash >
 Ctsl::detail_hopscotch_hash::hopscotch_bucket_hash< true >
 Ctsl::detail_hopscotch_hash::hopscotch_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, OverflowContainer >::hopscotch_iterator< is_const >
 Ctsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >
 Ctsl::hopscotch_map< size_t, size_t >
 Ctsl::hopscotch_sc_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >
 Ctsl::hopscotch_sc_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >
 Ctsl::hopscotch_set< Key, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >
 Chost_to_dev_all_prp< Tv >This class is a functor for "for_each" algorithm
 Chost_to_device_impl< T_type, layout_base, Memory, prp >This class is a functor for "for_each" algorithm
 Copenfpm::htoD< sg_type >
 CHyperCube< dim >This class calculate elements of the hyper-cube
 ►CHyperCube< subdim >
 Ci_box_id< dim >It store a box, its unique id and the sub-domain from where it come from
 Ci_lbox_grid< dim >Local Internal ghost box
 Ci_lbox_id< dim >It store an internal ghost box, the linked external ghost box and the sub-domain from where it come from as internal ghost box
 Cibox_send< dim >Set of internal ghost box to send
 CID_operation< output_type >
 Cids_crs< dim, sz >
 Cids_pl
 ►Cie_ghost< dim, T, Memory, layout_base >Structure that store and compute the internal and external local ghost box
 Cie_ghost< dim, St, Memory, layout_base >
 Cie_ghost< dim, T, HeapMemory, memory_traits_lin >
 Cie_ghost< dim, typename grid_in_type::stype, Memory, layout_base >
 ►Cie_ghost_gpu< dim, T, Memory, layout_base >Structure that store and compute the internal and external local ghost box. Version usable in kernel
 ►Cie_loc_ghost< dim, T, layout_base, Memory >Structure that store and compute the internal and external local ghost box
 Cie_loc_ghost< dim, St, layout_base, Memory >
 Cie_loc_ghost< dim, T, memory_traits_lin, HeapMemory >
 Cie_loc_ghost< dim, typename grid_in_type::stype, layout_base, Memory >
 Ccub::If< IF, ThenType, ElseType >Type selection (IF ? ThenType : ElseType)
 Ccub::If< AgentSpmvPolicyT::DIRECT_LOAD_NONZEROS, NullType, ValueT >
 Ccub::If< false, ThenType, ElseType >
 Ccub::If< IsPointer< AggregatesOutputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSegmentFixupPolicyT::LOAD_MODIFIER, ValueT, OffsetT >, AggregatesOutputIteratorT >
 Ccub::If< IsPointer< FlagsInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSelectIfPolicyT::LOAD_MODIFIER, FlagT, OffsetT >, FlagsInputIteratorT >
 Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentReducePolicy::LOAD_MODIFIER, InputT, OffsetT >, InputIteratorT >
 Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentRlePolicyT::LOAD_MODIFIER, T, OffsetT >, InputIteratorT >
 Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentScanPolicyT::LOAD_MODIFIER, InputT, OffsetT >, InputIteratorT >
 Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSelectIfPolicyT::LOAD_MODIFIER, InputT, OffsetT >, InputIteratorT >
 Ccub::If< IsPointer< KeysInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentReduceByKeyPolicyT::LOAD_MODIFIER, KeyInputT, OffsetT >, KeysInputIteratorT >
 Ccub::If< IsPointer< PairsInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSegmentFixupPolicyT::LOAD_MODIFIER, KeyValuePairT, OffsetT >, PairsInputIteratorT >
 Ccub::If< IsPointer< SampleIteratorT >::VALUE, CacheModifiedInputIterator< LOAD_MODIFIER, SampleT, OffsetT >, SampleIteratorT >
 Ccub::If< IsPointer< ValuesInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentReduceByKeyPolicyT::LOAD_MODIFIER, ValueInputT, OffsetT >, ValuesInputIteratorT >
 Ccub::If< STORE_WARP_TIME_SLICING, typenameWarpExchangePairs::TempStorage, NullType >
 Ccub::If<(cudaSharedMemBankSizeFourByte==cudaSharedMemBankSizeEightByte), unsignedlonglong, unsignedint >
 Ccub::If<(Equals< typenamestd::iterator_traits< OutputIteratorT >::value_type, void >::VALUE), typenamestd::iterator_traits< InputIteratorT >::value_type, typenamestd::iterator_traits< OutputIteratorT >::value_type >
 Ccub::If<(sizeof(T)==8), longlong, typenameIf<(sizeof(T)==4), int, typenameIf<(sizeof(T)==2), short, char >::Type >::Type >
 Ccub::If<(STATUS_WORD_SIZE==8), longlong, typenameIf<(STATUS_WORD_SIZE==4), int, typenameIf<(STATUS_WORD_SIZE==2), short, char >::Type >::Type >
 CVcluster< InternalMemory >::index_gen< T >
 CVcluster< InternalMemory >::index_gen< index_tuple< prp... > >Process the receive buffer using the specified properties (meta-function)
 Cindex_tuple<... >These set of classes generate an array definition at compile-time
 Cindex_tuple_sq<... >
 Ccub::InequalityDefault inequality functor
 Ccub::InequalityWrapper< EqualityOp >Inequality functor (wraps equality functor)
 Ccub::InequalityWrapper< EqualityOpT >
 Cinit_prop< Np, vector >This class is a functor for "for_each" algorithm
 Cinsert_kernel2D< p >
 Cinsert_kernel3D< p >
 CInsertBlockWrapper< AggregateT, pMask >
 Ccub::Int2Type< A >Allows for the treatment of an integral constant as a type at compile-time (e.g., to achieve static call dispatch based on constant integral values)
 Cinte_calc_impl< vector, kernel >Calculate the interpolation for one point
 Cinte_template< np, prp_g, prp_v, m2p_or_p2m >Class that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m)
 Cinte_template< np, prp_g, prp_v, inte_m2p >Class that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m)
 Ccub::WarpScanShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::IntegerTraits< S >
 Cinter_memc< Seq >This class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c interleaved
 Cinter_memc_red< Seq >This class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c<.....,MEMORY_C_REDUCED> interleaved
 Cinterp_ele< Tdst, Grid_dst, Grid_src, nst_pos >This class is a functor for "for_each" algorithm
 Cinterp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, sa >Add scalar elements
 Cinterp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, 1 >Add 1D array elements
 Cinterp_points< dim, n_prop, v_prp_id, v_prp_type >This class is a functor for "for_each" algorithm
 Cinterpolate< vector, grid, kernel >Main class for interpolation Particle to mest p2m and Mesh to particle m2p
 CIntPow< base, exponent >
 CIntPow< base, 0 >
 Cip_box_grid< dim >Per-processor Internal ghost box
 Cis_complex_agg< T, prp >Return if true the aggregate type T has a property that has a complex packing(serialization) method
 Cis_complex_agg_impl< T, N, result_p, vprp >These set of classes generate an array definition at compile-time
 Cis_complex_agg_impl< T, 0, result_p, vprp >Terminator of the variadic template
 Cis_contiguos< prp >
 Cis_csv_writable< T >Indicate if the property T is writable in CSV
 Cis_csv_writable< bool >Indicate if the property T is writable in CSV
 Cis_csv_writable< char >Indicate if the property T is writable in CSV
 Cis_csv_writable< double >Indicate if the property T is writable in CSV
 Cis_csv_writable< float >Indicate if the property T is writable in CSV
 Cis_csv_writable< int >Indicate if the property T is writable in CSV
 Cis_csv_writable< long int >Indicate if the property T is writable in CSV
 Cis_csv_writable< short >Indicate if the property T is writable in CSV
 Cis_csv_writable< T[N1]>Indicate if the property T is writable in CSV
 Cis_csv_writable< T[N1][N2]>Indicate if the property T is writable in CSV
 Cis_csv_writable< T[N1][N2][N3]>Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned char >Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned int >Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned long int >Indicate if the property T is writable in CSV
 Cis_csv_writable< unsigned short >Indicate if the property T is writable in CSV
 Cis_grid_staggered< T, has_gt >Is_grid_staggered analyse T if it has a property grid_type defined and indicate that the grid is staggered
 Cis_grid_staggered< T, false >Is_grid_staggered analyse T if it has a property that define the type of grid
 Cis_initialized< T >Initialized
 Cis_initialized< openfpm::vector< T > >Initialized
 Cboost::numeric::odeint::is_resizeable< state_type_1d_ofp >
 Cboost::numeric::odeint::is_resizeable< state_type_2d_ofp >
 Cboost::numeric::odeint::is_resizeable< state_type_3d_ofp >
 Cboost::numeric::odeint::is_resizeable< state_type_4d_ofp >
 Cboost::numeric::odeint::is_resizeable< state_type_5d_ofp >
 Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 1, state_type > >
 Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 2, state_type > >
 Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 3, state_type > >
 Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 4, state_type > >
 Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 5, state_type > >
 Cboost::numeric::odeint::is_resizeable< vector_dist_expression< 0, openfpm::vector< aggregate< T > > > >
 Cis_typedef_and_data_same< cond, T >Check if T::type and T.data has the same type
 Cis_typedef_and_data_same< false, T >
 Cis_typedef_and_data_same< true, SpaceBox< dim, St > >
 Cis_typedef_and_data_same< true, wavefront< dim > >
 Cis_vtk_writable< T >Check for T to be writable
 Cis_vtk_writable< bool >Check bool
 Cis_vtk_writable< char >Check char
 Cis_vtk_writable< double >Check double
 Cis_vtk_writable< float >Check float
 Cis_vtk_writable< int >Check int
 Cis_vtk_writable< long int >Check long int
 Cis_vtk_writable< short >Check short
 Cis_vtk_writable< unsigned char >Check unsigned char
 Cis_vtk_writable< unsigned int >Check unsigned int
 Cis_vtk_writable< unsigned long int >Check unsigned long int
 Cis_vtk_writable< unsigned short >Check unsigned short
 Ccub::WarpReduceShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::IsInteger< S >
 Ccub::UnitWord< T >::IsMultiple< Unit >
 Ccub::IsPointer< Tp >Pointer vs. iterator
 Ccub::IsPointer< Tp * >
 Ccub::IsVolatile< Tp >Volatile modifier test
 Ccub::IsVolatile< Tp volatile >
 Cite_g
 Cite_gpu< dim >
 Ccub::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >::Iterate< COUNT, MAX >
 Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< ITERATION, MAX_ITERATIONS >Templated unrolling of item comparison (inductive case)
 Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< ITERATION, MAX_ITERATIONS >Templated unrolling of item comparison (inductive case)
 Ccub::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >::Iterate< MAX, MAX >
 Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< MAX_ITERATIONS, MAX_ITERATIONS >Templated unrolling of item comparison (termination case)
 Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< MAX_ITERATIONS, MAX_ITERATIONS >Templated unrolling of item comparison (termination case)
 Ccub::IterateThreadLoad< COUNT, MAX >Helper structure for templated load iteration (inductive case)
 Ccub::IterateThreadLoad< MAX, MAX >Helper structure for templated load iteration (termination case)
 Ccub::IterateThreadStore< COUNT, MAX >Helper structure for templated store iteration (inductive case)
 Ccub::IterateThreadStore< MAX, MAX >Helper structure for templated store iteration (termination case)
 ►Cboost::iterator_facade
 CIterator_g_const
 Cpetsc_solver< double >::itErrorContain the infinity norm of the residual at each iteration
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::KernelConfig
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::KernelConfig
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::KernelConfig
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::KernelConfig
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::KernelConfig
 Ccub::DispatchSpmv< ValueT, OffsetT >::KernelConfig
 Ccub::KernelConfig
 CFD_scheme< Sys_eqs, grid_type >::key_and_eqEquation id + space position
 CFDScheme< Sys_eqs >::key_and_eqEquation id + space position
 Ckey_int< dim >
 Ckey_shift< dim, chunk >
 Ckey_shift< 1, chunk >
 Ckey_shift< 2, chunk >
 Ckey_shift< 3, chunk >
 Ckey_shift< 4, chunk >
 Ckey_shift< 5, chunk >
 Ckey_shift< 6, chunk >
 Ckey_shift< 7, chunk >
 Ckey_shift< 8, chunk >
 ►CKeyEqual
 Ctsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect
 Ctsl::hopscotch_sc_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect
 Ctsl::hopscotch_sc_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect
 Ctsl::hopscotch_set< Key, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect
 Ccub::KeyValuePair< _Key, _Value >A key identifier paired with a corresponding value
 Ccub::KeyValuePair< OffsetT, LengthT >
 CKillParticleOut of bound policy it detect out of bound particles and decide what to do
 CKillParticleWithWarningOut-of-bound policy kill the particle but print a warning
 Ckl_selector_impl< kl_type, cl_type, impl >
 Ckl_selector_impl< kl_type, cl_type, 1 >
 Ckl_selector_impl< kl_type, cl_type, 2 >
 CFD::L2Error
 CL_norms
 ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, is_ok_cuda >
 ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, true >
 Clambda2_2kernel< st >
 Clambda4_4kernel< st >
 CLap< arg, Sys_eqs, impl >Laplacian second order on h (spacing)
 CLap< arg, Sys_eqs, CENTRAL >Laplacian second order approximation CENTRAL Scheme
 CLap< arg, Sys_eqs, CENTRAL_SYM >Laplacian second order approximation CENTRAL Scheme (with central derivative in the single)
 CLap_PSE< dim, T, ord, impl >Implementation of the Laplacian kernels for PSE
 CLap_PSE< 1, T, 2, KER_GAUSSIAN >
 CLap_PSE< 1, T, 4, KER_GAUSSIAN >
 CLap_PSE< 1, T, 6, KER_GAUSSIAN >
 CLap_PSE< 1, T, 8, KER_GAUSSIAN >
 CFD::Laplacian< dim, impl >
 CLaplacianStencil< dim, p >
 Clast_variadic< T1, T >
 Clast_variadic< T1 >
 CLastPOf< AggregateT >
 Claunch_call_impl< impl >
 Claunch_call_impl< 1 >
 Claunch_insert_sparse
 Claunch_insert_sparse_lambda_call< dim >
 Claunch_insert_sparse_lambda_call< 2 >
 Claunch_insert_sparse_lambda_call< 3 >
 Claunch_set_dense< dim >
 Claunch_set_dense< 2 >
 Claunch_set_dense< 3 >
 Copenfpm::vector< T, Memory, layout_base, grow_p, OPENFPM_NATIVE >::layout_base__< Tobj >
 Cvector< T, CudaMemory, memory_traits_inte, grow_policy_double, STD_VECTOR >::layout_base__< Tobj >
 Cvector< T, HeapMemory, memory_traits_lin, grow_p, STD_VECTOR >::layout_base__< Tobj >
 ClBox_dom< dim, T >Case for local ghost box
 CCartDecomposition< dim, T, Memory, layout_base, Distribution >::lc_processor_idClass to select the returned id by ghost_processorID
 Clid
 Clid_nn[Definition of the system]
 Clid_nn_3d_eigenSpecify the general caratteristic of system to solve
 Clid_nn_3d_petsc
 Climit_max_t< type_t >
 CFD::LInfError
 Cln_force
 Cln_potential
 CLNorms< lnorm_type >Class for computing the l2/l_infinity norm for distributed grids and vectors based on given errors
 Cload_mask_impl< N >
 Cload_mask_impl< 1 >
 Cload_mask_impl< 16 >
 Cload_mask_impl< 2 >
 Cload_mask_impl< 4 >
 Cload_mask_impl< 8 >
 CloadGhostBlock_impl< nLoop, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 1, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 2, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 3, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 CloadGhostBlock_impl< 7, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize >
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< _POLICY, DUMMY >Load helper
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_DIRECT, DUMMY >
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_TRANSPOSE, DUMMY >
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_VECTORIZE, DUMMY >
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_WARP_TRANSPOSE, DUMMY >
 Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED, DUMMY >
 Clocal_ghost_from_dec_impl< dim, St, prop, Memory, layout_base, is_ok_cuda >
 Clocal_ghost_from_dec_impl< dim, St, prop, Memory, layout_base, true >
 Clocal_ghost_from_opart_impl< with_pos, dim, St, prop, Memory, layout_base, is_ok_cuda >
 Clocal_ghost_from_opart_impl< with_pos, dim, St, prop, Memory, layout_base, true >
 Ccub::Log2< N, CURRENT_VAL, COUNT >Statically determine log2(N), rounded up
 Ccub::Log2< N, 0, COUNT >
 Ctsl::detail_hopscotch_hash::make_void< T >
 CMatLabWriter< dim, T >This class is able to save grid into tiff files
 CMatrix< dim, T >This class implement an NxN (dense) matrix
 Ccub::MaxDefault max functor
 Cmax_< Tdst, Tsrc >This structure define the operation add to use with copy general
 Cmax_prop_nn< T, has_max_prop >
 Cmax_prop_nn< T, false >
 Cboost::numeric::odeint::ofp_operations::maximum< Value >
 CMem_bal< local_index >Class for BALANCED cell list implementation
 ►CMem_fast< Memory, local_index >It is a class that work like a vector of vector
 ►CMem_fast< HeapMemory, int >
 CMem_fast< HeapMemory, local_index_ >
 ►CMem_fast< HeapMemory, typename Mem_type::local_index_type >
 ►CMem_fast< Memory, int >
 CMem_fast_ker< Memory, layout_base, local_index >
 ►CMem_fast_ker< Memory, memory_traits_lin, int >
 Cmem_geto< dim, T, layout, data_type, g1_type, key_type, sel >Case memory_traits_lin
 Cmem_geto< dim, T, layout, data_type, g1_type, key_type, 1 >Case memory_traits_inte
 Cmem_getpointer< data_type, layout, sel >
 Cmem_getpointer< data_type, layout, 1 >
 CMem_mw< local_index >Class for MEMORY-WISE cell list implementation
 Cmem_reference< T >Metafunction take T and return a reference
 Cmem_setarray< grid_type, Memory >This class is a functor for "for_each" algorithm
 Cmem_setext< grid_type, S, layout, data_type, sel >Case memory_traits_lin
 Cmem_setext< grid_type, S, layout, data_type, 1 >Case memory_traits_inte
 Cmem_setext_prp< grid_type, data_type, S >This class is a functor for "for_each" algorithm
 Cmem_setm< S, layout, data_type, g1_type, sel >Case memory_traits_lin
 Cmem_setm< S, layout, data_type, g1_type, 1 >Case memory_traits_inte
 Cmem_setmemory< data_type, Mem_type, layout, sel >
 Cmem_setmemory< data_type, Mem_type, layout, 1 >
 Cmem_swap< T, layout, data_type, grid_type, sel >Case memory_traits_lin
 Cmem_swap< T, layout, data_type, grid_type, 1 >Case memory_traits_inte
 ►CMem_type
 ►CMemory
 ►Cmemory
 Cmemory_array< T >This class give a representation to a chunk or memory
 Cmemory_c< T, impl, D >
 Cmemory_c< multi_array< T >, MEMORY_C_STANDARD, D >Specialization of memory_c for multi_array
 Cmemory_c< T, MEMORY_C_STANDARD, D >This class is a container for the memory interface like HeapMemory CudaMemory
 Cmemory_thrust_c< T >This class is a container for the memory interface
 Cmemory_traits_inte< T >Transform the boost::fusion::vector into memory specification (memory_traits)
 Cmemory_traits_inte< T_ >
 Cmemory_traits_inte< T_type >
 Cmemory_traits_lin< T >Transform the boost::fusion::vector into memory specification (memory_traits)
 Cmemory_traits_lin< T_ >
 Cmemory_traits_lin_type< T, is_agg >Transform the boost::fusion::vector into memory specification (memory_traits)
 Cmemory_traits_lin_type< T, false >Small meta-function to get the type of the memory
 Cmerge_< Tdst, Tsrc >This structure define the operation add to use with copy general
 Copenfpm::merge_prp_device_impl< is_ok_cuda, T, Memory, layout_base, grow_p >
 Copenfpm::merge_prp_device_impl< true, T, Memory, layout_base, grow_p >
 Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::MergeItemMerge item type (either a non-zero value or a row-end offset)
 Cmet_sub_wSub-domain list and weight
 Cmeta_compare< T >This class compare general objects
 Cmeta_compare< T[N1]>Partial specialization for N=1 1D-Array
 Cmeta_compare< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_compare< T[N1][N2][N3]>Partial specialization for N=3
 Cmeta_copy< T >This class copy general objects
 Cmeta_copy< T[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy< T[N1][N2][N3]>Partial specialization for N=3
 Cmeta_copy< T[N1][N2][N3][N4]>Partial specialization for N=4
 Cmeta_copy< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6]>Partial specialization for N=6
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7]>Partial specialization for N=7
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8]>Partial specialization for N=8
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>Partial specialization for N=9
 Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>Partial specialization for N=10
 Cmeta_copy_block< copy_type, nprp, prp_val, prp_id >
 Cmeta_copy_block< copy_type[N1], nprp, prp_val, prp_id >
 Cmeta_copy_block< copy_type[N1][N2], nprp, prp_val, prp_id >
 Cmeta_copy_d< Tsrc, Tdst >Copy for a source object to a destination
 Cmeta_copy_d< Tsrc, Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_d< Tsrc, Tdst[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy_d< Tsrc[N1], Tdst >Partial specialization for N=1 1D-Array
 Cmeta_copy_d< Tsrc[N1], Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_d< Tsrc[N1][N2], Tdst >Partial specialization for N=2 2D-Array
 Cmeta_copy_d< Tsrc[N1][N2], Tdst[N1][N2]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op< op, T >This class copy general objects applying an operation
 Cmeta_copy_op< op, openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > >Partial specialization for N=1 1D-Array
 Cmeta_copy_op< op, openfpm::detail::multi_array::sub_array_openfpm< T, 2, vmpl > >Partial specialization for N=2 2D-Array
 Cmeta_copy_op< op, T[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op< op, T[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy_op< op, T[N1][N2][N3]>Partial specialization for N=3
 Cmeta_copy_op_d< op, Tsrc, Tdst >
 Cmeta_copy_op_d< op, openfpm::detail::multi_array::sub_array_openfpm< Tsrc, 1, vmpl >, openfpm::detail::multi_array::sub_array_openfpm< Tdst, 1, vmpl > >Partial specialization for N=2 2D-Array
 Cmeta_copy_op_d< op, openfpm::detail::multi_array::sub_array_openfpm< Tsrc, 2, vmpl >, openfpm::detail::multi_array::sub_array_openfpm< Tdst, 2, vmpl > >Partial specialization for N=2 2D-Array
 Cmeta_copy_op_d< op, Tsrc, Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op_d< op, Tsrc[N1], Tdst >Partial specialization for N=1 1D-Array
 Cmeta_copy_op_d< op, Tsrc[N1], Tdst[N1]>Partial specialization for N=1 1D-Array
 Cmeta_copy_op_d< op, Tsrc[N1][N2], Tdst[N1][N2]>Partial specialization for N=2 2D-Array
 Cmeta_copy_set_bck< T >
 Cmeta_copy_set_bck< T[N]>
 Cmeta_prop< I, ele_g, St, T, is_writable >This class is an helper to create properties output from scalar and compile-time array elements
 Cmeta_prop< I, ele_g, St, T, false >Specialication when is not writable
 Cmeta_prop< I, ele_g, St, T[N1], is_writable >Partial specialization for N=1 1D-Array
 Cmeta_prop< I, ele_g, St, T[N1][N2], is_writable >Partial specialization for N=2 2D-Array
 Cmeta_prop< I, ele_g, St, T[N1][N2][N3], is_writable >Partial specialization for N=3 3D-Array
 Cmeta_prop_new< I, ele_g, St, T, is_writable >This class is an helper to create properties output from scalar and compile-time array elements
 Cmeta_prop_new< I, ele_g, St, T, false >Specialication when is not writable
 Cmeta_prop_new< I, ele_g, St, T[N1], is_writable >Partial specialization for N=1 1D-Array
 Cmeta_prop_new< I, ele_g, St, T[N1][N2], is_writable >Partial specialization for N=2 2D-Array
 Cmeta_prop_new< I, ele_g, St, T[N1][N2][N3], is_writable >Partial specialization for N=3 3D-Array
 Cmeta_raw_read< dim, Tg, Tr, i >This is the scalar case
 Cmeta_raw_read< dim, Tg, Tr[nv], i >This is the vector case
 CMetaFunc< index, N >[Metafunction definition]
 CMetaFuncOrd< index, N >
 CVcluster< InternalMemory >::MetaFuncOrd< index, N >Metafunction
 CMetaParser
 CMethodOfImages< SurfaceNormal, vd_type >Class for getting mirror particles to impose Neumann BCs
 CMetis< Graph >Helper class to define Metis graph
 CMetis< Graph_CSR< nm_v< dim >, nm_e > >
 CMetis_graphMetis graph structure
 CMetisDistribution< dim, T >Class that distribute sub-sub-domains across processors using Metis Library
 Cmheader< n_ele >This structure contain the information of a chunk
 Ccub::MinDefault min functor
 Cmin_< Tdst, Tsrc >This structure define the operation add to use with copy general
 Cminus< arg, Sys_eqs >It ancapsulate the minus operation
 Ctsl::mod_growth_policy< GrowthFactor >
 CModelCustomModel for Dynamic load balancing
 CModelCustom2Second model for dynamic load balancing
 CModelLinLinear model
 CModelSquareLinear model
 CMonomial< dim >
 CMonomial_gpu< dim >
 CMonomialBasis< dim, T, vector_type, Args >
 CMonomialBasis< dim >
 Cmove_impl< impl, grid_key_base, dim >
 Cmove_impl< false, grid_key_base, dim >
 ►Cmp4_kernel< st >
 Cmp_funct< grid, ginfo >
 Cmp_funct_impl< dim, T >
 Cmp_funct_impl< dim, T[N1]>
 Cmp_funct_impl< dim, T[N1][N2]>
 CMPI_IAllGatherW< T >General recv for vector of
 CMPI_IAllGatherW< char >Specialization for vector of char
 CMPI_IAllGatherW< double >Specialization for vector of double
 CMPI_IAllGatherW< float >Specialization for vector of float
 CMPI_IAllGatherW< int >Specialization for vector of integer
 CMPI_IAllGatherW< long int >Specialization for vector of long int
 CMPI_IAllGatherW< short >Specialization for vector of short
 CMPI_IAllGatherW< size_t >Specialization for vector of size_t
 CMPI_IAllGatherW< unsigned char >Specialization for vector of unsigned char
 CMPI_IAllGatherW< unsigned int >Specialization for vector of unsigned integer
 CMPI_IAllGatherW< unsigned short >Specialization for vector of short
 CMPI_IAllGatherWBSet of wrapping classing for MPI_Irecv
 CMPI_IallreduceW< T >Set of wrapping classing for MPI_Iallreduce
 CMPI_IallreduceW< char >Specialization for char
 CMPI_IallreduceW< double >Specialization for double
 CMPI_IallreduceW< float >Specialization for float
 CMPI_IallreduceW< int >Specialization for integer
 CMPI_IallreduceW< long int >Specialization for size_t
 CMPI_IallreduceW< short >Specialization for short
 CMPI_IallreduceW< size_t >Specialization for size_t
 CMPI_IallreduceW< unsigned char >Specialization for char
 CMPI_IallreduceW< unsigned int >Specialization for unsigned integer
 CMPI_IallreduceW< unsigned short >Specialization for short
 CMPI_IBcastW< T >General recv for vector of
 CMPI_IBcastW< char >Specialization for char
 CMPI_IBcastW< double >Specialization for double
 CMPI_IBcastW< float >Specialization for float
 CMPI_IBcastW< int >Specialization for vector of integer
 CMPI_IBcastW< long int >Specialization for size_t
 CMPI_IBcastW< short >Specialization for short
 CMPI_IBcastW< size_t >Specialization for size_t
 CMPI_IBcastW< unsigned char >Specialization for char
 CMPI_IBcastW< unsigned int >Specialization for unsigned integer
 CMPI_IBcastW< unsigned short >Specialization for short
 CMPI_IBcastWBSet of wrapping classing for MPI_Irecv
 CMPI_IrecvW< T >General recv for vector of
 CMPI_IrecvW< char >Specialization for char
 CMPI_IrecvW< double >Specialization for double
 CMPI_IrecvW< float >Specialization for float
 CMPI_IrecvW< int >Specialization for vector of integer
 CMPI_IrecvW< long int >Specialization for size_t
 CMPI_IrecvW< short >Specialization for short
 CMPI_IrecvW< size_t >Specialization for size_t
 CMPI_IrecvW< unsigned char >Specialization for char
 CMPI_IrecvW< unsigned int >Specialization for unsigned integer
 CMPI_IrecvW< unsigned short >Specialization for short
 CMPI_IrecvWBSet of wrapping classing for MPI_Irecv
 CMPI_IsendW< T, Mem, gr >General send for a vector of any type
 CMPI_IsendW< char, Mem, gr >Specialization for char
 CMPI_IsendW< double, Mem, gr >Specialization for double
 CMPI_IsendW< float, Mem, gr >Specialization for float
 CMPI_IsendW< int, Mem, gr >Specialization for vector of integer
 CMPI_IsendW< long int, Mem, gr >Specialization for size_t
 CMPI_IsendW< short, Mem, gr >Specialization for short
 CMPI_IsendW< size_t, Mem, gr >Specialization for size_t
 CMPI_IsendW< unsigned char, Mem, gr >Specialization for char
 CMPI_IsendW< unsigned int, Mem, gr >Specialization for unsigned integer
 CMPI_IsendW< unsigned short, Mem, gr >Specialization for short
 CMPI_IsendWBSet of wrapping classing for MPI_Isend
 CFD::mul
 Cmul< expr >It model an expression expr1 * expr2
 Cmul_inte< T >Multiply the src by coeff for several types T
 Cmul_inte< T[N1]>Multiply the src by coeff for several types T
 Cmul_inte< T[N1][N2]>Multiply the src by coeff for several types T
 Cmult< T, N >This class multiply all the elements in a boost::mpl::vector excluding the first element
 Cmult< T, 1 >
 Cmulti_array< T >This class is a trick to indicate the compiler a specific specialization pattern
 ►Copenfpm::detail::multi_array::multi_array_base_openfpm
 Cmulti_mask< i >
 Cmulti_mask< 1 >
 Cmulti_mask< 16 >
 Cmulti_mask< 2 >
 Cmulti_mask< 4 >
 Cmulti_mask< 8 >
 CMultiArrayViewGpu< BaseT, Nup, N >
 CMultiArrayViewGpu< BaseT, Nup, 0 >
 Cmutable_or_not< T, mm >
 Cmutable_or_not< Kernel, is_gpu_celllist< NN >::type::value||is_gpu_ker_celllist< NN >::type::value >
 Cmutable_or_not< NN, is_gpu_celllist< NN >::type::value||is_gpu_ker_celllist< NN >::type::value >
 Cmutable_or_not< T, true >
 Ccub::Mutex
 Cmy_particle
 Cmy_struct
 CN_box< dim, T >
 CN_operation
 CNarrowBand< grid_in_type, phi_type >Class for getting the narrow band around the interface
 Cnative_encapsulated_type< T >
 Cnb_f
 Cne_cp
 Cnm_eSub-domain edge graph node
 Cnm_part_eReduced edge graph node
 Cnm_part_vReduced sub-domain vertex graph node
 Cnm_v< dim >
 ►CNN_gpu_int_base_hr_impl< dim, r_int, pr_int, ids_type, cnt_type >
 CNN_gpu_it< dim, cnt_type, ids_type, r_int, true >
 CNN_gpu_it_radius< dim, cnt_type, ids_type >
 CNN_gpu_selector< dim, cnt_type, ids_type, is_sparse >
 CNN_gpu_selector< dim, cnt_type, ids_type, true >
 CNN_index< impl >
 CNN_index< NN_index_sort >
 ►Cnn_prcs< dim, T, layout_base, Memory >This class store the adjacent processors and the adjacent sub_domains
 Cnn_prcs< dim, St, layout_base, Memory >
 Cnn_prcs< dim, T, memory_traits_lin, HeapMemory >
 Cnn_prcs< dim, typename grid_in_type::stype, layout_base, Memory >
 Cnn_type_result< NN1_type, NN2_type >
 Cnn_type_result< void, NN2_type >
 CNNc_array< dim, size, thr >
 CNNc_array< dim, NNc_size >
 CNNc_array< dim, openfpm::math::pow(3, dim)/2+1 >
 CNNc_array< dim, size, false >
 CNNc_array< dim,(unsigned int) openfpm::math::pow(3, dim)/2+1 >
 CNNc_array< dim,(unsigned int) openfpm::math::pow(3, dim)>
 CNNFull< dim >
 CNNfull_is_padding_impl< dim >Check if is padding
 CNNfull_is_padding_impl< 2 >Check if is padding
 CNNfull_is_padding_impl< 3 >Check if is padding
 CNNStar< dim >
 CNNStar_c< dim >
 CNNType< dim, T, CellListImpl, PartIt, type, local_index >Get the neighborhood iterator based on type
 CNNType< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC, local_index >Get the neighborhood iterator based on type
 CNNType< dim, T, CellListImpl, PartIt, VL_SYMMETRIC, local_index >Get the neighborhood iterator based on type
 CNNType< dim, T, CellListImpl, PartIt, WITH_RADIUS, local_index >Get the neighborhood iterator based on type
 CNNTypeM< dim, T, CellListImpl, PartIt, type >Get the neighborhood iterator based on type
 CNNTypeM< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC >Get the neighborhood iterator based on type
 CNNTypeM< dim, T, CellListImpl, PartIt, VL_SYMMETRIC >Get the neighborhood iterator based on type
 CNo_check
 Cno_edgeClass with no edge
 Cno_equationSpecify the general characteristic of system to solve
 Cno_fieldStub field
 Cno_stencilNo stencil
 Cno_transform< dim, T >No transformation
 Cno_transform_only< dim, T >No transformation
 CNoCheckClass to check if the edge can be created or not
 Cnode_cp
 CnoPointers_sequence< v, prp >It return a boost::mpl::vector of integers where each integer identify one object without the method "noPointers"
 CnoPointers_sequence_impl< v, p1, prp >Implementation of noPointer_sequence_impl
 CnoPointers_sequence_impl< v, p1 >Implementation of noPointer_sequence_impl
 Cnot_on_testNot on testing mode
 CNothingOut-of-bound policy do nothing
 Ccub::NullTypeA simple "NULL" marker type
 Cnumber_prop< T, np >
 Cnumber_prop< T, 0 >Return the number of properties the type T has
 Cobject< v >This is a container to create a general object
 Cobject_creator< v, prp >It create a boost::fusion vector with the selected properties
 Cobject_creator< v >Specialization when no properties are passed
 Cobject_creator_chunking< v, prp >
 Cobject_creator_chunking< v >Specialization when no properties are passed
 Cobject_creator_chunking_encapsulator< T >
 Cobject_creator_chunking_impl< v, vc, prp >Implementation of object creator
 Cobject_creator_chunking_impl< v, vc, p1, prp... >Implementation of object creator
 Cobject_creator_chunking_impl< v, vc, prp >Implementation of object creator
 Cobject_creator_impl< v, vc, prp >Implementation of object creator
 Cobject_creator_impl< v, vc, p1, prp... >Implementation of object creator
 Cobject_creator_impl< v, vc, prp >Implementation of object creator
 Cobject_s_di< v_src, v_dst, type_copy, prp >It copy the properties from one object to another
 Cobject_s_di< v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another
 Cobject_s_di< v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... >
 Cobject_s_di< v_src, v_dst, OBJ_NORMAL, prp... >Given a set of properties for the destination (0,1,3,5) it copy the source properties (0,1,2,3)
 Cobject_s_di_e< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_s_di_e_cnk< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_s_di_e_cnk_meta_copy_selector< T >
 Cobject_s_di_e_cnk_meta_copy_selector< T[N1]>
 Cobject_s_di_e_op< op, v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_s_di_e_op_cnk< op, v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_s_di_f< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_s_di_f_op< op, v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_s_di_op< op, v_src, v_dst, type_copy, prp >It copy the properties from one object to another applying an operation
 Cobject_s_di_op< op, v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another applying an operation
 Cobject_s_di_op< op, v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... >It copy the properties from one object to another applying an operation
 Cobject_s_di_op< op, v_src, v_dst, OBJ_NORMAL, prp... >Given a set of properties for the destination (0,1,3,5) it copy the source properties (0,1,2,3) applying an operation
 Cobject_si_d< v_src, v_dst, type_copy, prp >It copy the properties from one object to another
 Cobject_si_d< v_src, v_dst, OBJ_ENCAP >
 Cobject_si_d< v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another
 Cobject_si_d< v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... >It copy the properties from one object to another
 Cobject_si_d< v_src, v_dst, OBJ_NORMAL, prp... >It copy the properties from one object to another
 Cobject_si_d_e< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_si_d_e_cnk< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_si_d_e_cnk_meta_copy_selector< T >
 Cobject_si_d_e_cnk_meta_copy_selector< T[N1]>
 Cobject_si_d_f< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_si_di< v_src, v_dst, type_copy, prp >It copy the properties from one object to another applying an operation
 Cobject_si_di< v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another applying an operation
 Cobject_si_di_e< v_src, v_dst, prp >
 Cobject_si_di_e_op< op, v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cobject_si_di_op< op, v_src, v_dst, type_copy, prp >It copy the properties from one object to another applying an operation
 Cobject_si_di_op< op, v_src, v_dst, OBJ_ENCAP, prp... >It copy the properties from one object to another applying an operation
 CObserverFunctor< DXX, DYY >
 Coffset_mv< dim >It contain the offset necessary to move to coarser and finer level grids
 Cgpu::ofp_context_t
 Cboost::numeric::odeint::ofp_operations
 Copenfpm::ofp_storage_order
 Con_test[Constant fields struct definition]
 Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::OobInequalityOp< LAST_TILE >
 Cop_ssend_gg_recv_mergeHelper class to merge data
 Cop_ssend_gg_recv_merge_impl< sr >Helper class to merge data without serialization
 Cop_ssend_gg_recv_merge_impl< true >Helper class to merge data with serialization
 Cop_ssend_gg_recv_merge_impl_run_device< sr >Helper class to merge data without serialization, using host memory
 Cop_ssend_gg_recv_merge_impl_run_device_direct< sr >Helper class to merge data without serialization direct transfer to CUDA buffer
 Cop_ssend_gg_recv_merge_run_deviceHelper class to merge data
 Cop_ssend_recv_add< op >Helper class to add data
 Cop_ssend_recv_add_sr< sr >Helper class to add data without serialization
 Cop_ssend_recv_add_sr< true >Helper class to add data with serialization
 Cop_ssend_recv_merge< op, vector_type_opart >Helper class to merge data
 Cop_ssend_recv_merge_gpu< op, vector_type_opart, vector_type_prc_offset >Helper class to merge data
 Cop_ssend_recv_merge_gpu_impl< sr, op, vector_type_opart, vector_type_prc_offset >Helper class to merge data without serialization
 Cop_ssend_recv_merge_gpu_impl< true, op, vector_type_opart, vector_type_prc_offset >Helper class to merge data with serialization
 Cop_ssend_recv_merge_impl< sr, op, vector_type_opart >Helper class to merge data without serialization
 Cop_ssend_recv_merge_impl< true, op, vector_type_opart >Helper class to merge data with serialization
 Copenfpm::detail::multi_array::operator_arrow_proxy_openfpm< T >
 CORB< dim, T, loc_wg, loc_pos, Box, Tree >This class implement orthogonal recursive bisection
 Cp_box< dim, T >It store all the boxes of the near processors in a linear array
 Cpack_pack_op< inte_layout, obj_type, Mem >
 Cpack_request_op< inte_layout, obj_type, Mem >
 Cpack_request_op< true, obj_type, Mem >
 CPack_selector< T >Pack selector
 CPack_selector_array_prim< T, impl >
 CPack_selector_array_prim< T, true >
 CPack_selector_impl< T, is_foundamental >It is not a fundamental type
 CPack_selector_impl< T, true >Select the primitive packing
 CPack_selector_known_type_impl< T, known_type >Pack selector for unknown type
 CPack_selector_known_type_impl< T, HAS_PACKER >
 CPack_selector_known_type_impl< T, IS_ENCAP >
 CPack_selector_known_type_impl< T, IS_GRID >
 CPack_selector_unknown_type_impl< T, has_noPointers >Pack selector for unknown type
 CPack_selector_unknown_type_impl< T, 0 >
 CPack_selector_unknown_type_impl< T, 2 >Pack selector for unknown type
 CPack_selector_unknown_type_impl< T, 3 >
 CPack_statPacking status object
 Cpack_unpack_cond_with_prp< cond, op, T, S, layout_base, prp >There is max_prop inside
 Cpack_unpack_cond_with_prp_inte_lin< T, impl >
 Cpack_unpack_cond_with_prp_inte_lin< T, true >
 Cpack_with_iterator< is_complex, dim, grid, encap_src, encap_dst, boost_vct, it, dtype, prp >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cpack_with_iterator< false, dim, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cpack_with_iterator< true, 1, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cpack_with_iterator< true, 2, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cpack_with_iterator< true, 3, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cpack_with_iterator_longx< dim, obj_byte, git, grid >
 Cpack_with_iterator_longx< 2, obj_byte, git, grid >
 Cpack_with_iterator_longx< 3, obj_byte, git, grid >
 Cpack_with_iterator_shortx< dim, n_cpy, obj_byte, git, grid >
 Cpack_with_iterator_shortx< 2, n_cpy, obj_byte, git, grid >
 Cpack_with_iterator_shortx< 3, n_cpy, obj_byte, git, grid >
 CPacker< T, Mem, pack_type >Packing class
 CPacker< T, Mem, PACKER_ARRAY_CP_PRIMITIVE >
 CPacker< T, Mem, PACKER_ARRAY_PRIMITIVE >Packer for primitives
 CPacker< T, Mem, PACKER_ENCAP_OBJECTS >
 CPacker< T, Mem, PACKER_ENCAP_OBJECTS_CHUNKING >
 CPacker< T, Mem, PACKER_GENERAL >Packer class for vectors
 CPacker< T, Mem, PACKER_GRID >Packer for grids and sub-grids
 CPacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK >Packer class for objects
 CPacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS >Packer for objects, with impossibility to check for internal pointers
 CPacker< T, Mem, PACKER_PRIMITIVE >Packer for primitives
 Ccub::AlignBytes< T >::Pad
 Cpar_struct
 CParmetis< Graph >Helper class to define Metis graph
 CParmetis< Graph_CSR< nm_v< dim >, nm_e > >
 CParmetis_dist_graphMetis graph structure
 CParmetis_graphMetis graph structure
 CParMetisDistribution< dim, T >Class that distribute sub-sub-domains across processors using ParMetis Library
 CParticleIt_CellP< T >
 CParticleIt_Cells< dim, CellListType >This iterator iterate across the particles of a Cell-list following the Cell structure
 CParticleItCRS_Cells< dim, CellListType, vector_pos_type >This iterator iterate across the particles of a Cell-list following the Cell structure
 CPartItNN< type, dim, vector, CellList >In general different NN scheme like full symmetric or CRS require different iterators over particles this class select the proper one
 CPartItNN< VL_CRS_SYMMETRIC, dim, vector, CellList >In general different NN scheme like full symmetric or CRS require different iterators over particles this class select the proper one
 Ccub::DispatchRadixSort< IS_DESCENDING, KeyT, ValueT, OffsetT >::PassConfig< UpsweepKernelT, ScanKernelT, DownsweepKernelT >Pass configuration structure
 Ccub::DispatchSegmentedRadixSort< IS_DESCENDING, KeyT, ValueT, OffsetIteratorT, OffsetT >::PassConfig< SegmentedKernelT >PassConfig data structure
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::PassThruTransform
 Cperiodicity< dim >Boundary conditions
 Cperiodicity_int< dim >Boundary conditions
 Cpetsc_AMG_reportClass to test AMG solvers
 Cpetsc_solver< T >In case T does not match the PETSC precision compilation create a stub structure
 Cpetsc_solver< double >This class is able to do Matrix inversion in parallel with PETSC solvers
 CPoint< dim, T >This class implement the point shape in an N-dimensional space
 CPoint2D_test< T >Test structure used for several test
 CPoint< 2, double >
 CPoint< 3, float >
 CPoint< dim, long int >
 CPoint< dim, unsigned int >
 CPoint< Grid::dims, St >
 CPoint< vector_type::dims, unsigned int >
 Cpoint_and_gid
 Cpoint_expression< T >Main class that encapsulate a constant number used in a point expression
 Cpoint_expression< const T[dim]>Specialization for a const array of dimension dim
 Cpoint_expression< openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > >Specialization for views
 Cpoint_expression< T[dim]>Specialization for an array of dimension dim as expression
 Cpoint_expression_op< orig, exp1, exp2, op >Unknown operation specialization
 Cpoint_expression_op< orig, exp1, exp2, POINT_DIV >Division operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_MUL >Multiplication operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_MUL_POINT >Multiplication operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_NORM >Point norm operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_NORM2 >Point square norm operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_NORM_INF >Point norm Infinity operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_SUB >Subtraction operation
 Cpoint_expression_op< orig, exp1, exp2, POINT_SUB_UNI >Expression that subtract two points
 Cpoint_expression_op< orig, exp1, exp2, POINT_SUM >Sum operation
 CPoint_orig< T >Definition of a class Point in plain C++ and boost::vector for testing purpose
 Cpoint_scalar_process< val_type, is_sort, is_scalar >
 Cpoint_scalar_process< val_type, is_sort, true >
 CPoint_test< T >Test structure used for several test
 CPoint_test_prp< T >Test structure used for several test
 CPoint_test_scal< T >Point test with only scalar properties
 Cpointer_check
 Cpoisson_nn_helm
 CPolarEv< DX, DY, DXX, DXY, DYY >
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy100SM10
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy100SM10
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy100SM10
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy110SM11
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy110SM11
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy110SM11
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy130SM13
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy130SM13
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy130SM13
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy130SM13
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy200SM20
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy200SM20
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy200SM20
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy200SM20
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy200SM20
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy200SM20
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy300SM30
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy300SM30
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy300SM30
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy300SM30
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy300SM30
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy300SM30
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy350SM35
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy350SM35
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy350SM35
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy350SM35
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy350SM35
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy350SM35
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy370SM37
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy500SM50
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy500SM50
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy520SM520
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy600SM600
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy600SM60
 Cpopulate_cell_list_no_sym_impl< is_gpu >
 Cpopulate_cell_list_no_sym_impl< true >
 Cpopulate_cell_list_sym_impl< is_gpu >
 Cpopulate_cell_list_sym_impl< true >
 CFD::pos_or_propL< grid_type, prp >Selector for position or properties left side expression
 Cpos_or_propL< vector, prp >Selector for position or properties left side expression
 Cpos_or_propL< vector, PROP_POS >Selector for position or properties left side
 Cpos_or_propL_ker< vector, prp >Selector for position or properties left side expression
 Cpos_or_propL_ker< vector, PROP_POS >Selector for position or properties left side
 Cpos_or_propR< vector, prp >Selector for position or properties right side position
 Cpos_or_propR< vector, PROP_POS >Selector for position or properties right side
 Cpos_pc
 Cpos_v< vector_pos_type >Structure that contain a reference to a vector of particles
 Cpos_val< dim, T >
 Cpost_increment_sub_impl< dim, stl_type, linearizer >
 ►Ctsl::power_of_two_growth_policy
 Ccub::PowerOfTwo< N >Statically determine if N is a power-of-two
 CPPInterpolation< particlesFrom_type, particlesTo_type >Class for Creating the DCPSE Operator For the function approximation objects and computes DCPSE Kernels
 Ccub::BlockRadixRank< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::PrefixCallBack
 Ctsl::prime_growth_policy
 Cprint_warning_on_adjustment< dim, linearizer >Declaration print_warning_on_adjustment
 Cproc_box_idProcessor id and box id
 Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::proc_with_prp< prp_object, prp >Process the particle with properties
 Cproc_without_prpProcess the particle without properties
 Cproc_without_prp_deviceProcess the particle without properties
 Cprocess_data_block< T, dim, blockEdgeSize >
 Cprocess_data_block< T[N1], dim, blockEdgeSize >
 CProcess_keys_grid< dim, CellList >Class for an hilbert order processing of cell keys for CellList_gen implementation
 CProcess_keys_hilb< dim, CellList >Class for an hilbert order processing of cell keys for CellList_gen implementation
 CProcess_keys_lin< dim, CellList >
 Cprocess_receive_mem_traits_inte< sT, layout_base, Memory >This class is a functor for "for_each" algorithm
 CCartDecomposition< dim, T, Memory, layout_base, Distribution >::processor_idClass to select the returned id by ghost_processorID
 Cprop_id< prp_id >
 Cprop_out_edge< Graph >This class is a functor for "for_each" algorithm
 Cprop_out_g< ele_g, St >This class is a functor for "for_each" algorithm
 Cprop_out_v< ele_v, St >This class is a functor for "for_each" algorithm
 Cprop_out_v_pvtp< ele_v, St >This class is a functor for "for_each" algorithm
 Cprop_out_vertex< Graph >This class is a functor for "for_each" algorithm
 Cprop_output< has_attributes, Graph, i >This class specialize functions in the case the type T has or not defined attributes
 Cprop_output< false, Graph, i >This class specialize functions in the case the type T has not defined attributes
 Cprop_output_array_scalar_selector_edge< is_array >Property writer for scalar and vector
 Cprop_output_array_scalar_selector_edge< true >Property writer for vector
 Cprop_output_array_scalar_selector_edge_fill_vertex< is_array >Property writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk)
 Cprop_output_array_scalar_selector_edge_fill_vertex< true >Property writer for vector
 Cprop_output_array_scalar_selector_vertex< is_array >Property writer for scalar and vector
 Cprop_output_array_scalar_selector_vertex< true >Property writer for vector
 Cprop_write_out< dim, T >Write the vectror property
 Cprop_write_out< 1, T >Write the scalar property
 Cprop_write_out_new< dim, T >Write the vectror property
 Cprop_write_out_new< 1, T >Write the scalar property
 CpropCheckINF< vector >This class is a functor for "for_each" algorithm
 CpropCheckNAN< vector >This class is a functor for "for_each" algorithm
 Cprp_all_zero< T, is_zero, prp >Structure to convert a variadic template into boost::mpl::vector
 Cprp_all_zero< T, true, prp ... >
 CPSEError
 Cptr_info
 Cpush_back_op< is_t, is_s, T, S >
 Cpush_back_op< false, false, T, S >
 Cpush_back_op< false, true, T, S >
 Cpush_back_op< true, true, T, S >
 Cpush_back_op_neste< bool, T, S >Pack/add function selector
 Cpush_back_op_neste< true, T, S >Pack/add function selector
 Cpush_back_std_op_neste< bool, T, S >Pack/add function selector
 Cpush_back_std_op_neste< true, T, S >
 CPV_cl
 Cr_type_dim< op1_dim, op2_dim, op >It return the dimansionality of the operation given the dimensionality of the 2 operators
 Cr_type_dim< 1, 1, POINT_DIV >Scalar / scalar = scalar
 Cr_type_dim< 1, 1, POINT_MUL >Scalar * scalar = scalar
 Cr_type_dim< 1, 1, POINT_SUB >Scalar - scalar = scalar
 Cr_type_dim< 1, 1, POINT_SUM >Scalar + scalar = scalar
 Cr_type_dim< op1_dim, op2_dim, POINT_MUL_POINT >Point * Point = scalar
 Cr_type_p< r, orig >Return type of the expression
 Cr_type_p< 1, orig >Return type of the expression
 Crank_gen< T, is_point >Like std::rank but it also work for openfpm structures like Point where it return 1
 Crank_gen< T, true >
 Craw_read< dim, Tg >This class is a functor for "for_each" algorithm
 Crcv_rm
 CredTemporal buffer for reductions
 Cred_max< prp >Get the reference of the selected element
 Cred_min< prp >
 Cred_sum< prp >
 CRedist_options< phi_type >Structure to bundle options for redistancing
 CRedist_options< double >
 CRedistancingSussman< grid_in_type, phi_type >Class for reinitializing a level-set function into a signed distance function using Sussman redistancing
 Creduce_op< aggr_vect, reduction_vectors >This class is a functor for "for_each" algorithm
 Creduce_op_final< aggr_vect, red_type, reduction_vectors >This class is a functor for "for_each" algorithm
 Creduce_type< T >In general a reduction of a type T produce a type T
 Creduce_type< double[]>A reduction operation on an array of double is a double
 Creduce_type< float[]>A reduction operation on an array of float is a float
 Creduce_type< int[]>A reduction operation on an array of int is an int
 Ccub::ReduceByKeyOp< ReductionOpT >< Binary reduction operator to apply to values
 Ccub::ReduceByKeyOp< cub::Sum >
 Ccub::ReduceByKeyScanTileState< ValueT, KeyT, SINGLE_WORD >
 Ccub::ReduceByKeyScanTileState< ValueT, KeyT, true >
 Ccub::ReduceBySegmentOp< ReductionOpT >Reduce-by-segment functor
 Ccub::ReduceBySegmentOp< cub::Sum >
 Cref_wrap< T >
 Ccub::CacheModifiedOutputIterator< MODIFIER, ValueType, OffsetT >::Reference
 Cboost::numeric::odeint::ofp_operations::rel_error< Fac1 >
 Cboost::numeric::odeint::ofp_operations::rel_error_l2< Fac1 >
 Cboost::numeric::odeint::ofp_operations::rel_error_l2_2< Fac1 >
 Cboost::numeric::odeint::ofp_operations::rel_error_max< Fac1 >
 Cboost::numeric::odeint::ofp_operations::rel_error_max2< Fac1 >
 Cremove_attributes_const_ref< T >T_to_memory_c is a metafunction that given T it convert it into
 Ccub::RemoveQualifiers< Tp, Up >Removes const and volatile qualifiers from type Tp
 Ccub::RemoveQualifiers< Tp, const Up >
 Ccub::RemoveQualifiers< Tp, const volatile Up >
 Ccub::RemoveQualifiers< Tp, volatile Up >
 Copenfpm::reorder< Ti >
 Creplace_< Tdst, Tsrc >This structure define the operation add to use with copy general
 Creport_cell_list_func_tests
 Creport_cell_list_preord_tests
 Creport_grid_copy_func_tests
 Creport_grid_iterator_test
 Creport_sparse_grid_tests
 Creport_vector_func_tests
 Creport_vector_gg_map_tests
 Creport_verlet_tests
 Cresult_box< dim >Result of the itersection of a box with an array of boxes
 CRGBRGB color struct
 CRhsBlockWrapper< BlockT >
 CRhsBlockWrapper< BlockT[N1][N2]>
 CRhsBlockWrapper< BlockT[N]>
 CRHSFunctor< DXX, DYY >
 Crid
 Cgrid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid >::rp_id
 Crval< T, impl >It store one row value of a vector
 Crval< T, EIGEN_RVAL >It store one row value of a vector
 Crval< T, PETSC_RVAL >It store one row value of a vector
 Csadd_< prp >
 Csadd_block_< prp, blockLength >
 Copenfpm::scalar_block_implementation_switch< impl, block_functor >Functor switch to select the vector sparse for standars scalar and blocked implementation
 Copenfpm::scalar_block_implementation_switch< 2, block_functor >
 Cboost::numeric::odeint::ofp_operations::scale< Fac1 >
 Cboost::numeric::odeint::ofp_operations::scale_sum1< Fac1 >
 Cboost::numeric::odeint::ofp_operations::scale_sum10< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10 >
 Cboost::numeric::odeint::ofp_operations::scale_sum11< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11 >
 Cboost::numeric::odeint::ofp_operations::scale_sum12< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11, Fac12 >
 Cboost::numeric::odeint::ofp_operations::scale_sum13< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11, Fac12, Fac13 >
 Cboost::numeric::odeint::ofp_operations::scale_sum14< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11, Fac12, Fac13, Fac14 >
 Cboost::numeric::odeint::ofp_operations::scale_sum2< Fac1, Fac2 >
 Cboost::numeric::odeint::ofp_operations::scale_sum3< Fac1, Fac2, Fac3 >
 Cboost::numeric::odeint::ofp_operations::scale_sum4< Fac1, Fac2, Fac3, Fac4 >
 Cboost::numeric::odeint::ofp_operations::scale_sum5< Fac1, Fac2, Fac3, Fac4, Fac5 >
 Cboost::numeric::odeint::ofp_operations::scale_sum6< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6 >
 Cboost::numeric::odeint::ofp_operations::scale_sum7< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7 >
 Cboost::numeric::odeint::ofp_operations::scale_sum8< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8 >
 Cboost::numeric::odeint::ofp_operations::scale_sum9< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9 >
 Cboost::numeric::odeint::ofp_operations::scale_sum_swap2< Fac1, Fac2 >
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::ScaleTransform
 Ccub::ScanTileState< T, SINGLE_WORD >
 ►Ccub::ScanTileState< KeyValuePair< KeyT, ValueT > >
 Ccub::ScanTileState< T, false >
 Ccub::ScanTileState< T, true >
 Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage::Aliasable::ScatterAliasable
 Cse_class3_vector< Np, dim, T, Decomposition, vector >This class check for inconsistency access
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::SearchTransform< LevelIteratorT >
 Cselector_chunking_prp_has_zero_size< is_not_zero, T, T_nc, prp >
 Cselector_chunking_prp_has_zero_size< true, T, T_nc, prp... >
 Cselvg< is_free >
 Cselvg< false >
 CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::SendGraphPackStruct containing the (sub)graph to send
 Cseq_traits_impl< Seq >Implementation of seq_traits
 Cset_buf_pointer_for_each_prop< sT >This class is a functor for "for_each" algorithm
 Cset_buf_size_for_each_prop< sT >This class is a functor for "for_each" algorithm
 Cset_compile_condition< to_set >
 Cset_compile_condition< false >
 Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::set_mem_retained_buffers< inte_or_lin, send_vector, v_mpl >
 Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::set_mem_retained_buffers< true, send_vector, v_mpl >
 Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::set_mem_retained_buffers_inte< send_vector, v_mpl >Set the buffer for each property
 Cset_zero< rtype >Meta-function to return a compatible zero-element
 Cset_zero< Point< dim, T > >Create a point with all compunent set to zero
 CsetBackground_impl< aggrT_src, local_grids_type >This class is a functor for "for_each" algorithm
 Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE5< BinaryOpT, const >
 Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE6< BinaryOpT, >
 Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE7< BinaryOpT, const >
 Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE8< BinaryOpT, >
 Csgrid_cpu< dim, T, S, grid_lin, layout, layout_base, chunking >
 Cshift< dim, T >
 CCartDecomposition< dim, T, Memory, layout_base, Distribution >::shift_idClass to select the returned id by ghost_processorID
 Cshift_only< dim, T >
 Cshift_ph< bit_phases, cnt_type >
 Cshift_vect_converter< dim, T, Memory, layout_base >In case of high dimensions shift vector converter
 Cshift_vect_converter< dim, St, Memory, layout_base >
 Cshift_vect_converter< dim, T, HeapMemory, memory_traits_lin >
 Cshift_vect_converter< dim, typename grid_in_type::stype, Memory, layout_base >
 CSimpleRNGSimpleRNG is a simple random number generator based on George Marsaglia's MWC (multiply with carry) generator. Although it is very simple, it passes Marsaglia's DIEHARD series of random number generator tests
 CSkeletonStencil< dim, p_src, p_dst >
 Cskip_init< np, T >
 Cskip_init< true, T >
 CsLeft_< prp >
 Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, Enable >
 Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 0) &&(MinBits<=8)>::type >
 Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 16) &&(MinBits<=32)>::type >
 Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 32) &&(MinBits<=64)>::type >
 Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 8) &&(MinBits<=16)>::type >
 Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< NeighborhoodSize+NB_RESERVED_BITS_IN_NEIGHBORHOOD >
 Csmax_< prp >
 Csmax_block_< prp, blockLength >
 Csmin_< prp >
 Csmin_block_< prp, blockLength >
 CsolErrorIt contain statistic of the error of the calculated solution
 Cpetsc_solver< double >::solv_bench_infoIt contain the benchmark information for each solver
 Cspace_key_dx< dim, T >Grid_key_dx is the key to access any element in the grid
 CSpaceDistribution< dim, T >Class that distribute sub-sub-domains across processors using an hilbert curve to divide the space
 Csparse_grid_bck_value< chunk_def >
 Csparse_grid_bck_wrapper_impl< base >
 Csparse_grid_bck_wrapper_impl< openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > >
 Csparse_grid_gpu_index< SparseGridGpu_type >Element index contain a data chunk index and a point index
 Csparse_grid_section< SparseGridType >
 Copenfpm::sparse_index< index_type >
 Copenfpm::sparse_vector_reduction< vector_data_type, vector_index_type, vector_index_type2, vector_reduction, block_functor, impl2, pSegment >This class is a functor for "for_each" algorithm
 Copenfpm::sparse_vector_reduction_cpu< vector_data_type, vector_index_type, vector_index_type_reo, vector_reduction, impl >This class is a functor for "for_each" algorithm
 Copenfpm::sparse_vector_reduction_cpu_impl< reduction_type, vector_reduction, T, impl, red_type >
 Copenfpm::sparse_vector_reduction_cpu_impl< reduction_type, vector_reduction, T, impl, red_type[N1]>
 Copenfpm::sparse_vector_reduction_solve_conflict_assign_cpu< encap_src, encap_dst, vector_reduction >This class is a functor for "for_each" algorithm
 Copenfpm::sparse_vector_reduction_solve_conflict_reduce_cpu< encap_src, encap_dst, vector_reduction, impl >This class is a functor for "for_each" algorithm
 Copenfpm::sparse_vector_reduction_solve_conflict_reduce_cpu_impl< impl, vector_reduction, T, red_type >
 Copenfpm::sparse_vector_reduction_solve_conflict_reduce_cpu_impl< impl, vector_reduction, T, red_type[N1]>
 Copenfpm::sparse_vector_special< vector_data_type, vector_index_type, vector_reduction >This class is a functor for "for_each" algorithm
 CSparseGridGpu_iterator< dim, SparseGridType >
 CSparseGridGpu_iterator_sub< dim, SparseGridType >
 Csparsegridgpu_pack_impl< AggregateT, dataBuffer_type, prp >This class is a functor for "for_each" algorithm
 Csparsegridgpu_pack_request< AggregateT, prp >This class is a functor for "for_each" algorithm
 Csparsegridgpu_unpack_impl< AggregateT, dataBuffer_type, prp >This class is a functor for "for_each" algorithm
 CSparseMatrix< T, id_t, DEFAULT_MATRIX >Sparse Matrix implementation
 CSparseMatrix< T, id_t, EIGEN_BASE >
 CSparseMatrix< T, id_t, PETSC_BASE >Sparse Matrix implementation, that map over Eigen
 CSphere< dim, T >This class implement the Sphere concept in an N-dimensional space
 Ccub::SpmvParams< ValueT, OffsetT >< Signed integer type for sequence offsets
 CsRight_< prp >
 Cstag_create_and_add_grid< dim, st_grid, St >It create separated grid for each properties to write them into a file
 Cstag_set_position< dim, v, has_pM >This class is a functor for "for_each" algorithm
 Cstag_set_position< dim, v, false >This class is a functor for "for_each" algorithm
 Cstate_type_1d_ofpA 1d Odeint and Openfpm compatible structure
 Cstate_type_2d_ofpA 2d Odeint and Openfpm compatible structure
 Cstate_type_3d_ofpA 3d Odeint and Openfpm compatible structure
 Cstate_type_4d_ofpA 4d Odeint and Openfpm compatible structure
 Cstate_type_5d_ofpA 5d Odeint and Openfpm compatible structure
 Cstate_type_ofpm_add_elements< counter, state_type, list >
 Cstate_type_ofpm_add_elements< 0, state_type, list ... >
 Cstate_type_ofpm_add_elements< n_state-1, state_type, state_type >
 Cstate_type_ofpm_impl< n_state, state_type >
 Cstatic_array< N, T >
 Cstd_array_copy_chunks< prop, T >
 Cstd_array_copy_chunks< prop, T[N1]>
 Cstd_array_vector_view< ArrTypeView >
 CSparseGridGpuKernels::stencil_conv_func_impl< dim >
 CSparseGridGpuKernels::stencil_conv_func_impl< 2 >
 CSparseGridGpuKernels::stencil_conv_func_impl< 3 >
 CSparseGridGpuKernels::stencil_cross_func< dim, p_src, p_dst, stencil_size >
 CSparseGridGpuKernels::stencil_cross_func_conv< dim, n_loop, p_src, p_dst, stencil_size >
 CSparseGridGpuKernels::stencil_cross_func_conv_block_read< dim, n_loop, p_src, p_dst, stencil_size >
 CSparseGridGpuKernels::stencil_cross_func_impl< dim >
 CSparseGridGpuKernels::stencil_func_conv2< dim, n_loop, p_src1, p_src2, p_dst1, p_dst2, stencil_size >
 CSparseGridGpuKernels::stencil_func_conv2_b< dim, n_loop, p_src1, p_src2, p_dst1, p_dst2, stencil_size >
 CSparseGridGpuKernels::stencil_func_conv3_b< dim, n_loop, p_src1, p_src2, p_src3, p_dst1, p_dst2, p_dst3, stencil_size >
 Cstencil_offset_compute< dim, Np >Structure for stencil iterator
 Cstore_reduce_op_final< red_type, encap_type, reduction_vectors >This class is a functor for "for_each" algorithm
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< _POLICY, DUMMY >Store helper
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_DIRECT, DUMMY >
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_TRANSPOSE, DUMMY >
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_VECTORIZE, DUMMY >
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_WARP_TRANSPOSE, DUMMY >
 Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED, DUMMY >
 Cstriding< dim >
 Copenfpm::stub_block_functor
 Cstub_or_real< T, dims, stype, decomposition, stub >In case of testing return a stub grid
 Cstub_or_real< last, last::dims, typenamelast::stype, typenamelast::b_grid::decomposition::extended_type >
 Cstub_or_real< T, dims, stype, decomposition, false >Case when we are not on testing
 CFD::sub
 Cgrid_dist_iterator_sub< dim, device_grid >::sub_set
 Csubar_dim< vmpl >Return the dimension of the sub_array
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::subarray< NDims >
 Copenfpm::subarray_gen_openfpm< Array, N, vector >
 Csublin< dim, chunk >
 Csublin< 1, chunk >
 Csublin< 2, chunk >
 Csublin< 3, chunk >
 Csublin< 4, chunk >
 Csublin< 5, chunk >
 Csublin< 6, chunk >
 Csublin< 7, chunk >
 Csublin< 8, chunk >
 Csubsub< dim >Sub-sub-domain
 Csubsub_lin< dim >Linearized version of subsub
 CFD::subuni
 Ccub::SumDefault sum functor
 CFD::sum
 Csum< expr >It model an expression expr1 + ... exprn
 Csum_ele< bint, ele >
 Csum_ele< boost::mpl::int_< op1 >, ele >
 Csum_ele< boost::mpl::na, ele >
 Csum_functor_value< v_expr >Sum functor value
 CSupport
 CSupportBuilder< vector_type, vector_type2 >
 CSupportBuilderGPU< vector_type >
 Cswitch_copy_host_to_device< T_type, prp >This class is a functor for "for_each" algorithm
 Cswitcher_get_v< vector, impl >
 Cswitcher_get_v< vector, comp_dev >
 Ccub::SwizzleScanOp< ScanOp >Binary operator wrapper for switching non-commutative scan arguments
 Csys_nn
 Csys_pp
 Csyss_nn
 Csyss_pp
 CSystem< dim, nvf, ncf, eqs >System of equations
 Ct_to_memory_c< T >Meta-function t_to_memory_c
 Ct_to_memory_c_impl< T >Partial specialization for scalar N=0
 Ct_to_memory_c_impl< T[N1]>Partial specialization for N=1
 Ct_to_memory_c_impl< T[N1][N2]>Partial specialization for N=2
 Ct_to_memory_c_impl< T[N1][N2][N3]>Partial specialization for N=3
 Ct_to_memory_c_impl< T[N1][N2][N3][N4]>Partial specialization for N=4
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6]>Partial specialization for N=6
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7]>Partial specialization for N=7
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8]>Partial specialization for N=8
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>Partial specialization for N=9
 Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>Partial specialization for N=10
 Ct_to_memory_c_red< T >Meta-function t_to_memory_c_red
 Ct_to_memory_c_red_impl< T >Partial specialization for scalar N=0
 Ct_to_memory_c_red_impl< T[N1]>Partial specialization for N=1
 Ct_to_memory_c_red_impl< T[N1][N2]>Partial specialization for N=2
 Ct_to_memory_c_red_impl< T[N1][N2][N3]>Partial specialization for N=3
 Ct_to_memory_c_red_impl< T[N1][N2][N3][N4]>Partial specialization for N=4
 Ct_to_memory_c_red_impl< T[N1][N2][N3][N4][N5]>Partial specialization for N=5
 Ccub::BlockHistogramAtomic< BINS >::TempStorageShared memory storage layout type
 Ccub::TempStorage
 Ccub::WarpScanShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorageShared memory storage layout type
 Ctensor< T, s1, s2, s3 >
 Ctensor< int, s1, s2, s3 >
 Ctest_box_vpack
 Ctest_chunking3
 Ctest_grid_type_no_def
 Ctest_grid_type_normal
 Ctest_grid_type_staggered[Define structures]
 Ctest_has_attributes[Check has_posMask struct definition]
 Ctest_has_max_propTest type for has_max_prop
 Ctest_has_no_max_propTest type for has_max_prop
 Ctest_has_posMask[Check has_posMask struct definition]
 Ctest_no_attributes
 Ctest_no_has_posMaskTest type for has_posMask
 Ccub::TexObjInputIterator< T, OffsetT >A random-access input wrapper for dereferencing array values through texture cache. Uses newer Kepler-style texture objects
 CTiffWriter< dim, T >This class is able to save grid into tiff files
 Ccub::ScanTileState< T, true >::TileDescriptor
 Ccub::ReduceByKeyScanTileState< ValueT, KeyT, true >::TileDescriptorBigStatus
 Ccub::ReduceByKeyScanTileState< ValueT, KeyT, true >::TileDescriptorLittleStatus
 Ccub::TilePrefixCallbackOp< T, ScanOpT, ScanTileStateT, PTX_ARCH >
 CtimerClass for cpu time benchmarking
 CTimesTime structure for statistical purposes
 Cto_boost_vmpl< id >
 Cto_int_sequence< N, M >
 Cto_memory_multi_array_ref_view< T >OpenFPM use memory_c<multi_array<T> ..... > to implement the structure of array layout
 Cto_variadic_const_impl< c, end, ele, exit, vars >Recursive specialization of to_variadic
 Cto_variadic_const_impl< c, end, ele, true, vars ... >Terminator of to_variadic
 Cto_variadic_impl< c, end, exit, vars >Recursive specialization of to_variadic
 Cto_variadic_impl< c, end, true, vars ... >Terminator of to_variadic
 CtoKernel_transform< layout_base, T, int >
 CtoKernel_transform< layout_base, T, 0 >
 CtoKernel_transform< layout_base, T, 1 >
 CtoPoint< dim, St >
 Ccub::CachingDeviceAllocator::TotalBytes
 Ctransform_if_temporal< v_exp >
 Ctransform_if_temporal< vector_dist_expression< 0, openfpm::vector_gpu< aggregate< T > > > >
 Ccub::TransformInputIterator< ValueType, ConversionOp, InputIteratorT, OffsetT >A random-access input wrapper for transforming dereferenced values
 Ctriplet< T, impl >It store the non zero elements of the matrix
 Ctriplet< T, EIGEN_TRIPLET >It store one non-zero element in the sparse matrix
 Ctriplet< T, PETSC_BASE >It store one non-zero element in the sparse matrix
 ►Cstd::true_type
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::TScale< NOMINAL_ITEMS_PER_THREAD >
 ►Cvalue_accessor_generator_openfpm::type
 ►Cvalue_accessor_generator_openfpm::type
 ►Cvalue_accessor_generator_openfpm::type
 ►Cvalue_accessor_generator_openfpm::type
 ►Cvalue_accessor_generator_openfpm::type
 Ctype_identity< T >
 Ctype_is_one
 CtypeCheck< tcheck, foundamental >Type check in case of unknown type
 CtypeCheck< tcheck, true >Type check in case of supported type
 CtypeCheck< tcheck[N1], foundamental >Type check in case of supported array type
 CtypeCheck< tcheck[N1][N2], foundamental >Type check in case of supported 2D array type
 CUIntDivCeil< numerator, denominator >
 Cumfpack_solver< T >Stub when library compiled without eigen
 Cumfpack_solver< double >Stub when library compiled without eigen
 ►Cstd::unary_function
 Ccub::Uninitialized< T >A storage-backing wrapper that allows types with non-trivial constructors to be aliased in unions
 ►Ccub::Uninitialized< _TempStorage >
 Ccub::Uninitialized< cub::KeyValuePair[TILE_ITEMS+1]>
 Ccub::Uninitialized< ItemExchangeT >
 Ccub::Uninitialized< KeyValuePair< OffsetT, LengthT >[WARPS]>
 Ccub::Uninitialized< OuterScanArray >
 ►Ccub::UnitWord< T >Unit-words of data movement
 Ccub::UnitWord< _TempStorage >
 Ccub::UnitWord< char2 >
 Ccub::UnitWord< cub::KeyValuePair >
 Ccub::UnitWord< float2 >
 Ccub::UnitWord< float4 >
 Ccub::UnitWord< ItemExchangeT >
 Ccub::UnitWord< KeyValuePair< OffsetT, LengthT > >
 Ccub::UnitWord< OuterScanArray >
 ►Cstd::unordered_map
 Cunpack_each_prop_buffer< op, Vt, S, layout_base, v_mpl >
 Cunpack_selector_with_prp< result, T, S, layout_base, Memory >
 Cunpack_selector_with_prp< true, T, S, layout_base, Memory >
 Cunpack_selector_with_prp_lin< inte_or_lin, T, S, layout_base, Memory >
 Cunpack_selector_with_prp_lin< true, T, S, layout_base, Memory >
 CUnpack_statUnpacking status object
 Cunpack_with_iterator< dim, grid, encap_src, encap_dst, boost_vct, it, stype, prp >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 Cunpack_with_iterator< 3, grid, encap_src, encap_dst, boost_vct, it, stype, prp ... >Pack an N-dimensional grid into a vector like structure B given an iterator of the grid
 CUnpacker< T, Mem, pack_type >Unpacker class
 CUnpacker< T, Mem, PACKER_ARRAY_CP_PRIMITIVE >
 CUnpacker< T, Mem, PACKER_ARRAY_PRIMITIVE >
 CUnpacker< T, Mem, PACKER_ENCAP_OBJECTS_CHUNKING >Unpacker for encapsulated objects
 CUnpacker< T, Mem, PACKER_GENERAL >Unpacker for vectors
 CUnpacker< T, Mem, PACKER_GRID >Unpacker for grids
 CUnpacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK >Unpacker class for objects
 CUnpacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS >Unpacker for objects with no possibility to check for internal pointers
 CUnpacker< T, Mem, PACKER_PRIMITIVE >Unpacker for primitives
 Cunroll_with_to_kernel< is_sorted, uwk, T >
 Cunroll_with_to_kernel< false, true, T >
 Cunroll_with_to_kernel< true, true, T >
 Cut_startBoost unit test fixation (start procedure to call before testing)
 Cv_box< vector >
 Cv_info
 Cv_mem_mutable< vector >
 Cv_mem_mutable< typename vector_expression_transform< vector >::type >
 CV_p< T >Vertex class that encapsulate an object T
 Cv_transform< H, L >
 Cv_transform_impl< H, F, L, exit, Args >Recursive specialization of v_transform
 Cv_transform_impl< H, F, L, true, Args... >Terminator of to_variadic
 Cv_transform_two< H, arg0, L >
 Cv_transform_two_impl< H, arg0, F, L, exit, Args >Recursive specialization of v_transform in case of metafunction with 2 argument
 Cv_transform_two_impl< H, arg0, F, L, true, Args... >Terminator of to_variadic
 Cv_transform_two_v2< H, arg0, L >
 Cv_transform_two_v2_impl< H, arg0, F, L, exit, Args >Recursive specialization of v_transform in case of metafunction with 2 argument
 Cv_transform_two_v2_impl< H, arg0, F, L, true, Args... >Terminator of to_variadic
 Copenfpm::detail::multi_array::value_accessor_generator_openfpm< T, NumDims, vector >
 Cvalue_function< integer >
 Ctsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::ValueSelect
 Ctsl::hopscotch_sc_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::ValueSelect
 CVandermonde< dim, T, MatrixType >
 CVandermondeRowBuilder< dim, T, MonomialBasis_type >
 CFD_scheme< Sys_eqs, grid_type >::variable_b< prp_id >Encapsulation of the b term as constant
 Cvariadic_caller< T >
 Cvariadic_caller< index_tuple_sq< prp ... > >
 ►CVcluster_base< InternalMemory >This class virtualize the cluster of PC as a set of processes that communicate
 CVcluster_base< HeapMemory >
 CVcluster_logVcluster log
 Cvect_dist_key_dxGrid key for a distributed grid
 Copenfpm::vect_isel< T >It analyze the type given and it select correctly the implementation for vector
 Copenfpm::vector< T, Memory, layout_base, grow_p, impl >Implementation of 1-D std::vector like structure
 ►Cvector
 CVector< T, DEFAULT_VECTOR >Sparse Matrix implementation stub object when OpenFPM is compiled with no linear algebra support
 Copenfpm::vector< agg_arr< openfpm::math::pow(kernel::np, vector::dims)> >
 Copenfpm::vector< aggregate, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< 128 > >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< 128 >, BlockMapGpuFunctors::BlockFunctor< 128 > >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< 128 >, BlockMapGpuFunctors::BlockFunctor< 128 >, BlockMapGpuFunctors::BlockFunctor< 128 > >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< threadBlockSize > >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, BlockMapGpuFunctors::BlockFunctor< threadBlockSize > >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, BlockMapGpuFunctors::BlockFunctor< threadBlockSize > >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< dim, St >, Memory, layout_base >
 Copenfpm::vector< aggregate< dim, T >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< dim, T >, Memory, layout_base >
 Copenfpm::vector< aggregate< dim, typename grid_in_type::stype >, Memory, layout_base >
 Copenfpm::vector< aggregate< ids_type >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< ids_type >, Memory, layout_base >
 Copenfpm::vector< aggregate< int > >
 Copenfpm::vector< aggregate< int >, HeapMemory >
 Copenfpm::vector< aggregate< int >, Memory >
 Copenfpm::vector< aggregate< int, int >, HeapMemory, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< int, int >, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< int, int, int >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< int, short int > >
 Copenfpm::vector< aggregate< int[dim]> >
 Copenfpm::vector< aggregate< local_index_ >, HeapMemory >
 Copenfpm::vector< aggregate< long int > >
 Copenfpm::vector< aggregate< long int >, HeapMemory, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< long int, long int >, HeapMemory, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< long int, long int, long int >, HeapMemory, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< aggregate< long int, unsigned int > >
 Copenfpm::vector< aggregate< short int, short int > >
 Copenfpm::vector< aggregate< size_t > >
 Copenfpm::vector< aggregate< size_t >, HeapMemory >
 Copenfpm::vector< aggregate< size_t, size_t, unsigned int > >
 Copenfpm::vector< aggregate< T > >
 Copenfpm::vector< aggregate< T >, memory, layout_base >
 Copenfpm::vector< aggregate< typename Mem_type::local_index_type >, HeapMemory >
 Copenfpm::vector< aggregate< unsigned int > >
 Copenfpm::vector< aggregate< unsigned int >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< unsigned int, unsigned int >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, Memory, layout_base >
 Copenfpm::vector< aggregate< unsigned int, unsigned long int >, CudaMemory, memory_traits_inte >
 Copenfpm::vector< aggregate< void *, void *, int > >
 Copenfpm::vector< aggregate_bfv< chunk_def >, S, layout_base >
 Copenfpm::vector< AggregateAppend< int, prop >::type, HeapMemory, memory_traits_lin >
 Copenfpm::vector< AggregateInternalT, long int, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< AggregateInternalT, long int, memory_traits_lin, grow_policy_double, vect_isel< AggregateInternalT >::value >
 Copenfpm::vector< AMG_time_err_coars >
 Copenfpm::vector< Box< dim, int > >
 Copenfpm::vector< Box< dim, long int > >
 Copenfpm::vector< Box< dim, size_t > >
 Copenfpm::vector< Box< dim, St >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< Box< dim, St >, Memory, layout_base >
 Copenfpm::vector< Box< dim, T > >
 Copenfpm::vector< Box< dim, T >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< Box< dim, T >, Memory, layout_base >
 Copenfpm::vector< Box< dim, typename grid_in_type::stype >, Memory, layout_base >
 Copenfpm::vector< Box< dim, unsigned int > >
 Copenfpm::vector< Box_dom< dim, St > >
 Copenfpm::vector< Box_dom< dim, T > >
 Copenfpm::vector< Box_dom< dim, typename grid_in_type::stype > >
 Copenfpm::vector< Box_loc_sub< dim, St > >
 Copenfpm::vector< Box_loc_sub< dim, T > >
 Copenfpm::vector< Box_loc_sub< dim, typename grid_in_type::stype > >
 Copenfpm::vector< Box_sub< dim, T > >
 Copenfpm::vector< Box_sub_k< dim, T > >
 Copenfpm::vector< cell_grid< Grid > >
 Copenfpm::vector< cheader< dim > >
 Copenfpm::vector< cheader< dim >, S >
 Cstd::vector< comb< 0 > >Stub vector specialization
 Copenfpm::vector< comb< dim > >
 Copenfpm::vector< const Grid * >
 Copenfpm::vector< const void * >
 Copenfpm::vector< convertAggr >
 Copenfpm::vector< device_grid >
 Copenfpm::vector< DistGraph_CSR::EdgeReq >
 Copenfpm::vector< DistGraph_CSR::SendGraphPack >
 Copenfpm::vector< E >
 Copenfpm::vector< E, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< E >::value >
 Copenfpm::vector< e_box_id< dim > >
 Copenfpm::vector< e_box_multi< dim > >
 Copenfpm::vector< e_info >
 Copenfpm::vector< e_info, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< e_info >::value >
 Copenfpm::vector< e_lbox_grid< dim > >
 Copenfpm::vector< e_lbox_id< dim > >
 Copenfpm::vector< e_map, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< e_map >::value >
 Copenfpm::vector< ele_g >
 Copenfpm::vector< ele_g< typename pair::first, typename pair::second > >
 Copenfpm::vector< ele_g_st< typename pair::first, typename pair::second > >
 Copenfpm::vector< ele_v >
 Copenfpm::vector< ele_vpp< typename pair::second > >
 Copenfpm::vector< ele_vps< typename pair::first > >
 Copenfpm::vector< ep_box_grid< dim > >
 Copenfpm::vector< GBoxes< Decomposition::dims > >
 Copenfpm::vector< GBoxes< device_grid::dims > >
 Copenfpm::vector< GBoxes< dim > >
 Copenfpm::vector< GGraph >
 Copenfpm::vector< grid_base< dim, aggregate< double > > >
 Copenfpm::vector< grid_cpu< dim, aggregate< size_t > > >
 Copenfpm::vector< grid_cpu< dim, props_temp > >
 Copenfpm::vector< grid_cpu< dim, T > >
 Copenfpm::vector< grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >, HeapMemory, memory_traits_lin, openfpm::grow_policy_identity, STD_VECTOR >
 Copenfpm::vector< grid_dist_id_comm::rp_id >
 Copenfpm::vector< grid_dist_id_iterator_dec_skin::gp_sub >
 Copenfpm::vector< grid_dist_iterator< dim, device_grid, device_it, FIXED > >
 Copenfpm::vector< grid_dist_iterator< dim, device_grid, device_sub_it, FREE > >
 Copenfpm::vector< grid_dist_iterator_sub< dim, device_grid > >
 Copenfpm::vector< grid_key_dx< dim > >
 Copenfpm::vector< HeapMemory >
 Copenfpm::vector< i_box_id< dim > >
 Copenfpm::vector< i_lbox_grid< dim > >
 Copenfpm::vector< i_lbox_id< dim > >
 Copenfpm::vector< idx_t >
 Copenfpm::vector< int >
 Copenfpm::vector< ip_box_grid< dim > >
 Copenfpm::vector< itError >
 Copenfpm::vector< lBox_dom< dim, St > >
 Copenfpm::vector< lBox_dom< dim, T > >
 Copenfpm::vector< lBox_dom< dim, typename grid_in_type::stype > >
 Copenfpm::vector< lid >
 Copenfpm::vector< long >
 Copenfpm::vector< long int >
 Copenfpm::vector< met_sub_w >
 Copenfpm::vector< mheader< chunking::size::value >, S >
 Copenfpm::vector< mheader< n_ele > >
 Copenfpm::vector< Monomial< dim >, Args... >
 Copenfpm::vector< MPI_Request >
 Copenfpm::vector< MPI_Status >
 Copenfpm::vector< nm_e, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< nm_e >::value >
 Copenfpm::vector< nm_v< dim >, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< nm_v< dim > >::value >
 Copenfpm::vector< no_edge, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< no_edge >::value >
 Copenfpm::vector< openfpm::reorder< BlockMapGpuFunctors::BlockFunctor< 128 > > >
 Copenfpm::vector< openfpm::reorder< BlockMapGpuFunctors::BlockFunctor< threadBlockSize > > >
 Copenfpm::vector< openfpm::reorder< long int > >
 Copenfpm::vector< openfpm::vector >
 Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, aggregate< size_t > >, SpaceBox< dim, long int > > > >
 Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, props_temp >, SpaceBox< dim, long int > > > >
 Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, T >, SpaceBox< dim, long int > > > >
 Copenfpm::vector< openfpm::vector< aggregate< size_t, size_t > > >
 Copenfpm::vector< openfpm::vector< Box< dim, St > > >
 Copenfpm::vector< openfpm::vector< Box_proc< dim, St > > >
 Copenfpm::vector< openfpm::vector< Box_proc< dim, T > > >
 Copenfpm::vector< openfpm::vector< Box_proc< dim, typename grid_in_type::stype > > >
 Copenfpm::vector< openfpm::vector< gid > >
 Copenfpm::vector< openfpm::vector< idx_t > >
 Copenfpm::vector< openfpm::vector< long unsigned int > >
 Copenfpm::vector< openfpm::vector< offset_mv< dim > > >
 Copenfpm::vector< openfpm::vector< size_t > >
 Copenfpm::vector< openfpm::vector< SpaceBox< dim, St > > >
 Copenfpm::vector< openfpm::vector< SpaceBox< dim, T > > >
 Copenfpm::vector< openfpm::vector< SpaceBox< dim, typename grid_in_type::stype > > >
 Copenfpm::vector< openfpm::vector< unsigned char > >
 Copenfpm::vector< ORB_node< T >, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< ORB_node< T > >::value >
 Copenfpm::vector< p_box< dim, St > >
 Copenfpm::vector< p_box< dim, T > >
 Copenfpm::vector< p_box< dim, typename grid_in_type::stype > >
 Copenfpm::vector< patches >
 Copenfpm::vector< PetscInt >
 Copenfpm::vector< PetscScalar >
 Copenfpm::vector< Point< dim, St >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< Point< dim, St >, Memory, layout_base >
 Copenfpm::vector< Point< dim, T > >
 Copenfpm::vector< Point< dim, T >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< Point< dim, T >, Memory, layout_base >
 Copenfpm::vector< Point< dim, typename grid_in_type::stype >, Memory, layout_base >
 Copenfpm::vector< pos_v< typename Cell::internal_vector_pos_type > >
 Copenfpm::vector< prop, HeapMemory, memory_traits_lin >
 Copenfpm::vector< ref_wrap< int > >
 Copenfpm::vector< ref_wrap< vector > >
 Copenfpm::vector< ref_wrap< vector_dist_ker_type > >
 Copenfpm::vector< rid >
 Copenfpm::vector< rval< PetscScalar, PETSC_RVAL >, HeapMemory, memory_traits_inte >
 Copenfpm::vector< rval< T, EIGEN_RVAL > >
 Copenfpm::vector< send_vector >
 Copenfpm::vector< size_t >
 Copenfpm::vector< size_t, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< size_t >::value >
 Copenfpm::vector< solv_bench_info >
 Copenfpm::vector< SpaceBox< dim, St >, Memory, layout_base >
 Copenfpm::vector< SpaceBox< dim, T >, HeapMemory, memory_traits_lin >
 Copenfpm::vector< SpaceBox< dim, T >, Memory, layout_base >
 Copenfpm::vector< SpaceBox< dim, typename grid_in_type::stype >, Memory, layout_base >
 Copenfpm::vector< sparse_grid_section< SparseGridGpu > >
 Copenfpm::vector< std::pair< size_t, size_t > >
 Copenfpm::vector< std::string >
 Copenfpm::vector< std::unordered_map< size_t, size_t > >
 Copenfpm::vector< subsub< dim > >
 Copenfpm::vector< subsub_lin< dim > >
 Copenfpm::vector< T >
 Cvector< T, CudaMemory, memory_traits_inte, grow_policy_double, STD_VECTOR >Implementation of 1-D std::vector like structure
 CVector< T, EIGEN_BASE >
 Cvector< T, HeapMemory, memory_traits_lin, grow_p, STD_VECTOR >Implementation of 1-D std::vector like structure
 Copenfpm::vector< T, HeapMemory, memory_traits_lin, grow_policy_double >
 Copenfpm::vector< T, HeapMemory, memory_traits_lin, grow_policy_double, vect_isel< T >::value >
 Copenfpm::vector< T, Memory, layout_base, grow_p, OPENFPM_NATIVE >Implementation of 1-D std::vector like structure
 CVector< T, PETSC_BASE >PETSC vector for linear algebra
 Cvector< T, PtrMemory, memory_traits_lin, gp, STD_VECTOR >
 Copenfpm::vector< triplet >
 Copenfpm::vector< triplet< T, PETSC_BASE > >
 Copenfpm::vector< typename Mem_type::local_index_type >
 Copenfpm::vector< typename sT::value_type, PtrMemory, layout_base, openfpm::grow_policy_identity >
 Copenfpm::vector< V >
 Copenfpm::vector< V, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< V >::value >
 Copenfpm::vector< v_box< vector > >
 Copenfpm::vector< v_info >
 Copenfpm::vector< v_info, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< v_info >::value >
 Copenfpm::vector< void * >
 Cvector_custd_ker< T, layout_base >Grid interface available when on gpu
 ►Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >This class is an helper for the communication of vector_dist
 Cvector_dist_comm< dim, St, AggregateAppend< int, prop >::type, CartDecomposition< dim, St >, HeapMemory, memory_traits_lin >
 Cvector_dist_comm< dim, St, prop, CartDecomposition< dim, St >, HeapMemory, memory_traits_lin >
 Cvector_dist_expression< prp, vector >Main class that encapsulate a vector properties operand to be used for expressions construction
 Cvector_dist_expression< 16384, point >This class represent a constant parameter in a vector expression
 Cvector_dist_expression< prp, double >Main class that encapsulate a double constant
 Cvector_dist_expression< prp, float >Main class that encapsulate a float constant
 Cvector_dist_expression_comp_proxy_sel< cond >Expression implementation computation selector
 Cvector_dist_expression_comp_proxy_sel< false >
 Cvector_dist_expression_comp_sel< impl, vect_ker >Expression implementation computation selector
 Cvector_dist_expression_comp_sel< comp_dev, false >
 Cvector_dist_expression_comp_sel< comp_host, true >
 Cvector_dist_expression_impl< vector_type >Main class that encapsulate a vector properties operand to be used for expressions construction Temporal Expressions
 ►Cvector_dist_expression_impl< openfpm::vector< aggregate< T >, memory, layout_base > >
 ►Cvector_dist_expression_impl< openfpm::vector_gpu< aggregate< T > > >
 Cvector_dist_expression_op< exp1, exp2, op >Unknown operation specialization
 Cvector_dist_expression_op< exp1, boost::mpl::int_< n >, VECT_COMP >It take an expression and take the component
 Cvector_dist_expression_op< exp1, exp2, VECT_DIV >Division operation
 Cvector_dist_expression_op< exp1, exp2, VECT_MUL >Multiplication operation
 Cvector_dist_expression_op< exp1, exp2, VECT_SUB >Subtraction operation
 Cvector_dist_expression_op< exp1, exp2, VECT_SUM >Sum operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN_SORT >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM_SORT >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SORT >Apply kernel operation
 Cvector_dist_expression_op< exp1, void, VECT_NORM_INF >Expression that encapsulate a vector Norm INF expression
 Cvector_dist_expression_op< exp1, void, VECT_SUB_UNI >It take an expression and create the negatove of this expression
 Cvector_dist_expression_op< exp1, void, VECT_SUM_REDUCE >Expression that encapsulate a vector reduction expression
 Cvector_dist_iteratorIterator that Iterate across particle indexes
 Cvector_dist_iterator_subsetIterator that Iterate across particle indexes
 Cvector_dist_ker_list< vector_dist_ker_type >This class contain a list of all tracked vector_dist_ker around
 ►Cvector_dist_ker_list< int >
 Cvector_dist_ker_list< vector >
 Cvector_dist_op_compute_op< prp, is_sort, impl >
 Cvector_dist_op_compute_op< prp, false, comp_host >
 Cvector_dist_subset< dim, St, prop, Decomposition, Memory, layout_base >
 Cvector_dist_subset< vd_type::dims, typename vd_type::stype, typename vd_type::value_type >
 Cvector_expression_transform< vector, is_ker >
 Cvector_expression_transform< vector, true >
 Copenfpm::vector_gpu_ker< T, layout_base >Grid interface available when on gpu
 Copenfpm::vector_gpu_ker< aggregate< cnt_type >, memory_traits_inte >
 Copenfpm::vector_gpu_ker< aggregate< cnt_type, cnt_type >, memory_traits_inte >
 Copenfpm::vector_gpu_ker< aggregate< DataBlock< float, 64 > >, memory_traits_inte >
 Copenfpm::vector_gpu_ker< aggregate< dim, T >, layout_base >
 Copenfpm::vector_gpu_ker< aggregate< indexT >, layout_base >
 Copenfpm::vector_gpu_ker< aggregate< indexT >, memory_traits_inte >
 Copenfpm::vector_gpu_ker< aggregate< int >, memory_traits_inte >
 Copenfpm::vector_gpu_ker< aggregate< int >, memory_traits_lin >
 Copenfpm::vector_gpu_ker< aggregate< local_index >, layout_base >
 Copenfpm::vector_gpu_ker< aggregate< short int, short int >, memory_traits_inte >
 Copenfpm::vector_gpu_ker< aggregate< Ti >, layout_base >
 Copenfpm::vector_gpu_ker< aggregate< unsigned int, unsigned int, unsigned int >, layout_base >
 Copenfpm::vector_gpu_ker< AggregateBlockT, layout_base >
 Copenfpm::vector_gpu_ker< Box< dim, T >, layout_base >
 Copenfpm::vector_gpu_ker< typename apply_transform< memory_traits_inte, aggregate >::type, memory_traits_inte >
 Copenfpm::vector_gpu_ker_ref< T, layout_base >Grid interface available when on gpu
 Cvector_is_sort_result< s1, s2 >
 Copenfpm::vector_key_iteratorVector iterator
 Copenfpm::vector_key_iterator_ele< p, vector_type >Vector iterator
 Copenfpm::vector_key_iterator_seq< lid >Vector iterator
 Cvector_printer< vector_type, prp >This class is a functor for "for_each" algorithm
 Cvector_reduce_selector< is_device >
 Cvector_reduce_selector< false >
 Cvector_result< v1_type, v2_type >
 Cvector_result< void, v2_type >
 Cboost::numeric::odeint::vector_space_algebra_ofp
 Cboost::numeric::odeint::vector_space_algebra_ofp_gpu
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_1d_ofp >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_2d_ofp >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_3d_ofp >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_4d_ofp >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_5d_ofp >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_ofpm_impl< 1, state_type > >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_ofpm_impl< 2, state_type > >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_ofpm_impl< 3, state_type > >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_ofpm_impl< 4, state_type > >
 Cboost::numeric::odeint::vector_space_norm_inf< state_type_ofpm_impl< 5, state_type > >
 Copenfpm::vector_sparse< T, Ti, Memory, layout, layout_base, grow_p, impl, impl2, block_functor >
 Copenfpm::vector_sparse< AggregateInternalT, BlockMapGpuFunctors::BlockFunctor< 128 >, long int >
 Copenfpm::vector_sparse< AggregateInternalT, BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, long int >
 Copenfpm::vector_sparse_gpu_ker< T, Ti, layout_base >
 Copenfpm::vector_sparse_gpu_ker< aggregate< cnt_type >, int, memory_traits_inte >
 Copenfpm::vector_sparse_gpu_ker< aggregate< DataBlock< float, 64 > >, int, memory_traits_inte >
 Copenfpm::vector_sparse_gpu_ker< AggregateBlockT, indexT, layout_base >
 Copenfpm::vector_subset_ker< dim, prop, layout_base >
 ►CVerletList< dim, T, Mem_fast<>, shift< dim, T >, openfpm::vector< Point< dim, T > > >
 ►CVerletNNIterator< dim, Ver >Iterator for the neighborhood of the cell structures
 CvertexSub-domain vertex graph node
 Cvertex2
 Cvertex3
 Cvertex_node< G >This class is a functor for "for_each" algorithm
 Cvertex_prop< G >This class is a functor for "for_each" algorithm
 Cvl_selector_impl< is_sorted, vl_type, cl_type, impl >
 Cvl_selector_impl< false, vl_type, cl_type, 2 >
 Cvl_selector_impl< is_sorted, vl_type, cl_type, 1 >
 Cvl_selector_impl< true, vl_type, cl_type, 2 >
 Cvmpl_create_constant< N, M >
 Cvmpl_reduce_prod< vmpl >
 Cvmpl_reduce_prod_impl< c, accu, stop, vmpl, exit >
 Cvmpl_reduce_prod_impl< c, accu, stop, vmpl, true >Terminator of to_variadic
 Cvmpl_reduce_prod_stop< vmpl, stop >
 Cvmpl_reduce_prod_stop< vmpl,-1 >
 Cvmpl_sum_constant< ele, vmpl >
 Cvmpl_sum_constant< ele, boost::mpl::vector< vars ... > >
 Cvmpl_sum_constant_impl< ele, vmpl >
 CVoid< typename >Void structure
 CVoid_dev< typename >Void structure
 Cvtk_dims< ObjType, has_dims >If it has not dims property defined the object is considered scalar
 Cvtk_dims< ObjType, true >Return the dimansionality of the object
 Cvtk_dist_edge_node< G >This class is a functor for "for_each" algorithm
 Cvtk_dist_vertex_node< G, attr >This class is a functor for "for_each" algorithm
 Cvtk_dist_vertex_node< G, false >This class is a functor for "for_each" algorithm
 Cvtk_dist_vertex_node_array_scalar_selector< is_array >
 Cvtk_dist_vertex_node_array_scalar_selector< true >
 Cvtk_edge_node< G >This class is a functor for "for_each" algorithm
 Cvtk_type< T, is_w >Vtk type
 Cvtk_type< T, false >Vtk type
 Cvtk_vertex_node< G, attr >This class is a functor for "for_each" algorithm
 Cvtk_vertex_node< G, false >This class is a functor for "for_each" algorithm
 Cvtk_vertex_node_array_scalar_selector< is_array >
 Cvtk_vertex_node_array_scalar_selector< true >
 Cvtk_write< ele, vtk, has_attributes >Write a property that has attributes
 Cvtk_write< ele, vtk, false >Add to the vtk writer the key
 CVTKWriter< Object, imp >
 CVTKWriter< Graph, DIST_GRAPH >
 CVTKWriter< Graph, VTK_GRAPH >
 CVTKWriter< pair, VECTOR_GRIDS >
 CVTKWriter< pair, VECTOR_POINTS >
 CVTKWriter< pair, VECTOR_ST_GRIDS >
 CVTKWriter< vector, VECTOR_BOX >
 Cvx
 Ccub::WarpExchange< T, ITEMS_PER_THREAD, LOGICAL_WARP_THREADS, PTX_ARCH >
 Ccub::WarpReduce< T, LOGICAL_WARP_THREADS, PTX_ARCH >The WarpReduce class provides collective methods for computing a parallel reduction of items partitioned across a CUDA thread warp
 Ccub::WarpReduceShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >WarpReduceShfl provides SHFL-based variants of parallel reduction of items partitioned across a CUDA thread warp
 Ccub::WarpReduceSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >WarpReduceSmem provides smem-based variants of parallel reduction of items partitioned across a CUDA thread warp
 Ccub::WarpScan< T, LOGICAL_WARP_THREADS, PTX_ARCH >The WarpScan class provides collective methods for computing a parallel prefix scan of items partitioned across a CUDA thread warp
 Ccub::WarpScanShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >WarpScanShfl provides SHFL-based variants of parallel prefix scan of items partitioned across a CUDA thread warp
 Ccub::WarpScanSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >WarpScanSmem provides smem-based variants of parallel prefix scan of items partitioned across a CUDA thread warp
 Cwrite_stag< T >Classes to copy each component into a grid and add to the VTKWriter the grid
 Cwrite_stag< T[N1]>For each component add a grid fill it, and add to the VTK writer
 Cwrite_stag< T[N1][N2]>Partial specialization for N=2 2D-Array
 Cz_kernel< st, ord >
 Cz_kernel< st, 1 >
 Cz_kernel< st, 3 >
 Cz_kernel< st, 4 >
 Czero_t< type_t >