OpenFPM_pdata  2.0.0
Project that contain the implementation of distributed structures
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 Ccub::WarpReduceSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >::_TempStorageShared memory storage layout type (1.5 warps-worth of elements for each warp)
 Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::_TempStorage
 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::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage
 Ccub::AgentReduce< AgentReducePolicy, InputIteratorT, OutputIteratorT, OffsetT, ReductionOp >::_TempStorageShared memory type required by this thread block
 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::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::WarpExchange< T, ITEMS_PER_THREAD, LOGICAL_WARP_THREADS, PTX_ARCH >::_TempStorageShared memory storage layout type
 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::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::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::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory
 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::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorageShared memory storage layout type
 Ccub::TilePrefixCallbackOp< T, ScanOpT, ScanTileStateT, PTX_ARCH >::_TempStorage
 Ccub::BlockScanRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, MEMOIZE, PTX_ARCH >::_TempStorageShared memory storage layout 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
 Copenfpm::add_prp_device_impl< is_ok_cuda, T, Memory, layout, layout_base, grow_p >
 Copenfpm::add_prp_device_impl< true, T, Memory, layout, layout_base, grow_p >
 Copenfpm::add_prp_impl< objv, vect_dst >Struct to merge two vectors
 Cadd_prp_impl< objv, vect_dst >Struct to merge two vectors
 Copenfpm::add_prp_impl< OBJECT_ADD, 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_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 ... >
 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
 CAMG_time_err_coarsIt contain information about the performance of the AMG
 Canyname_field[Constant fields struct definition]
 Canyname_field_with_posDefine a non-constant (in space) field
 Capply_kernel_is_number_or_expression< 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< 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< 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::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, 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)
 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_asc< size_p::value >
 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< index, NumDims >
 Cboost::array_openfpm< size_type, NumDims >
 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_ord< size_p::value, typename boost::multi_array< T, size_p::value >::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 >
 Cboost::multi_array_openfpm< T, NumDims, Allocator >::array_view< NDims >
 Cboost::const_multi_array_ref_openfpm< T, NumDims, TPtr >::array_view< NDims >
 Cboost::detail::multi_array::const_sub_array_openfpm< T, NumDims, TPtr >::array_view< NDims >
 Cboost::detail::multi_array::sub_array_openfpm< T, NumDims >::array_view< NDims >
 Copenfpm::array_view_gen_openfpm< Array, N >
 Cboost::array_view_gen_openfpm< Array, N >
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector >::array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims >::array_view_openfpm< NDims >
 Cboost::multi_array_ref_openfpm< T, NumDims >::array_view_openfpm< NDims >
 Cboost::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims >::array_view_openfpm< NDims >
 Cboost::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, TPtr >::array_view_openfpm< NDims >
 Cboost::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
 Ccub::ArrayWrapper< T, COUNT >A wrapper for passing simple static arrays as kernel parameters
 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 >
 Cnm_e::attributesAttributes name
 Cnm_part_v::attributesAttributes name
 Cnm_part_e::attributesAttributes name
 Cnode_cp::attributesAttributes name
 Cnm_v::attributesAttributes name
 Ctest_has_attributes::attributesDefine attribute names
 Ced::attributesAttributes name
 Cne_cp::attributesDefine attributes names
 Cvertex::attributesAttributes name
 Cvertex2::attributesAttributes name
 Cvertex3::attributesAttributes name
 Cvx::attributesAttributes name
 CPoint_test_prp< T >::attributesAttributes name
 CPoint_test_scal< T >::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
 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< int, source2 >
 Cbest_conv< long int, source2 >
 Cbest_conv< source1, int >
 Cbest_conv< source1, long int >
 Cbest_conv< source1, unsigned int >
 Cbest_conv< source1, unsigned long int >
 Cbest_conv< unsigned int, source2 >
 Cbest_conv< unsigned long int, source2 >
 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
 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
 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
 CBox< dim, T >This class represent an N-dimensional box
 CBox< 3, float >
 CBox< dim, dT >
 CBox< dim, long int >
 CBox< dim, size_t >
 CBox< dim, St >
 CBox< dim, typename last::stype >
 CBox< dim, typename Sys_eqs::stype >
 CBox< Grid::dims, size_t >
 CBox< N, size_t >
 CBox< vector::dims, size_t >
 CBox< vector::dims, typename vector::stype >
 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
 Cbrt_test
 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
 Ccall_aggregatePack< obj_type, Mem, prp >Calls a packer in nested way
 Ccall_aggregatePackRequest< obj_type, Mem, prp >
 Ccall_aggregateUnpack< obj_type, Mem, prp >Calls an unpacker in nested way
 Ccall_encapPack< encap, Mem, prp >
 Ccall_encapPackRequest< encap, Mem, prp >
 Ccall_encapUnpack< 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_packRequest_agg_functor< obj_type, Mem >
 Ccall_packRequest_enc_functor< encap, Mem >
 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 >
 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
 CCellBase
 CCellDecomposer_sm
 CCellIterator< Cell >It iterate through the elements of a cell
 CCellList_gpu_ker< dim, T, cnt_type, ids_type, transform >
 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)
 Ccheck_device_ptr< data_type >This class is a functor for "for_each" algorithm
 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_type< T, 2 >
 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 >
 Cboost::detail::multi_array::choose_value_accessor_n_openfpm< T, NumDims >
 Copenfpm::detail::multi_array::choose_value_accessor_one_openfpm< T, vector >
 Cboost::detail::multi_array::choose_value_accessor_one_openfpm< T >
 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 >
 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 copy aggregates applying an operation limited to some properties
 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 >
 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 >
 Cboost::multi_array_openfpm< T, NumDims, Allocator >::const_array_view< NDims >
 Cboost::detail::multi_array::const_sub_array_openfpm< T, NumDims, TPtr >::const_array_view< NDims >
 Cboost::detail::multi_array::sub_array_openfpm< T, NumDims >::const_array_view< NDims >
 Copenfpm::const_array_view_gen_openfpm< Array, N >
 Cboost::const_array_view_gen_openfpm< Array, N >
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::const_array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector >::const_array_view_openfpm< NDims >
 Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims >::const_array_view_openfpm< NDims >
 Cboost::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims >::const_array_view_openfpm< NDims >
 Cboost::const_multi_array_ref_openfpm< T, NumDims, TPtr >::const_array_view_openfpm< NDims >
 Cboost::multi_array_ref_openfpm< T, NumDims >::const_array_view_openfpm< NDims >
 Cboost::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, TPtr >::const_array_view_openfpm< NDims >
 Cboost::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 >
 Cboost::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims >::const_subarray< NDims >
 Copenfpm::const_subarray_gen_openfpm< Array, N, vector >
 Cboost::const_subarray_gen_openfpm< Array, N >
 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
 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_op< op, S >Structure to copy aggregates applying an operation
 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, 2 >Specialization for aggregate type objects
 Ccopy_general_op< op, T, 3 >Specialization for aggregate type object that define an operator=
 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_switch_memory_c_no_cpy< T_type_src, T_type_dst >This class is a functor for "for_each" algorithm
 Ccub::CountingInputIterator< ValueType, OffsetT >A random-access input generator for dereferencing a sequence of incrementing integer values
 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
 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
 CdataDiv< T >Class that store Internal part external and border part of a dataset
 Copenfpm::Debug< typename >
 CDebug< typename >
 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
 Cdevice_grid< dim >
 Cdevice_to_host_impl< T_type, prp >This class is a functor for "for_each" algorithm
 Cdevice_to_host_start_stop_impl< T_type, 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
 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, 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, nm_e > >
 CDistParMetisDistribution< dim, T >
 CDLB
 Cdo_not_print_warning_on_adjustment< dim >
 Cdo_when_dim_gr_i< dim, i, ORB, Enable >This structure use SFINAE to avoid instantiation of invalid code
 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 >
 CDrawParticlesA class to draw/create particles based on simple shaped
 Ce_box_id< dim >It store the information about the external ghost box
 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_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
 Cenable_if< boost::mpl::bool_<(i< dim)> >::type >
 Ccub::EnableIf< Condition, T >Simple enable-if (similar to Boost)
 Ccub::EnableIf< false, T >
 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
 Cep_box_grid< dim >Per-processor external ghost box
 CEq< expr1, expr2, Sys_eqs >Equation
 Cequal_to
 Ccub::EqualityDefault equality functor
 Ccub::Equals< A, B >Type equality test
 Ccub::Equals< A, A >
 CErrorOut-of-bound policy kill the program
 Ceta[Definition of the system]
 Cexecute_cl_test< impl >
 Cexecute_cl_test< 1 >
 Cexecute_cl_test< 2 >
 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]
 Cfalse_type
 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,....}
 Cfirst_variadic< T1, T >
 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
 CFtwo< arg0, T >[v_transform metafunction]
 CGBoxes< dim >This structure store the Box that define the domain inside the Ghost + domain box
 Cgcl< dim, St, CellL, Vector, impl >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 >
 Cgcl_standard_no_symmetric_impl< true >
 CGCoptionsGoogle chart options
 Copenfpm::general_storage_order< NumDims >
 Cboost::general_storage_order_ofp< NumDims >
 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, 1, 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
 Cget_vcl< Memory >
 Cget_vcl< CudaMemory >
 CgetAttrName< ele_g, has_attributes >Return the Attributes name from the type
 CgetAttrName< ele_g, false >Return the Attributes name from the type
 CGGraphGoogle Graph
 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, 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
 CGraph_CSR< nm_v, nm_e >
 CGraph_CSR< V, E >
 CGraphMLWriter< Graph >
 Cgrid< T >
 CFDScheme< Sys_eqs >::grid_b< grid, prp >Encapsulation of the b term as grid
 Cgrid_base_impl< dim, T, S, layout_, layout_base >Implementation of a N-dimensional grid
 Cgrid_base_impl< dim, T, S, memory_traits_inte< T >::type, memory_traits_inte >
 Cgrid_base_impl< dim, T, S, memory_traits_lin< T >::type, memory_traits_lin >
 Cgrid_call_serialize_variadic< device_grid, Memory, T >Unpack selector
 Cgrid_call_serialize_variadic< device_grid, Memory, index_tuple< prp... > >Unpack selector
 Cgrid_cpu< dim, T, S, layout >
 Cgrid_cpu< 1, T, Memory, typename layout_base< T >::type >
 Cgrid_cpu< dim, aggregate< size_t > >
 Cgrid_cpu< dim, Tg >
 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, 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 Sys_eqs::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > >
 Cgrid_dist_id_iterator_dec< Decomposition >Given the decomposition it create an iterator
 Cgrid_dist_iterator< dim, device_grid, impl, stencil >Distributed grid iterator
 Cgrid_dist_iterator< dim, device_grid, FIXED, stencil >Distributed grid iterator
 Cgrid_dist_iterator< dim, device_grid, FREE, stencil >Distributed grid iterator
 Cgrid_dist_iterator_sub< dim, device_grid >Distributed grid iterator
 Cgrid_dist_key_dx< dim >Grid key for a distributed grid
 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 >Grid interface available when on gpu
 Cgrid_gpu_ker< 1, T_, layout_base >
 Cgrid_gpu_ker< 1, T_, memory_traits_inte >
 Cgrid_gpu_ker< 1, T_, memory_traits_lin >
 Cgrid_gpu_ker_constructor_impl< inte_or_lin, T >
 Cgrid_gpu_ker_constructor_impl< false, T >
 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< 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 >
 Cgrid_key_dx_iterator< dim >
 Cgrid_key_dx_iterator< dim, no_stencil >
 Cgrid_key_dx_iterator_hilbert< dim >
 Cgrid_key_dx_iterator_sub< 0, warn >
 Cgrid_key_dx_rEmulate grid_key_dx with runtime dimensionality
 Cgrid_skin_iterator_bc< dim >
 Cgrid_skin_iterator_bc< Decomposition::dims >
 Cgrid_sm< N, T >Declaration grid_sm
 Cgrid_sm< dim, aggregate< size_t > >
 Cgrid_sm< dim, T >
 Cgrid_sm< dim, void >
 Cgrid_sm< last::dims, void >
 Cgrid_sm< Sys_eqs::dims, void >
 Cgrid_toKernelImpl< inte_or_lin, dim, T >
 Cgrid_toKernelImpl< true, 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
 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 >These set of classes generate an array definition at compile-time
 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
 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
 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
 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
 CID_operation< output_type >
 Cie_ghost< dim, T, Memory, layout_base >Structure that store and compute the internal and external local ghost box
 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 >Structure that store and compute the internal and external local ghost box
 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, typename WarpExchangePairs::TempStorage, NullType >
 Ccub::If<(Equals< typename std::iterator_traits< OutputIteratorT >::value_type, void >::VALUE), typename std::iterator_traits< InputIteratorT >::value_type, typename std::iterator_traits< OutputIteratorT >::value_type >
 Ccub::If<(sizeof(T)==8), long long, typename If<(sizeof(T)==4), int, typename If<(sizeof(T)==2), short, char >::Type >::Type >
 Ccub::If<(SMEM_CONFIG==cudaSharedMemBankSizeEightByte), unsigned long long, unsigned int >
 Ccub::If<(STATUS_WORD_SIZE==8), long long, typename If<(STATUS_WORD_SIZE==4), int, typename If<(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
 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
 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, 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
 Cip_box_grid< dim >Per-processor Internal ghost box
 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< 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
 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 >
 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::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >::Iterate< COUNT, MAX >
 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)
 Citerator_facade
 Citerator_facade
 CIterator_g_const
 Cpetsc_solver< double >::itErrorContain the infinity norm of the residual at each iteration
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::KernelConfig
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::KernelConfig
 Ccub::DispatchSpmv< ValueT, OffsetT >::KernelConfig
 Ccub::KernelConfig
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::KernelConfig
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::KernelConfig
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::KernelConfig
 CFDScheme< Sys_eqs >::key_and_eqEquation id + space position
 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
 ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, is_ok_cuda >
 ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, true >
 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 >
 Clast_variadic< T1, T >
 Clast_variadic< T1 >
 Cvector< T, CudaMemory, typename memory_traits_inte< aggregate< T > >::type, memory_traits_inte, grow_policy_double, STD_VECTOR >::layout_base__< Tobj >
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::layout_base__< Tobj >
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::layout_base__< Tobj >
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, 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
 Cln_force
 Cln_potential
 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 >
 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_prop_nn< T, has_max_prop >
 Cmax_prop_nn< T, false >
 Cmaximum_t
 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< Memory, int >
 CMem_fast<>
 CMem_fast_ker< Memory, layout_base, local_index >
 CMem_fast_ker< Memory, memory_traits_lin, int >
 Cmem_get< p, layout, data_type, g1_type, key_type, sel >Case memory_traits_lin
 Cmem_get< p, layout, data_type, g1_type, key_type, 1 >Case memory_traits_inte
 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_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_REDUCED, memory >This class is a container for the memory interface like HeapMemory CudaMemory
 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, layout_base, grow_p >
 Copenfpm::merge_prp_device_impl< true, T, Memory, layout, 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_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_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_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
 CMetis< Graph >Helper class to define Metis graph
 CMetis< Graph_CSR< nm_v, nm_e > >
 CMetis_graphMetis graph structure
 CMetisDistribution< dim, T >Class that distribute sub-sub-domains across processors using Metis Library
 Ccub::MinDefault min functor
 Cminus< arg, Sys_eqs >It ancapsulate the minus operation
 CModelCustomModel for Dynamic load balancing
 CModelCustom2Second model for dynamic load balancing
 CModelLinLinear model
 CModelSquareLinear model
 Cmp4_kernel< st >
 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
 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
 Cboost::detail::multi_array::multi_array_base_openfpm
 Ccub::Mutex
 Cmy_particle
 Cmy_struct
 CN_box< dim, T >
 CN_operation
 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
 CNN_gpu_it< dim, cnt_type, ids_type, r_int >
 CNN_gpu_it_radius< dim, cnt_type, ids_type >
 Cnn_prcs< dim, T >This class store the adjacent processors and the adjacent sub_domains
 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)>
 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_edgeClass with no edge
 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_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_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_op< 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_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_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_f< v_src, v_dst, prp >This class is a functor for "for_each" algorithm
 Cboost::ofp_storage_order
 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 >Helper class to merge data
 Cop_ssend_recv_merge_impl< sr, op >Helper class to merge data without serialization
 Cop_ssend_recv_merge_impl< true, op >Helper class to merge data with serialization
 Copenfpm::detail::multi_array::operator_arrow_proxy_openfpm< T >
 Cboost::detail::multi_array::operator_arrow_proxy_openfpm< T >
 CORB< dim, T, loc_wg, loc_pos, Box, Tree >This class implement orthogonal recursive bisection
 Cmemory_c< multi_array< T >, MEMORY_C_STANDARD, D >::ordering< index, N >In combination with generate_array is used to produce array at compile-time
 Cp_box< dim, T >It store all the boxes of the near processors in a linear array
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< cond, T1, Memory1, prp >Structures that do a nested packing, depending on the existence of 'pack' function inside of the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< cond, T1, Memory1, prp >Structures that do a nested packing, depending on the existence of 'pack' function inside of the object
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_cond< cond, T1, Memory1, prp >Structures that do a nested packing, depending on the existence of 'pack()' function inside the object
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_cond< true, T1, Memory1, prp... >Structures that do a nested packing, depending on the existence of 'pack()' function inside the object
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< true, T1, Memory1, prp... >Structures that do a nested packing, depending on the existence of 'pack' function inside of the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::pack_cond< true, T1, Memory1, prp... >Structures that do a nested packing, depending on the existence of 'pack' function inside of the object
 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, false >
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_simple_cond< sel, prp >These structures serialize a simple (no "pack()" inside) object
 Cgrid_base_impl< dim, T, S, layout_, layout_base >::pack_simple_cond< sel, prp >
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::pack_simple_cond< true, prp ... >These structures serialize a simple (no "pack()" inside) object
 Cgrid_base_impl< dim, T, S, layout_, layout_base >::pack_simple_cond< true, prp ... >
 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_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
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< cond, T1, prp >Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::packMem_cond< cond, T1 >Structures that calculate how many bytes are required to serialize an object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< cond, T1, prp >Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::packMem_cond< true, T1 >Structures that calculate memory for an object, depending on the existence of 'packMem()'
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< true, T1, prp... >Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packMem_cond< true, T1, prp... >Structures that calculate memory for an object, depending on the existence of 'packMem' function inside the object
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< cond, T1, prp >Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< cond, T1, prp >Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< true, T1, prp... >Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::packRequest_cond< true, T1, prp... >Structures that do a pack request, depending on the existence of 'packRequest' function inside of the object
 Ccub::AlignBytes< T >::Pad
 CParmetis< Graph >Helper class to define Metis graph
 CParmetis< Graph_CSR< nm_v, 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
 Cplus_t
 CPoint< dim, T >This class implement the point shape in an N-dimensional space
 CPoint2D_test< T >Test structure used for several test
 CPoint< 3, float >
 CPoint< dim, long int >
 CPoint< Grid::dims, St >
 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< 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_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_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
 Cpoisson_nn_helm
 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::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy110SM11
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy110SM11
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, 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::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy200SM20
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy200SM20
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy200SM20
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy200SM20
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy200SM20
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy200SM20
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy300SM30
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy300SM30
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy300SM30
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy300SM30
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy300SM30
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy300SM30
 Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy350SM35
 Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy350SM35
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy350SM35
 Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy350SM35
 Ccub::DispatchSpmv< ValueT, OffsetT >::Policy350SM35
 Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, 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 >
 Cboost::detail::multi_array::populate_index_ranges_openfpm
 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_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_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 >
 Ccub::PowerOfTwo< N >Statically determine if N is a power-of-two
 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
 Cprint_warning_on_adjustment< dim >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_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_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_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
 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
 Craw_read< dim, Tg >This class is a functor for "for_each" algorithm
 CredTemporal buffer for reductions
 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 >
 Ccub::CacheModifiedOutputIterator< MODIFIER, ValueType, OffsetT >::Reference
 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 >
 Creplace_< Tdst, Tsrc >This structure define the operation add to use with copy general
 CRGBRGB color struct
 Crid
 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
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::ScaleTransform
 Cscan< cnt_type, ids_type >
 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 >
 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
 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
 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, >
 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
 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
 Cskip_init< np, T >
 Cskip_init< true, T >
 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
 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
 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
 Cstencil_offset_compute< dim, Np >Structure for stencil iterator
 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 >
 Cstub_or_real< T, dims, stype, decomposition, stub >In case of testing return a stub grid
 Cstub_or_real< last, last::dims, typename last::stype, typename last::b_grid::decomposition::extended_type >
 Cstub_or_real< T, dims, stype, decomposition, false >Case when we are not on testing
 Cgrid_dist_iterator_sub< dim, device_grid >::sub_set
 Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::subarray< NDims >
 Cboost::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims >::subarray< NDims >
 Copenfpm::subarray_gen_openfpm< Array, N, vector >
 Cboost::subarray_gen_openfpm< Array, N >
 Csubsub< dim >Sub-sub-domain
 Csubsub_lin< dim >Linearized version of subsub
 Ccub::SumDefault sum functor
 Csum< expr >It model an expression expr1 + ... exprn
 Csum_functor_value< v_expr >Sum functor value
 Cswitch_copy_host_to_device< T_type, prp >This class is a functor for "for_each" algorithm
 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::TempStorage
 Ccub::WarpScanShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorageShared memory storage layout type
 Ccub::BlockHistogramAtomic< BINS >::TempStorageShared memory storage layout type
 Ctensor< T, s1, s2, s3 >
 Ctensor< int, s1, s2, s3 >
 Ctest_box_vpack
 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_boost_vmpl<>Terminator for to_boost_mpl with last parameter
 Cto_boost_vmpl_impl< a, id >Implementation of to_boost_vmpl
 Cto_boost_vmpl_impl< a >Terminator for to_boost_mpl with last parameter
 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_impl< H, c, end, exit >Recursive specialization of to_variadic
 Cto_variadic_impl< H, F, L, true >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
 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
 Ctrue_type
 Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::TScale< NOMINAL_ITEMS_PER_THREAD >
 Ctype
 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
 Cumfpack_solver< T >Stub when library compiled without eigen
 Cumfpack_solver< double >Stub when library compiled without eigen
 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< cub::KeyValuePair[WARPS]>
 Ccub::Uninitialized< ItemExchangeT >
 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< OuterScanArray >
 Cunordered_map
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< cond, T1, Memory1, prp >Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< cond, T1, Memory1, prp >Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< true, T1, Memory1, prp... >Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >::unpack_cond< true, T1, Memory1, prp... >Structures that do a nested unpacking, depending on the existence of 'pack' function inside the object
 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 >
 Cgrid_base_impl< dim, T, S, layout_, layout_base >::unpack_simple_cond< sel, prp >
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::unpack_simple_cond< sel, prp >These structures do an de-serialize a simple object (no pack() inside)
 Cgrid_base_impl< dim, T, S, layout_, layout_base >::unpack_simple_cond< true, prp ... >
 Copenfpm::vector< T, Memory, layout, layout_base, grow_p, OPENFPM_NATIVE >::unpack_simple_cond< true, prp ... >
 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 >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
 Cut_startBoost unit test fixation (start procedure to call before testing)
 Cv_box< vector >
 Cv_info
 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
 Copenfpm::detail::multi_array::value_accessor_generator_openfpm< T, NumDims, vector >
 Cboost::detail::multi_array::value_accessor_generator_openfpm< T, NumDims >
 CVcluster_base< InternalMemory >This class virtualize the cluster of PC as a set of processes that communicate
 CVcluster_base< Memory >
 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, layout_base, grow_p, impl >Implementation of 1-D std::vector like structure
 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< dim, T >, Memory, typename layout_base< aggregate< dim, T > >::type, layout_base >
 Copenfpm::vector< aggregate< int >, Memory >
 Copenfpm::vector< aggregate< int, int, int >, Memory, typename layout_base< aggregate< int, int, int > >::type, layout_base >
 Copenfpm::vector< aggregate< local_index >, Memory >
 Copenfpm::vector< aggregate< size_t >, HeapMemory >
 Copenfpm::vector< aggregate< unsigned int >, Memory, typename layout_base< aggregate< unsigned int > >::type, layout_base >
 Copenfpm::vector< aggregate< unsigned int, unsigned int >, Memory, typename layout_base< aggregate< unsigned int, unsigned int > >::type, layout_base >
 Copenfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, Memory, typename layout_base< aggregate< unsigned int, unsigned int, unsigned int > >::type, layout_base >
 Copenfpm::vector< aggregate< unsigned int, unsigned long int >, CudaMemory, typename memory_traits_inte< aggregate< unsigned int, unsigned long int > >::type, memory_traits_inte >
 Copenfpm::vector< AMG_time_err_coars >
 Copenfpm::vector< BMemory< HeapMemory >, HeapMemory, memory_traits_lin< BMemory< HeapMemory > >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >
 Copenfpm::vector< BMemory< InternalMemory >, HeapMemory, memory_traits_lin< BMemory< InternalMemory > >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >
 Copenfpm::vector< BMemory< Memory >, HeapMemory, memory_traits_lin< BMemory< Memory > >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >
 Copenfpm::vector< Box< dim, St >, Memory, typename layout_base< Box< dim, St > >::type, layout_base >
 Copenfpm::vector< Box< dim, T > >
 Copenfpm::vector< Box< dim, T >, Memory, typename layout_base< Box< dim, T > >::type, layout_base >
 Copenfpm::vector< Box_dom< dim, T > >
 Copenfpm::vector< Box_loc_sub< dim, T > >
 Copenfpm::vector< Box_sub< dim, T > >
 Copenfpm::vector< Box_sub_k< dim, T > >
 Copenfpm::vector< cell_grid< Grid > >
 Cstd::vector< comb< 0 > >Stub vector specialization
 Copenfpm::vector< comb< dim > >
 Copenfpm::vector< const Grid * >
 Copenfpm::vector< const void * >
 Copenfpm::vector< device_grid >
 Copenfpm::vector< DistGraph_CSR::EdgeReq >
 Copenfpm::vector< DistGraph_CSR::SendGraphPack >
 Copenfpm::vector< E >
 Copenfpm::vector< E, HeapMemory, typename memory_traits_lin< E >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< E >::value >
 Copenfpm::vector< E, Memory, layout_e, layout_e_base, grow_p, openfpm::vect_isel< E >::value >
 Copenfpm::vector< e_box_id< dim > >
 Copenfpm::vector< e_info >
 Copenfpm::vector< e_info, HeapMemory, typename memory_traits_lin< e_info >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< e_info >::value >
 Copenfpm::vector< e_info, Memory, typename layout_e_base< e_info >::type, layout_e_base, grow_p, openfpm::vect_isel< e_info >::value >
 Copenfpm::vector< e_lbox_grid< dim > >
 Copenfpm::vector< e_lbox_id< dim > >
 Copenfpm::vector< e_map, HeapMemory, typename memory_traits_lin< e_map >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< e_map >::value >
 Copenfpm::vector< e_map, Memory, typename layout_e_base< e_map >::type, layout_e_base, grow_p, openfpm::vect_isel< e_map >::value >
 Copenfpm::vector< e_map, Memory, typename memory_traits_lin< e_map >::type, layout_e_base, grow_p, 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< grid_cpu< dim, aggregate< size_t > > ::dims > >
 Copenfpm::vector< GGraph >
 Copenfpm::vector< grid_cpu< dim, aggregate< size_t > > >
 Copenfpm::vector< grid_dist_id_iterator_dec_skin::gp_sub >
 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, T > >
 Copenfpm::vector< lid >
 Copenfpm::vector< long >
 Copenfpm::vector< long int >
 Copenfpm::vector< Memory, HeapMemory, memory_traits_lin< Memory >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >
 Copenfpm::vector< met_sub_w >
 Copenfpm::vector< MPI_Request >
 Copenfpm::vector< MPI_Status >
 Copenfpm::vector< nm_e, HeapMemory, typename memory_traits_lin< nm_e >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< nm_e >::value >
 Copenfpm::vector< nm_v, HeapMemory, typename memory_traits_lin< nm_v >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< nm_v >::value >
 Copenfpm::vector< openfpm::vector >
 Copenfpm::vector< openfpm::vector< aggregate< device_grid, SpaceBox< dim, long int > > > >
 Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, aggregate< size_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, T > > >
 Copenfpm::vector< openfpm::vector< gid > >
 Copenfpm::vector< openfpm::vector< idx_t > >
 Copenfpm::vector< openfpm::vector< long unsigned int > >
 Copenfpm::vector< openfpm::vector< size_t > >
 Copenfpm::vector< openfpm::vector< SpaceBox< dim, T > > >
 Copenfpm::vector< p_box< dim, T > >
 Copenfpm::vector< PetscInt >
 Copenfpm::vector< PetscScalar >
 Copenfpm::vector< Point< dim, St >, Memory, typename layout_base< Point< dim, St > >::type, layout_base >
 Copenfpm::vector< Point< dim, T >, Memory, typename layout_base< Point< dim, T > >::type, layout_base >
 Copenfpm::vector< pos_v< typename Cell::internal_vector_pos_type > >
 Copenfpm::vector< prop, Memory, typename layout_base< prop >::type, layout_base >
 Copenfpm::vector< rid >
 Copenfpm::vector< rval< PetscScalar, PETSC_RVAL >, HeapMemory, typename memory_traits_inte< rval< PetscScalar, PETSC_RVAL > >::type, memory_traits_inte >
 Copenfpm::vector< rval< T, EIGEN_RVAL > >
 Copenfpm::vector< send_vector >
 Copenfpm::vector< size_t >
 Copenfpm::vector< size_t, HeapMemory, typename memory_traits_lin< size_t >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< size_t >::value >
 Copenfpm::vector< size_t, Memory, typename layout_v_base< size_t >::type, layout_v_base, grow_p, openfpm::vect_isel< size_t >::value >
 Copenfpm::vector< solv_bench_info >
 Copenfpm::vector< SpaceBox< dim, size_t > >
 Copenfpm::vector< SpaceBox< dim, T > >
 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, typename memory_traits_inte< aggregate< T > >::type, memory_traits_inte, grow_policy_double, STD_VECTOR >Implementation of 1-D std::vector like structure
 CVector< T, EIGEN_BASE >
 Copenfpm::vector< T, HeapMemory, memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >
 Cvector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >Implementation of 1-D std::vector like structure
 Copenfpm::vector< T, HeapMemory, typename memory_traits_lin< T >::type, memory_traits_lin, grow_policy_double, STD_VECTOR >Implementation of 1-D std::vector like structure
 Copenfpm::vector< T, Memory, layout, 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, typename memory_traits_lin< T >::type, memory_traits_lin, gp, STD_VECTOR >
 Copenfpm::vector< T, PtrMemory, typename memory_traits_lin< T >::type, 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, typename layout_base< typename sT::value_type >::type, layout_base, openfpm::grow_policy_identity >
 Copenfpm::vector< V >
 Copenfpm::vector< V, HeapMemory, typename memory_traits_lin< V >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< V >::value >
 Copenfpm::vector< V, Memory, layout_v, layout_v_base, grow_p, openfpm::vect_isel< V >::value >
 Copenfpm::vector< v_box< vector > >
 Copenfpm::vector< v_info >
 Copenfpm::vector< v_info, HeapMemory, typename memory_traits_lin< v_info >::type, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< v_info >::value >
 Copenfpm::vector< v_info, Memory, typename memory_traits_lin< v_info >::type, memory_traits_lin, grow_p, 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_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_op< exp1, exp2, op >Unknown operation specialization
 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_SIM >Apply kernel operation
 Cvector_dist_expression_op< exp1, vector_type, VECT_SUM_REDUCE >Expression that encapsulate a vector reduction expression
 Cvector_dist_expression_op< exp1, void, VECT_SUB_UNI >It take an expression and create the negatove of this expression
 Cvector_dist_iteratorIterator that Iterate across particle indexes
 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< dim, T >, layout_base >
 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< unsigned int, unsigned int, unsigned int >, layout_base >
 Copenfpm::vector_gpu_ker< Box< dim, T >, layout_base >
 Copenfpm::vector_key_iteratorVector iterator
 Copenfpm::vector_key_iterator_seq< lid >Vector iterator
 CVerletBase
 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
 CVoid< 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 >