Ccub::AgentHistogram< AgentHistogramPolicyT, PRIVATIZED_SMEM_BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, PrivatizedDecodeOpT, OutputDecodeOpT, OffsetT, PTX_ARCH >::_TempStorage | Shared memory type required by this thread block |
Ccub::AgentReduce< AgentReducePolicy, InputIteratorT, OutputIteratorT, OffsetT, ReductionOp >::_TempStorage | Shared memory type required by this thread block |
Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::_TempStorage | |
Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage | |
Ccub::AgentScan< AgentScanPolicyT, InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::_TempStorage | |
Ccub::AgentSegmentFixup< AgentSegmentFixupPolicyT, PairsInputIteratorT, AggregatesOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::_TempStorage | |
Ccub::AgentSelectIf< AgentSelectIfPolicyT, InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::_TempStorage | |
Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::_TempStorage | Shared memory type required by this thread block |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type (last element from each thread's input) |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared 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 >::_TempStorage | Shared memory |
Ccub::BlockRadixSort< KeyT, BLOCK_DIM_X, ITEMS_PER_THREAD, ValueT, RADIX_BITS, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::BlockReduceRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::BlockReduceRakingCommutativeOnly< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::BlockReduceWarpReductions< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::BlockScanRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, MEMOIZE, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::BlockShuffle< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage | Shared memory storage layout type (last element from each thread's input) |
Ccub::TilePrefixCallbackOp< T, ScanOpT, ScanTileStateT, PTX_ARCH >::_TempStorage | |
Ccub::WarpExchange< T, ITEMS_PER_THREAD, LOGICAL_WARP_THREADS, PTX_ARCH >::_TempStorage | Shared memory storage layout type |
Ccub::WarpReduceSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >::_TempStorage | Shared memory storage layout type (1.5 warps-worth of elements for each warp) |
Cgrid_dist_amr_key_iterator< dim, device_grid, device_sub_it, it_type >::actual_it | Actual it type |
CAdaptiveCylinderCone< dim, T > | This class represent an Adaptive cylinder cone |
Cadd_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
Cadd_atomic_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
Cadd_const_reference< T, is_reference > | |
Cadd_const_reference< T, true > | |
Cadd_const_reference< vector_orig > | |
Copenfpm::add_prp_device_impl< is_ok_cuda, T, Memory, layout_base, grow_p > | |
Copenfpm::add_prp_device_impl< true, T, Memory, layout_base, grow_p > | |
Cadd_prp_impl< objv, vect_dst > | Struct to merge two vectors |
Cadd_prp_impl< OBJECT_ADD, vect_dst > | Struct to merge two vectors |
CAexample | Example 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::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::PtxHistogramSweepPolicy | |
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::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::PtxReduceByKeyPolicy | |
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::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::PtxRleSweepPolicy | |
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::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::PtxAgentScanPolicy | |
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::DispatchSpmv< ValueT, OffsetT >::PtxSegmentFixupPolicy | |
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::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::PtxSelectIfPolicyT | |
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 |
Ccub::DispatchSpmv< ValueT, OffsetT >::PtxSpmvPolicyT | |
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 > | |
CORB_node< T > | ORB node |
Caggregate< vector_dist_expression< double > > | |
Caggregate< vector_dist_expression< double >, vector_dist_expression< double > > | |
Caggregate< vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double > > | |
Caggregate< vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double > > | |
Caggregate< vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double >, vector_dist_expression< double > > | |
Caggregate_add< aggr > | |
Caggregate_add< aggregate< types ... > > | |
Caggregate_bfv< T > | An aggregate that accept a boost fusion vector as type |
Caggregate_convert< dim, blockEdgeSize, aggr > | |
Caggregate_convert< dim, blockEdgeSize, aggregate< types ... > > | |
Caggregate_or_known_type< layout_base, T, impl, args > | |
Caggregate_or_known_type< layout_base, T, 2, args ... > | |
Caggregate_or_known_type< layout_base, T, 4, args ... > | |
Caggregate_transform_datablock_impl< dim, blockEdgeSize, aggr_list > | |
CAggregateAppend< BlockT, T > | |
CAggregateAppend< BlockT, aggregate< list ... > > | |
CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type > | |
CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1]> | |
CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1][N2]> | |
CAlgoimWrapper< wrapping_field, grid_type, wrapping_field_type[N1][N2][N3]> | |
Ccub::AgentHistogram< AgentHistogramPolicyT, PRIVATIZED_SMEM_BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, PrivatizedDecodeOpT, OutputDecodeOpT, OffsetT, PTX_ARCH >::_TempStorage::Aliasable | |
Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage::Aliasable | |
Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::_TempStorage::Aliasable | |
Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::_TempStorage::Aliasable | |
►Ccub::AlignBytes< T > | Structure alignment |
Ccub::AlignBytes< const T > | |
Ccub::AlignBytes< const volatile T > | |
Ccub::AlignBytes< volatile T > | |
Callocate< S > | This class is a functor for "for_each" algorithm |
Calpa_base_structs | |
CAMG_time_err_coars | It contain information about the performance of the AMG |
Camr_launch_sparse | |
Canyname_field | [Constant fields struct definition] |
Canyname_field_with_pos | Define a non-constant (in space) field |
Capply_kernel_is_number_or_expression< impl, T, vector, exp, NN_type, Kernel, rtype, is_exp > | Apply the kernel to particle differently that is a number or is an expression |
Capply_kernel_is_number_or_expression_gen< impl, T, vector, exp, NN_type, Kernel, rtype, is_exp > | Apply the kernel to particle differently that is a number or is an expression |
Capply_kernel_is_number_or_expression_sim< impl, vector, exp, NN_type, Kernel, rtype > | Apply the kernel to particle differently that is a number or is an expression |
Capply_kernel_rtype< exp, is_exp > | It give the return type of the expression if applicable |
Capply_kernel_rtype< exp, false > | It give the return type of the expression if applicable |
Capply_transform< layout_base, T > | |
Capply_trasform_impl< layout_base, T, args > | |
Capply_trasform_impl< layout_base, T, boost::fusion::vector< args... > > | |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, HAS_PARAM > | Specialization for when FlagOp has third index param |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, HAS_PARAM > | Specialization for when FlagOp has third index param |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, false > | Specialization for when FlagOp does not have a third index param |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::ApplyOp< FlagOp, false > | Specialization for when FlagOp does not have a third index param |
Ccub::ArgIndexInputIterator< InputIteratorT, OffsetT, OutputValueT > | A random-access input wrapper for pairing dereferenced values with their corresponding indices (forming KeyValuePair tuples) |
Ccub::ArgMax | Arg max functor (keeps the value and offset of the first occurrence of the larger item) |
Ccub::ArgMin | Arg min functor (keeps the value and offset of the first occurrence of the smallest item) |
Carr_arr_ptr< n_it, n_prp > | |
Carr_arr_ptr< 1, sizeof...(prp)> | |
Carr_arr_ptr< n_it, sizeof...(prp)> | |
Carr_ptr< n_it > | |
Copenfpm::array< T, N, ids_type > | |
Copenfpm::array< ids_type, dim, cnt_type > | |
Copenfpm::array< index, NumDims > | |
Copenfpm::array< size_type, NumDims > | |
Copenfpm::array< T, 0 > | |
Copenfpm::array< T, dim, cnt_type > | |
Carray_asc< dim > | |
Carray_asc< 2 > | |
Carray_asc< 3 > | |
Carray_asc< 4 > | |
Carray_extents< T > | Struct that give functionalities on array extensions |
Carray_extents< T[N1]> | Struct that give functionalities on array extensions |
Carray_extents< T[N1][N2]> | Struct that give functionalities on array extensions |
Carray_extents< T[N1][N2][N3]> | Struct that give functionalities on array extensions |
Cboost::array_openfpm< T, N, ids_type > | |
Cboost::array_openfpm< T, 0 > | |
Carray_ord< dim, size_type > | |
Carray_ord< 2, size_type > | |
Carray_ord< 3, size_type > | |
Carray_ord< 4, size_type > | |
Carray_to_vmpl< T > | Partial specialization for scalar N=0 |
Carray_to_vmpl< T[N1]> | Partial specialization for N=1 |
Carray_to_vmpl< T[N1][N2]> | Partial specialization for N=2 |
Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vector, TPtr >::array_view< NDims > | |
Copenfpm::detail::multi_array::sub_array_openfpm< T, NumDims, vector >::array_view< NDims > | |
Copenfpm::array_view_gen_openfpm< Array, N > | |
Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector >::array_view_openfpm< NDims > | |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::array_view_openfpm< NDims > | |
Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims >::array_view_openfpm< NDims > | |
CArrayHolder< T, args > | Array itself |
CArrayHolder_constexpr< T, args > | Array itself |
CArrayHolder_indexes< T, args > | Array itself |
CArrayWrapper< BaseT > | |
Ccub::ArrayWrapper< T, COUNT > | A wrapper for passing simple static arrays as kernel parameters |
CArrayWrapper< BaseType[N1]> | |
CArrayWrapper< BaseType[N1][N2]> | |
Cas_array_nnc< dim > | Set a dimension threshold |
Cmemory_c< multi_array< T >, MEMORY_C_STANDARD, D >::ascending< index, N > | In combination with generate_array is used to produce array at compile-time |
Cat_impl< vector, p, bool > | |
Cat_impl< vector, p, true > | |
Ced::attributes | Attributes name |
Cne_cp::attributes | Define attributes names |
Cnm_e::attributes | Attributes name |
Cnm_part_e::attributes | Attributes name |
Cnm_part_v::attributes | Attributes name |
Cnm_v< dim >::attributes | Attributes name |
Cnode_cp::attributes | Attributes name |
CPoint_test_prp< T >::attributes | Attributes name |
CPoint_test_scal< T >::attributes | Attributes name |
Ctest_has_attributes::attributes | Define attribute names |
Cvertex2::attributes | Attributes name |
Cvertex3::attributes | Attributes name |
Cvertex::attributes | Attributes name |
Cvx::attributes | Attributes name |
CAvg< d, Field, Sys_eqs, impl > | Average |
CAvg< d, arg, Sys_eqs, BACKWARD > | First order BACKWARD derivative on direction i |
CAvg< d, arg, Sys_eqs, CENTRAL > | Central average scheme on direction i |
CAvg< d, arg, Sys_eqs, FORWARD > | FORWARD average on direction i |
Cb_cast_helper< is_lin_or_inte > | |
Cb_cast_helper< false > | |
Cbase_copy< has_base, base_obj, v_obj > | |
Cbase_copy< true, base_obj, v_obj > | |
CVcluster< InternalMemory >::base_info< Memory > | Base info |
CVcluster< InternalMemory >::base_info< HeapMemory > | |
►Ccub::BaseTraits< _CATEGORY, _PRIMITIVE, _NULL_TYPE, _UnsignedBits, T > | Basic type traits |
►Ccub::NumericTraits< RemoveQualifiers< T >::Type > | |
Ccub::Traits< T > | Type traits |
Ccub::BaseTraits< FLOATING_POINT, true, false, _UnsignedBits, T > | |
►Ccub::BaseTraits< FLOATING_POINT, true, false, unsigned int, float > | |
Ccub::NumericTraits< float > | |
►Ccub::BaseTraits< FLOATING_POINT, true, false, unsigned long long, double > | |
Ccub::NumericTraits< double > | |
Ccub::BaseTraits< NOT_A_NUMBER, false, false, RemoveQualifiers< T >::Type, RemoveQualifiers< T >::Type > | |
►Ccub::BaseTraits< NOT_A_NUMBER, false, false, T, T > | |
Ccub::NumericTraits< T > | Numeric type traits |
►Ccub::BaseTraits< NOT_A_NUMBER, false, true, NullType, NullType > | |
Ccub::NumericTraits< NullType > | |
Ccub::BaseTraits< SIGNED_INTEGER, true, false, _UnsignedBits, T > | |
►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned char, signed char > | |
Ccub::NumericTraits< signed char > | |
►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned int, int > | |
Ccub::NumericTraits< int > | |
►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned long long, long long > | |
Ccub::NumericTraits< long long > | |
►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned long, long > | |
Ccub::NumericTraits< long > | |
►Ccub::BaseTraits< SIGNED_INTEGER, true, false, unsigned short, short > | |
Ccub::NumericTraits< short > | |
Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, _UnsignedBits, T > | |
►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, UnitWord< bool >::VolatileWord, bool > | |
Ccub::NumericTraits< bool > | |
►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned char, unsigned char > | |
Ccub::NumericTraits< unsigned char > | |
►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned int, unsigned int > | |
Ccub::NumericTraits< unsigned int > | |
►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned long long, unsigned long long > | |
Ccub::NumericTraits< unsigned long long > | |
►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned long, unsigned long > | |
Ccub::NumericTraits< unsigned long > | |
►Ccub::BaseTraits< UNSIGNED_INTEGER, true, false, unsigned short, unsigned short > | |
Ccub::NumericTraits< unsigned short > | |
►Ccub::BaseTraits<(std::numeric_limits< char >::is_signed) ? SIGNED_INTEGER :UNSIGNED_INTEGER, true, false, unsigned char, char > | |
Ccub::NumericTraits< char > | |
Cbcast_inte_impl< vect > | This class is a functor for "for_each" algorithm |
Cbest_conv< source1, source2 > | |
Cbest_conv_impl< source1, source2 > | |
Cbest_conv_impl< int, source2 > | |
Cbest_conv_impl< long int, source2 > | |
Cbest_conv_impl< source1, int > | |
Cbest_conv_impl< source1, long int > | |
Cbest_conv_impl< source1, unsigned int > | |
Cbest_conv_impl< source1, unsigned long int > | |
Cbest_conv_impl< unsigned int, source2 > | |
Cbest_conv_impl< unsigned long int, source2 > | |
►Cstd::binary_function | |
►Cgpu::maximum_t< red_type > | |
C_max_< red_type > | |
►Cgpu::plus_t< red_type > | |
C_add_< red_type > | |
Cgpu::equal_to_t< type_t > | |
Cgpu::greater_equal_t< type_t > | |
Cgpu::greater_t< type_t > | |
Cgpu::less_equal_t< type_t > | |
Cgpu::less_t< type_t > | |
Cgpu::maximum_t< type_t > | |
Cgpu::minimum_t< type_t > | |
Cgpu::minus_t< type_t > | |
Cgpu::multiplies_t< type_t > | |
Cgpu::not_equal_to_t< type_t > | |
Cgpu::plus_t< type_t > | |
Ckey_equal | Structure required for the Sph Harmonic amplitude dictionary arguments |
CleftOperand_t< type_t > | |
CrightOperand_t< type_t > | |
Ccub::BinaryOpHasIdxParam< T, BinaryOp > | Determine whether or not BinaryOp's functor is of the form bool operator()(const T& a, const T&b) or bool operator()(const T& a, const T&b, unsigned int idx) |
Cbisect_unroll< dim, ORB > | This class is a functor for "for_each" algorithm |
Cblock_offset< indexT > | |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | |
Ccub::CachingDeviceAllocator::BlockDescriptor | |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockDiscontinuity class provides collective methods for flagging discontinuities within an ordered set of items partitioned across a CUDA thread block |
Ccub::BlockExchange< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, WARP_TIME_SLICING, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockExchange class provides collective methods for rearranging data partitioned across a CUDA thread block |
Ccub::BlockHistogram< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockHistogram class provides collective methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block |
Ccub::BlockHistogramAtomic< BINS > | The BlockHistogramAtomic class provides atomic-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block |
Ccub::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockHistogramSort class provides sorting-based methods for constructing block-wide histograms from data samples partitioned across a CUDA thread block |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockLoad class provides collective data movement methods for loading a linear segment of items from memory into a blocked arrangement across a CUDA thread block |
►CBlockMapGpu< AggregateBlockT, threadBlockSize, indexT, layout_base > | |
CSparseGridGpu< dim, AggregateT, blockEdgeSize, threadBlockSize, indexT, layout_base, linearizer > | |
CBlockMapGpu< aggregate_convert< dim, default_edge< dim >::type::value, AggregateT >::type, default_edge< dim >::tb::value, long int, memory_traits_inte > | |
CBlockMapGpu_ker< AggregateBlockT, indexT, layout_base > | |
►CBlockMapGpu_ker< AggregateBlockT, indexT, layout_base > | |
CSparseGridGpu_ker< dim, blockEdgeSize, AggregateBlockT, ct_params, indexT, layout_base, GridSmT, linearizer, BcT > | |
Ccub::BlockRadixRank< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | BlockRadixRank provides operations for ranking unsigned integer types within a CUDA thread block |
Ccub::BlockRadixRankMatch< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, INNER_SCAN_ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | |
Ccub::BlockRadixSort< KeyT, BLOCK_DIM_X, ITEMS_PER_THREAD, ValueT, RADIX_BITS, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockRadixSort class provides collective methods for sorting items partitioned across a CUDA thread block using a radix sorting method |
Ccub::BlockRakingLayout< T, BLOCK_THREADS, PTX_ARCH > | BlockRakingLayout provides a conflict-free shared memory layout abstraction for 1D raking across thread block data |
Ccub::BlockReduce< T, BLOCK_DIM_X, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockReduce class provides collective methods for computing a parallel reduction of items partitioned across a CUDA thread block |
Ccub::BlockReduceRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | BlockReduceRaking provides raking-based methods of parallel reduction across a CUDA thread block. Supports non-commutative reduction operators |
Ccub::BlockReduceRakingCommutativeOnly< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | BlockReduceRakingCommutativeOnly provides raking-based methods of parallel reduction across a CUDA thread block. Does not support non-commutative reduction operators. Does not support block sizes that are not a multiple of the warp size |
Ccub::BlockReduceWarpReductions< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | BlockReduceWarpReductions provides variants of warp-reduction-based parallel reduction across a CUDA thread block. Supports non-commutative reduction operators |
Ccub::BlockScan< T, BLOCK_DIM_X, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockScan class provides collective methods for computing a parallel prefix sum/scan of items partitioned across a CUDA thread block |
Ccub::BlockScanRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, MEMOIZE, PTX_ARCH > | BlockScanRaking provides variants of raking-based parallel prefix scan across a CUDA thread block |
Ccub::BlockScanRunningPrefixOp< T, ScanOpT > | < Wrapped scan operator type |
Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | BlockScanWarpScans provides warpscan-based variants of parallel prefix scan across a CUDA thread block |
Ccub::BlockShuffle< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockShuffle class provides collective methods for shuffling data partitioned across a CUDA thread block |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH > | The BlockStore class provides collective data movement methods for writing a blocked arrangement of items partitioned across a CUDA thread block to a linear segment of memory |
CBoundaryStencilSetX< dim, p_src, p_dst > | |
CBoundaryStencilSetXRescaled< dim, p_src, p_dst, ScalarT > | |
►CBox< dim, T > | This class represent an N-dimensional box |
►CGhost< dim, long int > | |
CPadding< Sys_eqs::dims > | |
CPadding< dim > | Class that contain Padding information on each direction positive and Negative direction |
CGhost< dim, St > | |
CGhost< dim, typename Sys_eqs::stype > | |
CGhost< dim, typename grid_in_type::stype > | |
CGhost< dim, typename last::stype > | |
CSpaceBox< dim, size_t > | |
CSpaceBox< dim, St > | |
CSpaceBox< dim, typename grid_in_type::stype > | |
CGhost< dim, T > | |
CSpaceBox< dim, T > | This class represent an N-dimensional box |
CBox< 3, float > | |
CBox< Decomposition::dims, typename Decomposition::stype > | |
CBox< dim, dT > | |
CBox< dim, int > | |
CBox< dim, long int > | |
►CBox< dim, size_t > | |
Cwavefront< dim > | This class represent a wavefront of dimension dim |
CBox< dim, St > | |
CBox< dim, typename grid_in_type::stype > | |
CBox< dim, typename last::stype > | |
CBox< dim, typename Sys_eqs::stype > | |
CBox< grid::dims, size_t > | |
CBox< Grid::dims, size_t > | |
CBox< N, size_t > | |
CBox< SparseGridType::dims, size_t > | |
CBox< vector::dims, size_t > | |
CBox< vector::dims, typename vector::stype > | |
CBox_check< dim, T > | |
CBox_dom< dim, T > | Case for external ghost box |
CBox_fix< dim > | Internal ghost box sent to construct external ghost box into the other processors |
CCartDecomposition< dim, T, Memory, layout_base, Distribution >::box_id | Class to select the returned id by ghost_processorID |
CBox_loc_sub< dim, T > | For each sub-domain box sub contain the real the sub-domain id |
CBox_proc< dim, T > | Case for local external ghost box |
CBox_sub< dim, T > | |
CBox_sub_k< dim, T > | Particular case for local internal ghost boxes |
Cinterpolate< vector, grid, kernel >::Box_vol | |
CBoxDistribution< dim, T > | Class that distribute sub-sub-domains across processors using Metis Library |
Cbrt_test | |
Cbump< dim > | |
Copenfpm::c_storage_order | |
Ccub::CacheModifiedInputIterator< MODIFIER, ValueType, OffsetT > | A random-access input wrapper for dereferencing array values using a PTX cache load modifier |
Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::COLUMN_INDICES_LOAD_MODIFIER, OffsetT, OffsetT > | |
Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::ROW_OFFSETS_LOAD_MODIFIER, OffsetT, OffsetT > | |
Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::VALUES_LOAD_MODIFIER, ValueT, OffsetT > | |
Ccub::CacheModifiedInputIterator< AgentSpmvPolicyT::VECTOR_VALUES_LOAD_MODIFIER, ValueT, OffsetT > | |
Ccub::CacheModifiedInputIterator< LOAD_MODIFIER, UnsignedBits, OffsetT > | |
Ccub::CacheModifiedInputIterator< LOAD_MODIFIER, ValueT, OffsetT > | |
Ccub::CacheModifiedOutputIterator< MODIFIER, ValueType, OffsetT > | A random-access output wrapper for storing array values using a PTX cache-modifier |
Ccub::CachingDeviceAllocator | A simple caching allocator for device memory allocations |
Ccalculate_aint< dims, vector, np > | Calculate aint |
Ccalculate_aint< 2, vector, np > | Calculate aint 2D |
Ccalculate_aint< 3, vector, np > | Calculate aint |
CCalcVelocity< DX, DY, DXX, DXY, DYY > | |
Ccall_aggregatePack< obj_type, Mem, prp > | Calls a packer in nested way |
Ccall_aggregatePackRequest< obj_type, Mem, prp > | |
Ccall_aggregatePackRequestChunking< obj_type, Mem, prp > | |
Ccall_aggregateUnpack< obj_type, Mem, prp > | Calls an unpacker in nested way |
Ccall_encapPack< encap, Mem, prp > | |
Ccall_encapPackChunking< encap, Mem, prp > | |
Ccall_encapPackRequest< encap, Mem, prp > | |
Ccall_encapUnpack< encap, Mem, prp > | |
Ccall_encapUnpackChunking< encap, Mem, prp > | |
Ccall_init_if_needed< T, has_init > | Call the init function if a type T has the function init |
Ccall_init_if_needed< T, false > | Call the init function if a type T has the function init |
Ccall_pack_agg_functor< obj_type, Mem > | |
Ccall_pack_enc_functor< encap, Mem > | |
Ccall_pack_enc_functor_chunking< encap, Mem > | |
Ccall_pack_enc_functor_chunking_impl_arr< Timp > | |
Ccall_pack_enc_functor_chunking_impl_arr< Timp[N1]> | |
Ccall_packRequest_agg_functor< obj_type, Mem > | |
Ccall_packRequest_agg_functor_cnk< obj_type, Mem > | |
Ccall_packRequest_enc_functor< encap, Mem > | |
Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, is_vector > | |
Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 0 > | |
Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 3 > | |
Ccall_recursive_destructor_if_vector< T, T_ker, type_prp, layout_base, 4 > | |
Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, is_vector > | |
Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 0 > | |
Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 3 > | |
Ccall_recursive_host_device_if_vector< T, T_ker, type_prp, layout_base, 4 > | |
Ccall_serialize_variadic< T > | |
Ccall_serialize_variadic< index_tuple< prp... > > | |
Ccall_unpack_agg_functor< obj_type, Mem > | |
Ccall_unpack_encap_functor< encap, Mem, prp > | |
Ccall_unpack_encap_functor_chunking< encap, Mem, prp > | |
Ccall_unpack_encap_functor_chunking_array_selector< T > | |
Ccall_unpack_encap_functor_chunking_array_selector< T[N1]> | |
CCartesianGraphFactory< dim, Graph > | This class construct a cartesian graph |
Ccub::CastOp< B > | Default cast functor |
Ccell_grid< Grid > | For each combination in the cell grid you can have different grids |
Ccell_list_selector< vector, impl > | |
Ccell_list_selector< vector, comp_host > | |
►CCellDecomposer_gpu_ker< dim, T, cnt_type, ids_type, transform > | |
CCellList_gpu_ker< dim, T, cnt_type, ids_type, transform, is_sparse > | |
CCellList_gpu_ker< dim, T, cnt_type, ids_type, transform, true > | |
►CCellDecomposer_sm | |
CCellList< dim, T, Mem_fast< HeapMemory, int >, shift< dim, T > > | |
CCellList< dim, St, Mem_fast< Memory, int >, shift< dim, St > > | |
CCellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > | |
CCellList< dim, typename grid_in_type::stype, Mem_fast< Memory, int >, shift< dim, typename grid_in_type::stype > > | |
CCellList< dim, T, Mem_fast< HeapMemory, typename Mem_type::local_index_type >, no_transform< dim, T >, openfpm::vector< Point< dim, T > > > | |
CCellList< vector::dims, typename vector::stype, Mem_fast<>, shift< vector::dims, typename vector::stype > > | |
CCellList< dim, T, Mem_type, transform, vector_pos_type > | Class for FAST cell list implementation |
►CCellIterator< Cell > | It iterate through the elements of a cell |
CCellIteratorM< Cell, sh_byte > | It iterate through the elements of a cell |
►CCellList< dim, T, Mem_fast<>, no_transform< dim, T >, openfpm::vector< Point< dim, T > > > | |
CCellList_gen< dim, T, Prock, Mem_type, transform, vector_pos_type > | |
►CCellList< dim, T, Mem_fast<>, shift< dim, T > > | |
CCellListM< dim, T, sh_byte, CellBase > | Class for Multi-Phase cell-list |
►CCellNNIterator< dim, Cell, NNc_size, impl > | Iterator for the neighborhood of the cell structures |
CCellNNIteratorM< dim, Cell, sh_byte, NNc_size, impl > | Iterator for the neighborhood of the cell structures |
CCellNNIteratorSym< dim, Cell, vector_pos_type, NNc_size, impl > | Symmetric iterator for the neighborhood of the cell structures |
CCellNNIteratorSymM< dim, Cell, sh_byte, NNc_size, impl > | Iterator for the neighborhood of the cell structures |
CCellNNIteratorSymMP< dim, Cell, vector_pos_type, NNc_size, impl > | Symmetric iterator for the neighborhood of the cell structures |
►CCellNNIterator< dim, Cell, RUNTIME, impl > | Iterator for the neighborhood of the cell structures |
CCellNNIteratorM< dim, Cell, sh_byte, RUNTIME, impl > | Iterator for the neighborhood of the cell structures |
CCellNNIteratorSym< dim, Cell, vector_pos_type, RUNTIME, impl > | Symmetric iterator for the neighborhood of the cell structures |
CCellNNIteratorSymM< dim, Cell, sh_byte, RUNTIME, impl > | Symmetric 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::DeviceReducePolicy< OuputT, OffsetT, ReductionOpT >::Policy130 | SM13 |
►Ccub::ChainedPolicy< 200, Policy200, Policy130 > | |
Ccub::DeviceReducePolicy< OuputT, OffsetT, ReductionOpT >::Policy200 | SM20 |
►Ccub::ChainedPolicy< 200, Policy200, Policy200 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy200 | SM20 |
►Ccub::ChainedPolicy< 300, Policy300, Policy200 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy300 | SM30 |
Ccub::DeviceReducePolicy< OuputT, OffsetT, ReductionOpT >::Policy300 | SM30 |
►Ccub::ChainedPolicy< 350, Policy350, Policy300 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy350 | SM35 |
Ccub::DeviceReducePolicy< OuputT, OffsetT, ReductionOpT >::Policy350 | SM35 |
►Ccub::ChainedPolicy< 500, Policy500, Policy350 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy500 | SM50 |
►Ccub::ChainedPolicy< 600, Policy600, Policy350 > | |
Ccub::DeviceReducePolicy< OuputT, OffsetT, ReductionOpT >::Policy600 | SM60 |
►Ccub::ChainedPolicy< 600, Policy600, Policy500 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy600 | SM60 (GP100) |
►Ccub::ChainedPolicy< 610, Policy610, Policy600 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy610 | SM61 (GP104) |
►Ccub::ChainedPolicy< 620, Policy620, Policy610 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy620 | SM62 (Tegra, less RF) |
►Ccub::ChainedPolicy< 700, Policy700, Policy620 > | |
Ccub::DeviceRadixSortPolicy< KeyT, ValueT, OffsetT >::Policy700 | SM70 (GV100) |
Ccub::ChainedPolicy< PTX_VERSION, PolicyT, PolicyT > | Helper for dispatching into a policy chain (end-of-chain specialization) |
Ccheader< dim > | This structure contain the information of a chunk |
Ccheck_all_apply_ker< impl > | |
Ccheck_all_apply_ker< comp_dev > | |
Ccheck_all_apply_ker_sort | |
Ccheck_all_expressions< impl > | |
Ccheck_all_expressions< comp_dev > | |
Ccheck_device_ptr< data_type > | This class is a functor for "for_each" algorithm |
Ccheck_nan< T > | |
Ccheck_nan< double > | |
Ccheck_nan< float > | |
Ccheck_no_pointers< T > | This class check if the type T has pointers inside |
Ccheck_no_pointers_impl< T, has_pointer > | Check if the type T has pointers inside |
Ccheck_no_pointers_impl< T, false > | Check if the type T has pointers inside |
Ccheck_type< T, type_of_t > | |
Ccheck_type< T, 1 > | |
Ccheck_types< v > | Functor for for_each algorithm |
CCheckExistence | Class to check if the edge can be created or not |
Copenfpm::detail::multi_array::choose_value_accessor_n_openfpm< T, NumDims, vector > | |
Copenfpm::detail::multi_array::choose_value_accessor_one_openfpm< T, vector > | |
Ccid_< dim, cnt_type, ids_type, transform > | |
Ccid_< 1, cnt_type, ids_type, transform > | |
Ccid_< 2, cnt_type, ids_type, transform > | |
Ccid_< 3, cnt_type, ids_type, transform > | |
Ccl_selector_impl< cl_type, impl > | |
Ccl_selector_impl< cl_type, 1 > | |
Ccl_selector_impl< cl_type, 2 > | |
Ccomb< dim > | Position of the element of dimension d in the hyper-cube of dimension dim |
Ccomb< 0 > | |
Ccomb< Grid::dims > | |
Ccomb< Sys_eqs::dims > | |
Ccompare_aggregate< S > | Structure to compare aggregates |
Ccompare_cpu_encap_encap< e_src, e_dst > | This class is a functor for "for_each" algorithm |
Ccompare_fusion_vector< bfv > | This class is a functor for "for_each" algorithm |
Ccompare_general< T, agg > | Structure to copy aggregates |
Ccompare_general< T, 0 > | |
Ccompare_general< T, 2 > | |
Ccompare_host_device< base_type, prp > | |
Ccompare_host_device< base_type[N1], prp > | |
Ccompare_host_device< base_type[N1][N2], prp > | |
Ccompare_host_device< Point< N1, base_type >, prp > | |
CComposeArrayType< BaseT > | |
CComposeArrayType< BaseType[N1]> | |
CComposeArrayType< BaseType[N1][N2]> | |
Cconditional_push< v, p_ele, to_push > | Push p_ele into v only of to_push is true |
Cconditional_push< v, p_ele, false > | Push p_ele into v only of to_push is true |
Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vector, TPtr >::const_array_view< NDims > | |
Copenfpm::detail::multi_array::sub_array_openfpm< T, NumDims, vector >::const_array_view< NDims > | |
Copenfpm::const_array_view_gen_openfpm< Array, N > | |
Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector >::const_array_view_openfpm< NDims > | |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::const_array_view_openfpm< NDims > | |
Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims >::const_array_view_openfpm< NDims > | |
Cconst_mul_functor_value< v_expr > | Multiplication expression |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::const_subarray< NDims > | |
Copenfpm::const_subarray_gen_openfpm< Array, N, vector > | |
CFD_scheme< Sys_eqs, grid_type >::constant_b | Encapsulation of the b term as constant |
CFDScheme< Sys_eqs >::constant_b | Encapsulation of the b term as constant |
Ccub::ConstantInputIterator< ValueType, OffsetT > | A random-access input generator for dereferencing a sequence of homogeneous values |
CConstField | |
Cconstruct_expression< T > | |
Cconstruct_expression< double > | Construct a vector expression from a double |
Cconstruct_expression< float > | Construct a vector expression from a float |
Cgpu::context_t | |
CConv3x3x3< dim, p_src, p_dst > | |
CConv3x3x3_noshared< dim, p_src, p_dst > | |
Cconv_coeff | |
Cconv_impl< dim > | |
Cconv_impl< 3 > | |
CConv_tol_change< phi_type > | Optional convergence criterium checking the total change |
CConv_tol_change< double > | |
CConv_tol_residual< phi_type > | Optional convergence criterium checking the residual |
CConv_tol_residual< double > | |
Cconvert< A > | Set a conversion map between A and B |
Cconvert< std::string > | Partial specialization when A is a string |
Ccopy_acc< S > | This class is a functor for "for_each" algorithm |
Ccopy_aggregate< S > | Structure to copy aggregates |
Ccopy_aggregate_dual< S, S2 > | Structure to copy aggregates |
Ccopy_aggregate_op< op, S > | Structure to copy aggregates applying an operation |
Ccopy_all_prop_sparse< e_src, e_dst, indexT > | |
Ccopy_bck< Tsrc, Tdst > | |
Ccopy_corner_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy point in 3D |
Ccopy_corner_3< layout_type, prop, 1, chunking, is_cross > | Copy point in 3D |
Ccopy_corner_3< layout_type, prop, stencil_size, chunking, true > | Copy point in 3D |
Ccopy_cpu_encap< dim, S, Memory > | This class is a functor for "for_each" algorithm |
Ccopy_cpu_encap_encap< e_src, e_dst > | This class is a functor for "for_each" algorithm |
Ccopy_cpu_encap_encap_general< e_src, e_dst > | This class is a functor for "for_each" algorithm |
Ccopy_cpu_encap_encap_op_prp< op, e_src, e_dst, prp > | It copy two encap object |
Ccopy_cpu_encap_encap_prp< e_src, e_dst, prp > | This class is a functor for "for_each" algorithm |
Ccopy_cpu_encap_single< e_src > | This class is a functor for "for_each" algorithm |
Ccopy_ele< Eqs_sys, S, Ev > | This class is a functor for "for_each" algorithm |
Ccopy_ele_sca_array< copy_type, T, Ev, Eqs_sys, sa > | Copy scalar elements |
Ccopy_ele_sca_array< copy_type, T, Ev, Eqs_sys, 1 > | Copy 1D array elements |
Ccopy_encap_vector_fusion< enc, bfv > | This class is a functor for "for_each" algorithm |
Ccopy_fast_1d_device_memory< lin_or_inte, data_type, S > | This class is a functor for "for_each" algorithm |
Ccopy_fast_1d_device_memory< true, data_type, S > | This class is a functor for "for_each" algorithm |
Ccopy_fusion_vector< bfv > | This class is a functor for "for_each" algorithm |
Ccopy_fusion_vector_encap< bfv, enc > | This class is a functor for "for_each" algorithm |
Ccopy_general< T, agg > | Structure to copy aggregates |
Ccopy_general< T, 1 > | Specialization for if dst type is copy assignable from src type |
Ccopy_general< T, 2 > | Specialization for aggregate type object |
Ccopy_general< T, 3 > | Specialization for aggregate type object that define an operator= |
Ccopy_general_op< op, T, agg > | Structure to copy aggregates applying an operation |
Ccopy_general_op< op, T, 1 > | Specialization for object that can be assigned with an operator copy |
Ccopy_general_op< op, T, 3 > | Specialization for aggregate type objects |
Ccopy_grid_fast< is_complex, N, grid, ginfo > | This is a way to quickly copy a grid into another grid |
Ccopy_grid_fast< false, 2, grid, ginfo > | This is a way to quickly copy a grid into another grid |
Ccopy_grid_fast< false, 3, grid, ginfo > | This is a way to quickly copy a grid into another grid |
Ccopy_grid_fast< true, 1, grid, ginfo > | This is a way to quickly copy a grid into another grid |
Ccopy_grid_fast< true, 2, grid, ginfo > | This is a way to quickly copy a grid into another grid |
Ccopy_grid_fast< true, 3, grid, ginfo > | This is a way to quickly copy a grid into another grid |
Ccopy_grid_fast_caller< T > | |
Ccopy_grid_fast_caller< index_tuple_sq< prp ... > > | |
Ccopy_grid_fast_layout_switch< is_inte, dim, grid, ginfo > | |
Ccopy_grid_fast_layout_switch< true, dim, grid, ginfo > | |
Ccopy_ndim_fast_selector< dim > | |
Ccopy_ndim_fast_selector< 2 > | |
Ccopy_ndim_fast_selector< 3 > | |
Ccopy_packer_chunk< e_src, e_dst > | It copy one element of the chunk for each property |
Ccopy_packer_chunk_arr_impl< Timpl > | |
Ccopy_packer_chunk_arr_impl< Timpl[N1]> | |
Ccopy_prop_to_vector< Tsrc, Tdst > | |
Ccopy_prop_to_vector_block< Tsrc, Tdst > | |
Ccopy_prop_to_vector_block_impl< copy_type > | |
Ccopy_prop_to_vector_block_impl< copy_type[N1]> | |
Ccopy_sparse_to_sparse< dim, Tsrc, Tdst > | |
Ccopy_sparse_to_sparse_bb< dim, Tsrc, Tdst, aggrType > | |
Ccopy_sparse_to_sparse_bb_impl< T > | |
Ccopy_sparse_to_sparse_bb_impl< T[N1]> | |
Ccopy_sparse_to_sparse_bb_impl< T[N1][N2]> | |
Ccopy_sparse_to_sparse_op< op, dim, Tsrc, Tdst, prp > | |
Ccopy_switch_memory_c_no_cpy< T_type_src, T_type_dst > | This class is a functor for "for_each" algorithm |
Ccopy_sz< dim, mpl_v > | This class is a functor for "for_each" algorithm |
Copenfpm::copy_two_vectors_activate_impl< active > | |
Copenfpm::copy_two_vectors_activate_impl< true > | |
Ccopy_unpacker_chunk< e_src, e_dst > | It copy one element of the chunk for each property |
Ccopy_x_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy x edge in 3D |
Ccopy_x_3< layout_type, prop, 1, chunking, is_cross > | Copy x edge in 3D |
Ccopy_x_3< layout_type, prop, stencil_size, chunking, true > | Copy x edge in 3D |
Ccopy_xy_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy XY surface in 3D |
Ccopy_xy_3< 1, prop, stencil_size, chunking, is_cross > | Copy XY surface in 3D |
Ccopy_xyz< layout_type, prop, stencil_size, chunking, is_cross > | Copy block in 3D |
Ccopy_xyz< 1, prop, stencil_size, chunking, is_cross > | Copy block in 3D vectorized |
Ccopy_xz_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy XZ surface in 3D |
Ccopy_xz_3< layout_type, prop, 1, chunking, is_cross > | Copy XZ surface in 3D |
Ccopy_y_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy y edge in 3D |
Ccopy_y_3< layout_type, prop, 1, chunking, is_cross > | Copy y edge in 3D |
Ccopy_y_3< layout_type, prop, stencil_size, chunking, true > | Copy y edge in 3D |
Ccopy_yz_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy YZ surface in 3D |
Ccopy_yz_3< layout_type, prop, 1, chunking, is_cross > | Copy YZ surface in 3D |
Ccopy_z_3< layout_type, prop, stencil_size, chunking, is_cross > | Copy z edge in 3D |
Ccopy_z_3< layout_type, prop, 1, chunking, is_cross > | Copy z edge in 3D |
Ccopy_z_3< layout_type, prop, stencil_size, chunking, true > | Copy z edge in 3D |
Ccub::CountingInputIterator< ValueType, OffsetT > | A random-access input generator for dereferencing a sequence of incrementing integer values |
►Ccp_block_base< T, stencil_size, vector_vmpl, dim > | |
Ccp_block< T, stencil_size, vector_vmpl, dim > | |
►Ccp_block_base< T, stencil_size, vector_vmpl, 2 > | |
Ccp_block< T, stencil_size, vector_vmpl, 2 > | |
►Ccp_block_base< T, stencil_size, vector_vmpl, 3 > | |
Ccp_block< T, stencil_size, vector_vmpl, 3 > | |
Copenfpm::cpu_block_process< reduction_type, impl > | |
Copenfpm::cpu_block_process< reduction_type, 3 > | |
Copenfpm::cpu_block_process< reduction_type, VECTOR_SPARSE_BLOCK > | |
Ccross_stencil< dim, T > | |
Ccross_stencil_v< prop_type > | |
Ccsv_col< Tobj, attr > | This class is a functor for "for_each" algorithm |
Ccsv_col< Tobj, false > | This class is a functor for "for_each" algorithm |
Ccsv_col_str< T > | This class is an helper to produce csv headers from multi-array |
Ccsv_col_str< T[N1]> | Partial specialization for N=1 1D-Array |
Ccsv_col_str< T[N1][N2]> | Partial specialization for N=2 2D-Array |
Ccsv_col_str< T[N1][N2][N3]> | Partial specialization for N=3 |
Ccsv_col_str< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
Ccsv_prp< Tobj > | This class is a functor for "for_each" algorithm |
Ccsv_value_str< T, is_writable > | This class is an helper to produce csv data from multi-array |
Ccsv_value_str< T, false > | Partial specialization for unknown property |
Ccsv_value_str< T[N1], is_writable > | Partial specialization for N=1 1D-Array |
Ccsv_value_str< T[N1][N2], is_writable > | Partial specialization for N=2 2D-Array |
Ccsv_value_str< T[N1][N2][N3], is_writable > | Partial specialization for N=3 |
Ccsv_value_str< T[N1][N2][N3][N4], is_writable > | Partial specialization for N=4 |
CCSVWriter< v_pos, v_prp, impl > | CSV Writer |
Cct_par< nNN_, nLoop_ > | |
Ccub::CubVector< T, vec_elements > | Exposes a member typedef Type that names the corresponding CUDA vector type if one exists. Otherwise Type refers to the CubVector structure itself, which will wrap the corresponding x , y , etc. vector fields |
Ccub::CubVector< OffsetT, 2 > | |
Ccub::CubVector< T, 1 > | |
Ccub::CubVector< T, 2 > | |
Ccub::CubVector< T, 3 > | |
Ccub::CubVector< T, 4 > | |
Ccval< T > | It store the non zero elements of the matrix |
CD< d, Field, Sys_eqs, impl > | Derivative second order on h (spacing) |
CD< d, arg, Sys_eqs, BACKWARD > | First order BACKWARD derivative on direction i |
CD< d, arg, Sys_eqs, CENTRAL > | Second order central Derivative scheme on direction i |
CD< d, arg, Sys_eqs, CENTRAL_B_ONE_SIDE > | Second order one sided Derivative scheme on direction i |
CD< d, arg, Sys_eqs, FORWARD > | First order FORWARD derivative on direction i |
Cdata_il< l > | |
Cdata_il< 1 > | |
Cdata_il< 2 > | |
Cdata_il< 4 > | |
Cdata_il< 8 > | |
Cdata_ptr_fill< AggregateT, n_it, prp > | |
CDataBlock< ScalarT, DataBlockSize > | |
CdataDiv< T > | Class that store Internal part external and border part of a dataset |
CDcpseDiagonalScalingMatrix< dim, monomialBasis_type > | |
CDcpseRhs< dim > | |
CDEBUG< T > | |
CDebug< typename > | |
Copenfpm::Debug< typename > | |
CDEBUG< float & > | |
Cdec_optimizer< dim, Graph > | This class take a graph representing the space decomposition and produce a simplified version |
CDecomposition< T, S > | This class define the domain decomposition interface |
CDecomposition_encap< Decomposition, garray > | |
Cdeconstruct_impl< T_type, layout_base, Memory > | This class is a functor for "for_each" algorithm |
Cdecrement_memory< vector_type > | |
Cdefault_chunking< dim > | |
Cdefault_chunking< 1 > | |
Cdefault_chunking< 2 > | |
Cdefault_chunking< 3 > | |
Cdefault_chunking< 4 > | |
Cdefault_chunking< 5 > | |
Cdefault_chunking< 6 > | |
Cdefault_chunking< 7 > | |
Cdefault_chunking< 8 > | |
Cdefault_edge< dim > | |
Cdefault_edge< 1 > | |
Cdefault_edge< 2 > | |
Cdefault_edge< 3 > | |
Cboost::numeric::odeint::ofp_operations::default_rel_error< Fac1 > | |
CFD::Derivative< dir, ord_d, ord, impl > | |
CFD::Derivative_impl< dir, ord_d, ord, impl > | |
CFD::Derivative_impl< dir, 1, 2, CENTRAL > | |
CFD::Derivative_impl< dir, 1, 2, CENTRAL_ONE_SIDE_BACKWARD > | |
CFD::Derivative_impl< dir, 1, 2, CENTRAL_ONE_SIDE_FORWARD > | |
CFD::Derivative_impl< dir, 1, 2, CENTRAL_STAG > | |
CFD::Derivative_impl< dir, 1, 2, CENTRAL_STAG_ONE_SIDE_BACKWARD > | |
CFD::Derivative_impl< dir, 1, 2, CENTRAL_STAG_ONE_SIDE_FORWARD > | |
CFD::Derivative_impl< dir, 2, 2, CENTRAL > | |
CFD::Derivative_impl< dir, 2, 2, CENTRAL_ONE_SIDE_BACKWARD > | |
CFD::Derivative_impl< dir, 2, 2, CENTRAL_ONE_SIDE_FORWARD > | |
Cdevice_grid< dim > | |
Cdevice_grid_copy< is_sparse > | |
Cdevice_grid_copy< true > | |
Cdevice_to_host_impl< T_type, layout_base, prp > | This class is a functor for "for_each" algorithm |
Cdevice_to_host_start_stop_impl< T_type, layout_base, prp > | This class is a functor for "for_each" algorithm |
Ccub::DeviceHistogram | DeviceHistogram provides device-wide parallel operations for constructing histogram(s) from a sequence of samples data residing within device-accessible memory |
Ccub::DevicePartition | DevicePartition provides device-wide, parallel operations for partitioning sequences of data items residing within device-accessible memory |
Ccub::DeviceRadixSort | DeviceRadixSort 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::DispatchRadixSort< IS_DESCENDING, KeyT, ValueT, OffsetT > | < Signed integer type for global offsets |
Ccub::DispatchSegmentedRadixSort< IS_DESCENDING, KeyT, ValueT, OffsetIteratorT, OffsetT > | < Signed integer type for global offsets |
Ccub::DeviceReduce | DeviceReduce 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::DispatchReduce< InputIteratorT, OutputIteratorT, OffsetT, ReductionOpT > | < Binary reduction functor type having member T operator()(const T &a, const T &b) |
►Ccub::DeviceReducePolicy< std::iterator_traits< InputIteratorT >::value_type, OffsetT, ReductionOpT > | |
Ccub::DispatchSegmentedReduce< InputIteratorT, OutputIteratorT, OffsetIteratorT, OffsetT, ReductionOpT > | < Binary reduction functor type having member T operator()(const T &a, const T &b) |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT > | < Signed integer type for global offsets |
Ccub::DeviceRunLengthEncode | DeviceRunLengthEncode provides device-wide, parallel operations for demarcating "runs" of same-valued items within a sequence residing within device-accessible memory |
Ccub::DeviceScan | DeviceScan provides device-wide, parallel operations for computing a prefix scan across a sequence of data items residing within device-accessible memory |
Ccub::DeviceSegmentedRadixSort | DeviceSegmentedRadixSort 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::DeviceSegmentedReduce | DeviceSegmentedReduce provides device-wide, parallel operations for computing a reduction across multiple sequences of data items residing within device-accessible memory |
Ccub::DeviceSelect | DeviceSelect provides device-wide, parallel operations for compacting selected items from sequences of data items residing within device-accessible memory |
Ccub::DeviceSpmv | DeviceSpmv provides device-wide parallel operations for performing sparse-matrix * dense-vector multiplication (SpMV) |
Cdim3_ | |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT > | < Signed integer type for global offsets |
Ccub::DiscardOutputIterator< OffsetT > | A discard iterator |
Ccub::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::DiscontinuityOp | |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT > | < Signed integer type for global offsets |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT > | < Signed integer type for global offsets |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS > | < Whether or not we push rejected items to the back of the output |
Ccub::DispatchSpmv< ValueT, OffsetT > | < Signed integer type for global offsets |
Cdist_prop_out_edge< Graph > | This class is a functor for "for_each" algorithm |
Cdist_prop_out_vertex< Graph > | This class is a functor for "for_each" algorithm |
Cdist_prop_output< has_attributes, Graph, i > | This class specialize functions in the case the type T has or not defined attributes |
Cdist_prop_output< false, Graph, i > | This class specialize functions in the case the type T has not defined attributes |
Cdist_prop_output_array_scalar_selector_edge< is_array > | Property writer for scalar and vector |
Cdist_prop_output_array_scalar_selector_edge< true > | Property writer for vector |
Cdist_prop_output_array_scalar_selector_edge_fill_vertex< is_array > | Property writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk) |
Cdist_prop_output_array_scalar_selector_edge_fill_vertex< true > | Property writer for vector |
Cdist_prop_output_array_scalar_selector_vertex< is_array > | Property writer for scalar and vector |
Cdist_prop_output_array_scalar_selector_vertex< true > | Property writer for vector |
CDistFromSol< phi_type > | Bundles total residual and total change over all the grid points |
CDistFromSol< double > | |
CDistGraph_constr_impl< dim, Graph, se, T, dim_c, pos > | Graph constructor function specialization |
CDistGraph_constr_impl< dim, Graph, NO_EDGE, T, dim_c, pos... > | Graph constructor function specialization |
CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p > | Structure that store a graph in CSR format or basically in compressed adjacency matrix format |
CDistGraph_CSR< nm_v< dim >, nm_e > | |
►CDistGraph_CSR< V, E > | |
CDistGraph_CSR_s< V, E > | Simplified implementation of DistGraph_CSR |
CDistGraphFactory< dim, Graph > | This class construct a cartesian graph |
CDistParmetis< Graph > | Helper class to define Metis graph |
CDistParmetis< DistGraph_CSR< nm_v< dim >, nm_e > > | |
CDistParMetisDistribution< dim, T > | |
CDLB | |
Cdo_not_print_warning_on_adjustment< dim, linearizer > | |
Cdo_when_dim_gr_i< dim, i, ORB, Enable > | This structure use SFINAE to avoid instantiation of invalid code |
Cdo_when_dim_gr_i< dim, i, ORB, typename boost::enable_if< boost::mpl::bool_<(i< dim)> >::type > | |
►Cdomain_icell_calculator< dim, T, layout_base, Memory > | |
CCartDecomposition< dim, T, HeapMemory, memory_traits_lin, ParMetisDistribution< dim, T > > | |
CCartDecomposition< dim, St > | |
CCartDecomposition< dim, typename grid_in_type::stype > | |
►CCartDecomposition< dim, T, Memory, layout_base, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
CCartDecomposition_ext< dim, T, Memory, layout_base, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
Cdomain_icell_calculator< dim, St, layout_base, Memory > | |
Cdomain_icell_calculator< dim, T, memory_traits_lin, HeapMemory > | |
Cdomain_icell_calculator< dim, typename grid_in_type::stype, layout_base, Memory > | |
►Cdomain_nn_calculator_cart< dim > | This class calculate processor domains and neighborhood of each processor domain |
CCartDecomposition< dim, T, HeapMemory, memory_traits_lin, ParMetisDistribution< dim, T > > | |
CCartDecomposition< dim, St > | |
CCartDecomposition< dim, typename grid_in_type::stype > | |
CCartDecomposition< dim, T, Memory, layout_base, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
Ccub::DoubleBuffer< T > | Double-buffer storage wrapper for multi-pass stream transformations that require more than one storage array for streaming intermediate results back and forth |
Ccub::DoubleBuffer< KeyT > | |
Ccub::DoubleBuffer< ValueT > | |
CVTKWriter< pair, VECTOR_POINTS >::doubleint | |
CDrawParticles | A class to draw/create particles based on simple shaped |
Ce_box_id< dim > | It store the information about the external ghost box |
Ce_box_multi< dim > | For each external ghost id, it contain a set of sub-domain at which this external box is linked |
Ce_info | |
Ce_lbox_grid< dim > | Per-processor external ghost box |
Ce_lbox_id< dim > | It store the information about the local external ghost box |
Ce_map | Structure 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 >::EdgeReq | Structure to store a add request of an edge |
Cele | |
Cele_g< Grid, St > | It store one grid |
Cele_g_st< Grid, St > | Convert a staggered element into a string for vtk write |
Cele_vpp< Vpp > | Store a reference to the vector properties |
Cele_vps< Vps > | Store a reference to the vector position |
CEllipseParameters | |
Ccub::EnableIf< Condition, T > | Simple enable-if (similar to Boost) |
Ccub::EnableIf< false, T > | |
Cenc_num< encap > | |
Cencap_data_block< enc_type > | |
Cencap_shmem< sz > | Memcpy it split the copy across threads |
Cencapc< dim, T, layout > | |
Cencapc< 1, obj_type, Memory > | |
Cencapc< dim, T, typename memory_traits_inte< T >::type > | This structure encapsulate an object of the grid |
Cencapc< dim, T, typename memory_traits_lin< T >::type > | This structure encapsulate an object of the grid |
Cencapc< dim, void, Mem > | This structure specialize the class for a void object or null |
Cencapsulated_type< T > | |
Cep_box_grid< dim > | Per-processor external ghost box |
CEq< expr1, expr2, Sys_eqs > | Equation |
Ceq_id | |
►Cboost::mpl::equal_to | |
Cexit_impl< F, L > | Exit condition |
Cexit_impl_sq< c, end > | Exit condition |
►Cstd::equal_to | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< size_t, size_t >, KeySelect, ValueSelect, std::hash< size_t >, std::equal_to< size_t >, std::allocator< std::pair< size_t, size_t > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< Key, T >, KeySelect, ValueSelect, std::hash< Key >, std::equal_to< Key >, std::allocator< std::pair< Key, T > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< const Key, T >, KeySelect, ValueSelect, std::hash< Key >, std::equal_to< Key >, std::allocator< std::pair< const Key, T > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< Key, KeySelect, void, std::hash< Key >, std::equal_to< Key >, std::allocator< Key >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ccub::Equality | Default equality functor |
Ccub::Equals< A, B > | Type equality test |
Ccub::Equals< A, A > | |
Cequations2d1 | Specify the general characteristic of system to solve |
Cequations2d1_stag | Specify the general characteristic of system to solve |
Cequations2d1E | Specify the general characteristic of system to solve |
Cequations2d1p | |
Cequations2d1pE | |
Cequations2d2 | |
Cequations2d2E | |
Cequations2d2p | |
Cequations2d2pE | |
Cequations2d3 | |
Cequations2d3E | |
Cequations2d3p | |
Cequations2d3pE | |
Cequations2d4 | |
Cequations2d4E | |
Cequations3d1 | |
Cequations3d1E | |
Cequations3d1EPxy | |
Cequations3d1Pxy | |
Cequations3d1Pz | |
Cequations3d3 | |
Cequations3d3E | |
Cequations3d3EPxz | |
Cequations3d3EPz | |
Cequations3d3Pxz | |
Cequations3d3Pyz | |
Cequations3d3Pz | |
CError | Out-of-bound policy kill the program |
Ceta | [Definition of the system] |
►Cstd::exception | |
Cgpu::cuda_exception_t | |
Cexecute_cl_test< impl > | |
Cexecute_cl_test< 1 > | |
Cexecute_cl_test< 2 > | |
Cexist_sub_v_impl< v > | |
Cexist_sub_v_impl< 2 > | |
Cexist_sub_v_impl< 4 > | |
Cexist_sub_v_impl< 8 > | |
Cexp_kernel | Exponential kernel |
Cextends< T > | Classes to get the number of components of the properties |
Cextends< T[N1]> | Partial specialization for N=1 1D-Array |
Cextends< T[N1][N2]> | Partial specialization for N=2 2D-Array |
Cextends< T[N1][N2][N3]> | Partial specialization for N=3 |
Cextends< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
Cextends< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
Cextends< T[N1][N2][N3][N4][N5][N6]> | Partial specialization for N=6 |
Cextends< T[N1][N2][N3][N4][N5][N6][N7]> | Partial specialization for N=7 |
Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8]> | Partial specialization for N=8 |
Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]> | Partial specialization for N=9 |
Cextends< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]> | Partial specialization for N=10 |
CF< T > | [v_transform metafunction] |
►Cstd::false_type | |
►Cis_layout_inte< T::layout_base_ > | |
Cis_multiple_buffer_each_prp< T, true > | |
Chas_attributes< T, Sfinae > | |
Chas_base_to_copy< T, Sfinae > | |
Chas_check_device_pointer< T, Sfinae > | |
Chas_coordtype< T, Sfinae > | |
Chas_data< T, Sfinae > | |
Chas_getGrid< T, Sfinae > | |
Chas_grid_type< T, Sfinae > | |
Chas_init< ObjType, Sfinae > | Has_init check if a type has defined a method called init |
Chas_max_prop_nn< T, Sfinae > | |
Chas_noPointers< T, Sfinae > | |
Chas_pack< ObjType, Sfinae > | Has_Pack check if a type has defined a method called Pack |
Chas_packMem< ObjType, Sfinae > | Has_calculateMem check if a type has defined a method called calculateMem |
Chas_packRequest< ObjType, Sfinae > | Has_packRequest check if a type has defined a method called packRequest |
Chas_posMask< T, Sfinae > | |
Chas_set_d< T, Sfinae > | |
Chas_state_vector< T, Sfinae > | |
Chas_toKernel< ObjType, Sfinae > | Has_toKernel check if a type has defined a method called toKernel |
Chas_typedef_type< T, Sfinae > | |
Chas_val_pos< T, Sfinae > | |
Chas_value_type_ofp< T, Sfinae > | |
Chas_vector_kernel< T, Sfinae > | |
Chas_vtype< T, Sfinae > | |
CisDynStruct< ObjType, Sfinae > | |
Cis_Box< T, Sfinae > | |
Cis_Point< T, Sfinae > | |
Cis_aggregate< T, Sfinae > | |
Cis_const_field< T, Sfinae > | |
Cis_custom_vtk_writable< ObjType, Sfinae > | It check if the type is vtk writable |
Cis_encap< T, Sfinae > | |
Cis_expression< ObjType, Sfinae > | Is_expression check if a type is simple a type or is just an encapsulation of an expression |
Cis_gpu_celllist< T, Sfinae > | Check this is a gpu or cpu type cell-list |
Cis_gpu_ker_celllist< T, Sfinae > | Check this is a gpu or cpu type cell-list |
Cis_grid< T, Sfinae > | |
Cis_layout_inte< T, Sfinae > | |
Cis_layout_mlin< T, Sfinae > | |
Cis_multiple_buffer_each_prp< T, impl > | Is_multiple_buffer_each_prp |
Cis_openfpm_native< T, bool > | Is_openfpm_native check if a type is an openfpm native structure type |
Cis_testing< T, Sfinae > | |
Cis_vector< T, Sfinae > | |
Cis_vector_dist< T, Sfinae > | |
Cis_vector_native< T, Sfinae > | |
Cis_vtk_vector_dims< ObjType, Sfinae > | It check if the type is vtk writable |
Copenfpm::is_multi_array< T, Sfinae > | |
Ctsl::detail_hopscotch_hash::has_is_transparent< T, typename > | |
Ctsl::detail_hopscotch_hash::has_key_compare< T, typename > | |
CFD_scheme< Sys_eqs, grid_type > | Finite Differences |
CFDScheme< Sys_eqs > | Finite Differences |
CField< f, Sys_eqs > | |
Cfill_id< dim, G_v, prp > | Operator to fill the property 'prp' with the linearization of indexes |
Cfill_id< dim, G_v, NO_VERTEX_ID > | Operator to fill the property in case there are no properties |
CFill_one< index, N > | {1,1,1,1,....} |
Cfill_prop< dim, lin_id, dT, G_v, v, impl > | This class work as a functor |
Cfill_prop< dim, lin_id, dT, G_v, v, 0 > | This class work as a functor |
Cfill_prop< dim, lin_id, dT, G_v, v, 2 > | This class work as a functor |
Cfill_prop_by_type< dim, i, p, Graph, pos > | Operator for vector and scalar property |
Cfill_prop_by_type< dim, 0, p, Graph, pos... > | Operator for vector and scalar property in the case there are no properties |
Cfill_prop_v< dim, dT, G_v, v, impl > | This class work as a functor |
Cfill_prop_v< dim, dT, G_v, v, 0 > | This class work as a functor |
Cfill_prop_v< dim, dT, G_v, v, 2 > | This class work as a functor |
Cfill_prop_v_by_type< i, p, Graph, pos > | Operator for vector and scalar property |
Cfill_prop_v_by_type< 0, p, Graph, pos... > | Operator for vector and scalar property in the case there are no properties |
CFill_three< index, N > | Compile time array functor needed to generate array at compile-time of type |
CFill_two< index, N > | {2,2,2,2,....} |
CFill_zero< index, N > | {0,0,0,0,....} |
CFD::first_or_second< cond, exp1, exp2 > | |
Cfirst_or_second< cond, exp1, exp2 > | |
CFD::first_or_second< true, exp1, exp2 > | |
Cfirst_or_second< true, exp1, exp2 > | |
Cfirst_or_second_pt< cond, exp1, exp2 > | |
Cfirst_or_second_pt< true, exp1, exp2 > | |
Cfirst_variadic< T1, T > | |
CFitz< DX, DY > | |
Cboost::numeric::odeint::vector_space_algebra_ofp::for_each_norm< vector_type, index_type, norm_result_type > | |
Cboost::numeric::odeint::vector_space_algebra_ofp_gpu::for_each_norm< vector_type, index_type, norm_result_type > | |
Cboost::numeric::odeint::for_each_prop1< vector_type, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop10< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop11< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop12< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop13< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop14< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop15< S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop2< S1, S2, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop3< S1, S2, S3, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop4< S1, S2, S3, S4, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop5< S1, S2, S3, S4, S5, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop6< S1, S2, S3, S4, S5, S6, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop7< S1, S2, S3, S4, S5, S6, S7, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop8< S1, S2, S3, S4, S5, S6, S7, S8, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop9< S1, S2, S3, S4, S5, S6, S7, S8, S9, index_type, op_type > | |
Cboost::numeric::odeint::for_each_prop_resize< S1, S2 > | |
Cboost::mpl::aux::for_each_ref_cpu_impl< done > | |
Cboost::mpl::aux::for_each_ref_cpu_impl< false > | |
Cboost::mpl::aux::for_each_ref_host_impl< done > | |
Cboost::mpl::aux::for_each_ref_host_impl< false > | |
Cboost::mpl::aux::for_each_ref_impl< done > | |
Cboost::mpl::aux::for_each_ref_impl< false > | |
Copenfpm::fortran_storage_order | |
Ccub::FpLimits< _T > | |
Ccub::FpLimits< double > | |
Ccub::FpLimits< float > | |
Cfrswap< s_m > | This class is a functor for "for_each" algorithm |
Cfrswap_nomode< s_m, Mem_type > | This class is a functor for "for_each" algorithm |
CFt_chunk< n_ele, T > | Transform T=aggregate<float,double,int> into aggregate<std::array<float,n_ele>,std::array<double,n_ele>,std::array<int,n_ele>> |
CFt_chunk< n_ele, const T(&)[N1]> | Special case for vector |
CFtwo< arg0, T > | [v_transform metafunction] |
Cfunction< arg_f1, arg_f2, s > | |
CFD_scheme< Sys_eqs, grid_type >::function_b | Encapsulation of the b term as a function |
CFD::g_comp | |
CGaussianDLB | |
CGBoxes< dim > | This structure store the Box that define the domain inside the Ghost + domain box |
Cgcl< dim, St, CellL, Vector, impl, prp > | General function t get a cell-list |
Cgcl< dim, St, CellL, Vector, GCL_HILBERT > | General function t get a cell-list |
Cgcl< dim, St, CellL, Vector, GCL_SYMMETRIC > | General function t get a cell-list |
Cgcl_An< dim, St, CellL, Vector, impl > | General function t get a cell-list |
Cgcl_standard_no_symmetric_impl< is_gpu_celllist, prp > | |
Cgcl_standard_no_symmetric_impl< true, prp... > | |
CGCoptions | Google chart options |
CFD::gdb_ext_plus_g_info< dim > | |
Copenfpm::general_storage_order< NumDims > | |
CgeneralDimensionFunctor< T1 > | |
CgeneralDimensionFunctor< T1[N1]> | |
Cgenerate_array< T, N, F > | Main class to generate compile-time array |
Cgenerate_array_constexpr< T, N, F > | Main class to generate constexpr compile-time array |
Cgenerate_array_constexpr_impl< T, N, orig_N, F, args > | Recursive meta-function to generate compile-time array |
Cgenerate_array_constexpr_impl< T, 0, orig_N, F, args... > | Terminator of the variadic template |
Cgenerate_array_impl< T, N, orig_N, F, args > | Generate the array specializing ArrayHolder |
Cgenerate_array_impl< T, 0, orig_N, F, args... > | Terminator of the variadic template |
Cgenerate_array_vector< T, F > | Main class to generate an array from a boost::mpl::vector of numbers |
Cgenerate_array_vector_impl< T, N, F, args > | Generate the array specializing ArrayHolder |
Cgenerate_array_vector_impl< T, 0, F, args... > | Terminator of the variadic template |
Cgenerate_indexes< T, N, F > | Main class to generate indexes data structure |
Cgenerate_indexes_impl< T, N, orig_N, F, args > | Generate compile time index array |
Cgenerate_indexes_impl< T, 0, orig_N, F, args... > | Terminator of the variadic template |
Cgenerate_indexes_impl< T,-1, orig_N, F, args... > | In case of an empty list |
Cger< dim, T > | |
Cget_base_type_for_object_creator_chunking< type > | |
Cget_base_type_for_object_creator_chunking< std::array< T, N2 >[N1] > | |
Cget_block_sizes< dim, stencil_size, vector_blocks_ext, vector_ext > | This class is a functor for "for_each" algorithm |
CFD::get_grid_dist_expression_op< int, is_valid > | |
CFD::get_grid_dist_expression_op< 1, false > | |
CFD::get_grid_dist_expression_op< 1, true > | |
CFD::get_grid_dist_expression_op< 2, false > | |
CFD::get_grid_dist_expression_op< 2, true > | |
CFD::get_grid_dist_expression_op< 3, true > | |
Cget_pointer< dim_prp, prp, grid_type > | |
Cget_pointer< 1, prp, grid_type > | |
Cget_pointer< 2, prp, grid_type > | |
Cget_pointer_unpack< T, is_array > | |
Cget_pointer_unpack< T, true > | |
Cget_selector< T > | |
Cget_selector< T[N1]> | |
Cget_striding< dim, dim_prp, prp, grid_type > | |
CGoogleChart::get_value_type< arg_0, args > | |
Cget_vcl< Memory > | |
Cget_vcl< CudaMemory > | |
Cget_vector_dist_expression_op< int, is_valid > | |
Cget_vector_dist_expression_op< 1, false > | |
Cget_vector_dist_expression_op< 1, true > | |
Cget_vector_dist_expression_op< 2, true > | |
CGetAddBlockType< SGridGpu > | Get the type of the insertBlock |
CgetAttrName< ele_g, has_attributes > | Return the Attributes name from the type |
CgetAttrName< ele_g, false > | Return the Attributes name from the type |
CGetCpBlockType< SGridGpu, prp, stencil_size > | Get the type of the block |
CGetSetBlockType< SGridGpu > | Get the type of the SetBlock |
CGGraph | Google Graph |
Cghost_exchange_comm_impl< impl, layout_base, prp > | Template selector for asynchronous or not asynchronous |
Cghost_exchange_comm_impl< GHOST_ASYNC, layout_base, prp ... > | |
Cgid | |
CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::GlobalVInfo | Structure needed to get vertex position by global id |
CGoogleChart | Small class to produce graph with Google chart in HTML |
Cgrid_dist_id_iterator_dec_skin< Decomposition >::gp_sub | Internal struct |
CGraph_constructor_impl< dim, lin_id, Graph, se, T, dim_c, pos > | Graph constructor function specialization |
CGraph_constructor_impl< dim, lin_id, Graph, NO_EDGE, T, dim_c, pos... > | Graph constructor function specialization |
►CGraph_CSR< V, E, Memory, layout_v_base, layout_e_base, grow_p > | Structure that store a graph in CSR format or basically in compressed adjacency matrix format |
CGraph_CSR_s< ORB_node< T >, no_edge > | |
CGraph_CSR< nm_v< dim >, nm_e > | |
CGraph_CSR< ORB_node< T >, no_edge > | |
►CGraph_CSR< V, E > | |
CGraph_CSR_s< V, E > | Simplified implementation of Graph_CSR |
CGraphMLWriter< Graph > | |
Cgrid< T > | |
CFDScheme< Sys_eqs >::grid_b< grid, prp > | Encapsulation of the b term as grid |
Cgrid_base< dim, T, S, layout, linearizer > | |
Cgrid_base< 1, T, Memory, typename layout_base< T >::type > | |
Cgrid_base< dim, aggregate< size_t > > | |
Cgrid_base< dim, Tg > | |
Cgrid_base_impl< dim, T, S, layout_base, ord_type > | Implementation of a N-dimensional grid |
►Cgrid_base_impl< dim, T, S, memory_traits_inte, linearizer > | |
Cgrid_base< dim, T, S, typename memory_traits_inte< T >::type, linearizer > | This is an N-dimensional grid or an N-dimensional array with memory_traits_inte layout |
►Cgrid_base_impl< dim, T, S, memory_traits_lin, linearizer > | |
Cgrid_base< dim, T, S, typename memory_traits_lin< T >::type, linearizer > | This is an N-dimensional grid or an N-dimensional array with memory_traits_lin layout |
Cgrid_call_serialize_variadic< device_grid, Memory, T > | Unpack selector |
Cgrid_call_serialize_variadic< device_grid, Memory, index_tuple< prp... > > | Unpack selector |
CFD::GRID_DERIVATIVE< dir_, ord_d_, ord_, impl_ > | |
Cgrid_dist_amr< dim, St, T, impl, Decomposition, Memory, device_grid > | |
Cgrid_dist_amr< dim, St, T, AMR_IMPL_TRIVIAL, Decomposition, Memory, device_grid > | AMR Adaptive Multi Resolution Grid |
Cgrid_dist_amr_key< dim > | Amr grid distributed key |
Cgrid_dist_amr_key_iterator< dim, device_grid, device_sub_it, it_type > | |
CFD::grid_dist_expression< prp, grid, impl > | |
CFD::grid_dist_expression< 0, grid_patches< grid_cpu< dim, aggregate< double > > >, NORM_EXPRESSION > | Main class that encapsulate a grid properties operand to be used for expressions construction |
CFD::grid_dist_expression< dim, double, NORM_EXPRESSION > | Main class that encapsulate a double constant |
CFD::grid_dist_expression< dim, double, STAG_EXPRESSION > | Main class that encapsulate a double constant |
CFD::grid_dist_expression< dim, float, impl > | Main class that encapsulate a float constant |
CFD::grid_dist_expression< prp, grid, NORM_EXPRESSION > | Main class that encapsulate a grid properties operand to be used for expressions construction |
CFD::grid_dist_expression< prp, grid, STAG_EXPRESSION > | |
CFD::grid_dist_expression_iterator_to_make_algebra_work< dim > | |
CFD::grid_dist_expression_op< exp1, exp2, impl > | |
CFD::grid_dist_expression_op< exp1, boost::mpl::int_< n >, g_comp > | It take an expression and create the negatove of this expression |
CFD::grid_dist_expression_op< exp1, exp2, mul > | |
CFD::grid_dist_expression_op< exp1, exp2, sub > | |
CFD::grid_dist_expression_op< exp1, exp2, sum > | |
CFD::grid_dist_expression_op< exp1, void, GRID_DERIVATIVE< dir, ord_d, ord, impl > > | |
CFD::grid_dist_expression_op< exp1, void, subuni > | |
CFD::grid_dist_expression_value_impl< base_type > | |
CFD::grid_dist_expression_value_impl< base_type[N1]> | |
CFD::grid_dist_expression_value_impl< base_type[N1][N2]> | |
CFD::grid_dist_expression_value_impl< base_type[N1][N2][N3]> | |
CFD::grid_dist_expression_value_impl< Point< N1, base_type > > | |
CFD::grid_dist_expression_value_impl_func_scal< i > | |
CFD::grid_dist_expression_value_impl_func_scal< 0 > | |
CFD::grid_dist_expression_value_impl_func_vec< i > | |
CFD::grid_dist_expression_value_impl_func_vec< 0 > | |
CFD::grid_dist_expression_value_impl_vnz< i > | |
CFD::grid_dist_expression_value_impl_vnz< 0 > | |
Cgrid_dist_g_dx< device_grid > | Distributed linearized key |
►Cgrid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid > | This class is an helper for the communication of grid_dist_id |
Cgrid_dist_id< dim, St, T, CartDecomposition< dim, St >, HeapMemory, grid_cpu< dim, T > > | |
Cgrid_dist_id< Sys_eqs::dims, typename Sys_eqs::stype, aggregate< size_t >, typename Sys_eqs::b_grid::decomposition::extended_type > | |
Cgrid_dist_id< Sys_eqs::dims, typename Sys_eqs::stype, aggregate< size_t >, typename grid_type::decomposition::extended_type > | |
Cgrid_dist_id< grid_in_type::dims, typename grid_in_type::stype, props_temp > | |
Cgrid_dist_id< last::dims, typename last::stype, aggregate< size_t >, typename last::b_grid::decomposition::extended_type > | |
►Cgrid_dist_id< dim, St, T, Decomposition, Memory, device_grid > | This is a distributed grid |
Cstaggered_grid_dist< dim, St, T, Decomposition, Memory, device_grid > | Implementation of the staggered grid |
Cgrid_dist_id_comm< dim, St, T, CartDecomposition< dim, St >, HeapMemory, grid_cpu< dim, T > > | |
Cgrid_dist_id_comm< dim, typename grid_in_type::stype, props_temp, CartDecomposition< dim, typename grid_in_type::stype >, HeapMemory, grid_cpu< dim, props_temp > > | |
Cgrid_dist_id_comm< dim, typename last::stype, aggregate< size_t >, typename last::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > > | |
Cgrid_dist_id_comm< dim, typename Sys_eqs::stype, aggregate< size_t >, typename grid_type::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > > | |
Cgrid_dist_id_comm< dim, typename Sys_eqs::stype, aggregate< size_t >, typename Sys_eqs::b_grid::decomposition::extended_type, HeapMemory, grid_cpu< dim, aggregate< size_t > > > | |
►Cgrid_dist_id_iterator_dec< Decomposition, ghost_or_domain > | Given the decomposition it create an iterator |
CPointIterator< dim, T, Decomposition > | This class draw particles on subset of grid-like position |
Cgrid_dist_id_iterator_gpu< Decomposition, deviceGrids, ghost_or_domain > | Given the decomposition it create an iterator |
Cgrid_dist_iterator< dim, device_grid, device_sub_it, impl, stencil > | Distributed grid iterator |
Cgrid_dist_iterator< dim, device_grid, device_sub_it, FREE > | |
Cgrid_dist_iterator_sub< dim, device_grid > | Distributed grid iterator |
Cgrid_dist_key_dx< dim, base_key > | Grid key for a distributed grid |
Cgrid_dist_key_dx< dim > | |
Cgrid_dist_key_dx< Eqs_sys::dims > | |
Cgrid_dist_key_dx< Grid_dst::dims > | |
Cgrid_dist_key_dx< last::dims > | |
Cgrid_dist_lin_dx | Distributed linearized key |
Cgrid_dist_testing< dim > | |
Cgrid_gpu_ker< dim, T, layout_base, linearizer > | Grid interface available when on gpu |
Cgrid_gpu_ker< 1, T_, layout_base, grid_sm< 1, void > > | |
Cgrid_gpu_ker< 1, T_, memory_traits_inte, grid_sm< 1, void > > | |
Cgrid_gpu_ker< 1, T_, memory_traits_lin, grid_sm< 1, void > > | |
Cgrid_gpu_ker_constructor_impl< inte_or_lin, T > | |
Cgrid_gpu_ker_constructor_impl< false, T > | |
Cgrid_gpu_ker_ref< dim, T, layout_base, linearizer > | |
Cgrid_key< p > | |
Cgrid_key_1< p > | |
Cgrid_key_2< p > | |
Cgrid_key_3< p > | |
Cgrid_key_4< p > | |
Cgrid_key_c3< p > | |
Cgrid_key_d< dim, p > | Grid_key_d is the key to access any element in the grid |
Cgrid_key_dx< dim, index_type > | Grid_key_dx is the key to access any element in the grid |
Cgrid_key_dx< Decomposition::dims > | |
Cgrid_key_dx< dim > | |
Cgrid_key_dx< dim, ids_type > | |
Cgrid_key_dx< dim, int > | |
Cgrid_key_dx< dim, long int > | |
Cgrid_key_dx< Sys_eqs::dims > | |
Cgrid_key_dx_expression< dim, exp > | Expression template for grid_key_dx |
►Cgrid_key_dx_expression< dim, grid_key_dx_sub< dim, exp1, exp2 > > | |
Cgrid_key_dx_sub< dim, exp1, exp2 > | Main class that encapsulate a sub expression |
►Cgrid_key_dx_expression< dim, grid_key_dx_sum< dim, exp1, exp2 > > | |
Cgrid_key_dx_sum< dim, exp1, exp2 > | Main class that encapsulate a sum expression |
►Cgrid_key_dx_iterator< dim, stencil, linearizer > | |
Cgrid_key_dx_iterator_sub< dim, no_stencil, grid_sm< dim, void >, print_warning_on_adjustment< dim, grid_sm< dim, void > > > | |
Cgrid_key_dx_iterator_sp< dim > | |
Cgrid_key_dx_iterator< dim, no_stencil, grid_sm< dim, void > > | |
►Cgrid_key_dx_iterator< dim, stencil, linearizer > | |
Cgrid_key_dx_iterator_sub< dim > | |
Cgrid_key_dx_iterator_sub< Decomposition::dims > | |
►Cgrid_key_dx_iterator_sub< dim, stencil, linearizer, warn > | Declaration grid_key_dx_iterator_sub |
Cgrid_key_dx_iterator_sub_bc< dim, stencil, linearizer, warn > | The same as grid_key_dx_iterator_sub_p but with periodic boundary |
Cgrid_key_dx_iterator_hilbert< dim > | |
Cgrid_key_dx_iterator_sub< 0, warn > | |
Cgrid_key_dx_r | Emulate grid_key_dx with runtime dimensionality |
Cgrid_key_sparse_dx_iterator< dim, n_ele > | Grid key sparse iterator |
Cgrid_key_sparse_dx_iterator_sub< dim, n_ele > | Grid key sparse iterator on a sub-part of the domain |
Cgrid_key_sparse_lin_dx | It store the position in space of the sparse grid |
CFD::grid_patches< patches > | |
CFD::grid_patches< grid_base< dim, aggregate< double > > > | |
Cgrid_skin_iterator_bc< dim > | |
►Cgrid_skin_iterator_bc< Decomposition::dims > | |
►Cgrid_dist_id_iterator_dec_skin< Decomposition > | Given the decomposition it create an iterator |
CPointIteratorSkin< dim, T, Decomposition > | This class draw particles on subset of grid-like position |
►Cgrid_sm< N, T > | Declaration grid_sm |
Cgrid_zm< N, T > | Class that store the information of the grid like number of point on each direction and define the index linearization by stride |
Cgrid_sm< 1, void > | |
Cgrid_sm< dim, aggregate< size_t > > | |
Cgrid_sm< dim, int > | |
Cgrid_sm< dim, props_temp > | |
Cgrid_sm< dim, T > | |
Cgrid_sm< dim, void > | |
Cgrid_sm< last::dims, void > | |
Cgrid_sm< Sys_eqs::dims, void > | |
Cgrid_smb< dim, blockEdgeSize, indexT > | |
►Cgrid_smb< dim, blockEdgeSize, indexT > | |
Cgrid_zmb< dim, blockEdgeSize, indexT > | |
Cgrid_smb< dim, default_edge< dim >::type::value, long int > | |
Cgrid_toKernelImpl< inte_or_lin, base_grid, dim, T > | |
Cgrid_toKernelImpl< true, base_grid, dim, T > | |
Cgrid_unpack_selector_with_prp< result, T, device_grid, Memory > | Unpack selector |
Cgrid_unpack_selector_with_prp< true, T, device_grid, Memory > | Unpack selector |
Cgrid_unpack_with_prp< op, T, device_grid, Memory > | Unpack selector |
►Ccub::GridBarrier | GridBarrier implements a software global barrier among thread blocks within a CUDA grid |
Ccub::GridBarrierLifetime | GridBarrierLifetime extends GridBarrier to provide lifetime management of the temporary device storage needed for cooperation |
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_double | Grow policy define how the vector should grow every time we exceed the size |
Copenfpm::grow_policy_identity | Grow policy define how the vector should grow every time we exceed the size |
Copenfpm::grow_policy_page | Grow policy define how the vector should grow every time we exceed the size |
►CGrowthPolicy | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, OverflowContainer > | |
Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::GuardedInequalityWrapper< _EqualityOpT > | |
CH5_prop_out< ele_v, has_name > | This class is a functor for "for_each" algorithm |
CH5_prop_out< ele_v, false > | This class is a functor for "for_each" algorithm |
CH5_write< T, pid, V > | Write an HDF5 dataset in case of scalars and vectors |
CH5_write< T[N1], pid, V > | Partial specialization for N=1 1D-Array |
CH5_write< T[N1][N2], pid, V > | Partial specialization for N=2 2D-Array |
CH5_write< T[N1][N2][N3], pid, V > | Partial specialization for N=3 |
CH5_write< T[N1][N2][N3][N4], pid, V > | Partial specialization for N=4 |
Chas_max_prop< T, hvt > | |
Chas_max_prop< T, false > | |
Chas_pack_agg< T, prp > | Return if true the aggregate type T has a property that has a complex packing(serialization) method |
Chas_pack_agg_impl< T, N, result_p, vprp > | Generate the array specializing ArrayHolder |
Chas_pack_agg_impl< T, 0, result_p, vprp > | Terminator of the variadic template |
Chas_pack_encap< T, prp > | |
Chas_pack_gen< T, sel > | It return true if the object T require complex serialization |
Chas_pack_gen< T, false > | It return true if the object T require complex serialization |
Chas_val< int, T > | Evaluate the constant field function |
Chas_val< HAS_VAL, T > | Evaluate the constant field function |
►CHash | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, OverflowContainer > | |
►Cstd::hash | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< size_t, size_t >, KeySelect, ValueSelect, std::hash< size_t >, std::equal_to< size_t >, std::allocator< std::pair< size_t, size_t > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< Key, T >, KeySelect, ValueSelect, std::hash< Key >, std::equal_to< Key >, std::allocator< std::pair< Key, T > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< const Key, T >, KeySelect, ValueSelect, std::hash< Key >, std::equal_to< Key >, std::allocator< std::pair< const Key, T > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< Key, KeySelect, void, std::hash< Key >, std::equal_to< Key >, std::allocator< Key >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Cstd::hash< gid > | |
Cstd::hash< lid > | |
Cstd::hash< rid > | |
CHDF5_reader< type > | |
CHDF5_reader< GRID_DIST > | |
CHDF5_reader< VECTOR_DIST > | |
CHDF5_writer< type > | |
CHDF5_writer< GRID_DIST > | |
CHDF5_writer< VECTOR_DIST > | |
CHDF5_XdmfWriter< imp > | |
CHDF5_XdmfWriter< H5_POINTSET > | HDF5 writer for a point set |
CHeatStencil< dim, p_src, p_dst > | |
CHeatStencilGet< dim, p_src, p_dst > | |
►Ctsl::detail_hopscotch_hash::hopscotch_bucket_hash< StoreHash > | |
Ctsl::detail_hopscotch_hash::hopscotch_bucket< ValueType, NeighborhoodSize, StoreHash > | |
Ctsl::detail_hopscotch_hash::hopscotch_bucket_hash< true > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, OverflowContainer >::hopscotch_iterator< is_const > | |
Ctsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > | |
Ctsl::hopscotch_map< size_t, size_t > | |
Ctsl::hopscotch_sc_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > | |
Ctsl::hopscotch_sc_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > | |
Ctsl::hopscotch_set< Key, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy > | |
Chost_to_dev_all_prp< Tv > | This class is a functor for "for_each" algorithm |
Chost_to_device_impl< T_type, layout_base, Memory, prp > | This class is a functor for "for_each" algorithm |
Copenfpm::htoD< sg_type > | |
CHyperCube< dim > | This class calculate elements of the hyper-cube |
►CHyperCube< subdim > | |
CSubHyperCube< dim, subdim > | This represent a sub-hyper-cube of an hyper-cube like a face or an edge of a cube |
Ci_box_id< dim > | It store a box, its unique id and the sub-domain from where it come from |
Ci_lbox_grid< dim > | Local Internal ghost box |
Ci_lbox_id< dim > | It store an internal ghost box, the linked external ghost box and the sub-domain from where it come from as internal ghost box |
Cibox_send< dim > | Set of internal ghost box to send |
CID_operation< output_type > | |
Cids_crs< dim, sz > | |
Cids_pl | |
►Cie_ghost< dim, T, Memory, layout_base > | Structure that store and compute the internal and external local ghost box |
CCartDecomposition< dim, T, HeapMemory, memory_traits_lin, ParMetisDistribution< dim, T > > | |
CCartDecomposition< dim, St > | |
CCartDecomposition< dim, typename grid_in_type::stype > | |
CCartDecomposition< dim, T, Memory, layout_base, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
Cie_ghost< dim, St, Memory, layout_base > | |
Cie_ghost< dim, T, HeapMemory, memory_traits_lin > | |
Cie_ghost< dim, typename grid_in_type::stype, Memory, layout_base > | |
►Cie_ghost_gpu< dim, T, Memory, layout_base > | Structure that store and compute the internal and external local ghost box. Version usable in kernel |
CCartDecomposition_gpu< dim, T, Memory, layout_base > | |
►Cie_loc_ghost< dim, T, layout_base, Memory > | Structure that store and compute the internal and external local ghost box |
CCartDecomposition< dim, T, HeapMemory, memory_traits_lin, ParMetisDistribution< dim, T > > | |
CCartDecomposition< dim, St > | |
CCartDecomposition< dim, typename grid_in_type::stype > | |
CCartDecomposition< dim, T, Memory, layout_base, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
Cie_loc_ghost< dim, St, layout_base, Memory > | |
Cie_loc_ghost< dim, T, memory_traits_lin, HeapMemory > | |
Cie_loc_ghost< dim, typename grid_in_type::stype, layout_base, Memory > | |
Ccub::If< IF, ThenType, ElseType > | Type selection (IF ? ThenType : ElseType ) |
Ccub::If< AgentSpmvPolicyT::DIRECT_LOAD_NONZEROS, NullType, ValueT > | |
Ccub::If< false, ThenType, ElseType > | |
Ccub::If< IsPointer< AggregatesOutputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSegmentFixupPolicyT::LOAD_MODIFIER, ValueT, OffsetT >, AggregatesOutputIteratorT > | |
Ccub::If< IsPointer< FlagsInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSelectIfPolicyT::LOAD_MODIFIER, FlagT, OffsetT >, FlagsInputIteratorT > | |
Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentReducePolicy::LOAD_MODIFIER, InputT, OffsetT >, InputIteratorT > | |
Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentRlePolicyT::LOAD_MODIFIER, T, OffsetT >, InputIteratorT > | |
Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentScanPolicyT::LOAD_MODIFIER, InputT, OffsetT >, InputIteratorT > | |
Ccub::If< IsPointer< InputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSelectIfPolicyT::LOAD_MODIFIER, InputT, OffsetT >, InputIteratorT > | |
Ccub::If< IsPointer< KeysInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentReduceByKeyPolicyT::LOAD_MODIFIER, KeyInputT, OffsetT >, KeysInputIteratorT > | |
Ccub::If< IsPointer< PairsInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentSegmentFixupPolicyT::LOAD_MODIFIER, KeyValuePairT, OffsetT >, PairsInputIteratorT > | |
Ccub::If< IsPointer< SampleIteratorT >::VALUE, CacheModifiedInputIterator< LOAD_MODIFIER, SampleT, OffsetT >, SampleIteratorT > | |
Ccub::If< IsPointer< ValuesInputIteratorT >::VALUE, CacheModifiedInputIterator< AgentReduceByKeyPolicyT::LOAD_MODIFIER, ValueInputT, OffsetT >, ValuesInputIteratorT > | |
Ccub::If< STORE_WARP_TIME_SLICING, typenameWarpExchangePairs::TempStorage, NullType > | |
Ccub::If<(cudaSharedMemBankSizeFourByte==cudaSharedMemBankSizeEightByte), unsignedlonglong, unsignedint > | |
Ccub::If<(Equals< typenamestd::iterator_traits< OutputIteratorT >::value_type, void >::VALUE), typenamestd::iterator_traits< InputIteratorT >::value_type, typenamestd::iterator_traits< OutputIteratorT >::value_type > | |
Ccub::If<(sizeof(T)==8), longlong, typenameIf<(sizeof(T)==4), int, typenameIf<(sizeof(T)==2), short, char >::Type >::Type > | |
Ccub::If<(STATUS_WORD_SIZE==8), longlong, typenameIf<(STATUS_WORD_SIZE==4), int, typenameIf<(STATUS_WORD_SIZE==2), short, char >::Type >::Type > | |
CVcluster< InternalMemory >::index_gen< T > | |
CVcluster< InternalMemory >::index_gen< index_tuple< prp... > > | Process the receive buffer using the specified properties (meta-function) |
Cindex_tuple<... > | These set of classes generate an array definition at compile-time |
Cindex_tuple_sq<... > | |
Ccub::Inequality | Default inequality functor |
Ccub::InequalityWrapper< EqualityOp > | Inequality functor (wraps equality functor) |
Ccub::InequalityWrapper< EqualityOpT > | |
Cinit_prop< Np, vector > | This class is a functor for "for_each" algorithm |
Cinsert_kernel2D< p > | |
Cinsert_kernel3D< p > | |
CInsertBlockWrapper< AggregateT, pMask > | |
Ccub::Int2Type< A > | Allows for the treatment of an integral constant as a type at compile-time (e.g., to achieve static call dispatch based on constant integral values) |
Cinte_calc_impl< vector, kernel > | Calculate the interpolation for one point |
Cinte_template< np, prp_g, prp_v, m2p_or_p2m > | Class that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m) |
Cinte_template< np, prp_g, prp_v, inte_m2p > | Class that select the operation to do differently if we are doing Mesh to particle (m2p) or particle to mesh (p2m) |
Ccub::WarpScanShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::IntegerTraits< S > | |
Cinter_memc< Seq > | This class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c interleaved |
Cinter_memc_red< Seq > | This class convert a boost::mpl::fusion/vector to a boost::mpl::fusion/vector with memory_c<.....,MEMORY_C_REDUCED> interleaved |
Cinterp_ele< Tdst, Grid_dst, Grid_src, nst_pos > | This class is a functor for "for_each" algorithm |
Cinterp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, sa > | Add scalar elements |
Cinterp_ele_sca_array< copy_type, Tsrc, Tdst, Grid_src, Grid_dst, 1 > | Add 1D array elements |
Cinterp_points< dim, n_prop, v_prp_id, v_prp_type > | This class is a functor for "for_each" algorithm |
Cinterpolate< vector, grid, kernel > | Main class for interpolation Particle to mest p2m and Mesh to particle m2p |
CIntPow< base, exponent > | |
CIntPow< base, 0 > | |
Cip_box_grid< dim > | Per-processor Internal ghost box |
Cis_complex_agg< T, prp > | Return if true the aggregate type T has a property that has a complex packing(serialization) method |
Cis_complex_agg_impl< T, N, result_p, vprp > | These set of classes generate an array definition at compile-time |
Cis_complex_agg_impl< T, 0, result_p, vprp > | Terminator of the variadic template |
Cis_contiguos< prp > | |
Cis_csv_writable< T > | Indicate if the property T is writable in CSV |
Cis_csv_writable< bool > | Indicate if the property T is writable in CSV |
Cis_csv_writable< char > | Indicate if the property T is writable in CSV |
Cis_csv_writable< double > | Indicate if the property T is writable in CSV |
Cis_csv_writable< float > | Indicate if the property T is writable in CSV |
Cis_csv_writable< int > | Indicate if the property T is writable in CSV |
Cis_csv_writable< long int > | Indicate if the property T is writable in CSV |
Cis_csv_writable< short > | Indicate if the property T is writable in CSV |
Cis_csv_writable< T[N1]> | Indicate if the property T is writable in CSV |
Cis_csv_writable< T[N1][N2]> | Indicate if the property T is writable in CSV |
Cis_csv_writable< T[N1][N2][N3]> | Indicate if the property T is writable in CSV |
Cis_csv_writable< unsigned char > | Indicate if the property T is writable in CSV |
Cis_csv_writable< unsigned int > | Indicate if the property T is writable in CSV |
Cis_csv_writable< unsigned long int > | Indicate if the property T is writable in CSV |
Cis_csv_writable< unsigned short > | Indicate if the property T is writable in CSV |
Cis_grid_staggered< T, has_gt > | Is_grid_staggered analyse T if it has a property grid_type defined and indicate that the grid is staggered |
Cis_grid_staggered< T, false > | Is_grid_staggered analyse T if it has a property that define the type of grid |
Cis_initialized< T > | Initialized |
Cis_initialized< openfpm::vector< T > > | Initialized |
Cboost::numeric::odeint::is_resizeable< state_type_1d_ofp > | |
Cboost::numeric::odeint::is_resizeable< state_type_2d_ofp > | |
Cboost::numeric::odeint::is_resizeable< state_type_3d_ofp > | |
Cboost::numeric::odeint::is_resizeable< state_type_4d_ofp > | |
Cboost::numeric::odeint::is_resizeable< state_type_5d_ofp > | |
Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 1, state_type > > | |
Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 2, state_type > > | |
Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 3, state_type > > | |
Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 4, state_type > > | |
Cboost::numeric::odeint::is_resizeable< state_type_ofpm_impl< 5, state_type > > | |
Cboost::numeric::odeint::is_resizeable< vector_dist_expression< 0, openfpm::vector< aggregate< T > > > > | |
Cis_typedef_and_data_same< cond, T > | Check if T::type and T.data has the same type |
Cis_typedef_and_data_same< false, T > | |
Cis_typedef_and_data_same< true, SpaceBox< dim, St > > | |
Cis_typedef_and_data_same< true, wavefront< dim > > | |
Cis_vtk_writable< T > | Check for T to be writable |
Cis_vtk_writable< bool > | Check bool |
Cis_vtk_writable< char > | Check char |
Cis_vtk_writable< double > | Check double |
Cis_vtk_writable< float > | Check float |
Cis_vtk_writable< int > | Check int |
Cis_vtk_writable< long int > | Check long int |
Cis_vtk_writable< short > | Check short |
Cis_vtk_writable< unsigned char > | Check unsigned char |
Cis_vtk_writable< unsigned int > | Check unsigned int |
Cis_vtk_writable< unsigned long int > | Check unsigned long int |
Cis_vtk_writable< unsigned short > | Check unsigned short |
Ccub::WarpReduceShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::IsInteger< S > | |
Ccub::UnitWord< T >::IsMultiple< Unit > | |
Ccub::IsPointer< Tp > | Pointer vs. iterator |
Ccub::IsPointer< Tp * > | |
Ccub::IsVolatile< Tp > | Volatile modifier test |
Ccub::IsVolatile< Tp volatile > | |
Cite_g | |
Cite_gpu< dim > | |
Ccub::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >::Iterate< COUNT, MAX > | |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< ITERATION, MAX_ITERATIONS > | Templated unrolling of item comparison (inductive case) |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< ITERATION, MAX_ITERATIONS > | Templated unrolling of item comparison (inductive case) |
Ccub::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >::Iterate< MAX, MAX > | |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< MAX_ITERATIONS, MAX_ITERATIONS > | Templated unrolling of item comparison (termination case) |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::Iterate< MAX_ITERATIONS, MAX_ITERATIONS > | Templated unrolling of item comparison (termination case) |
Ccub::IterateThreadLoad< COUNT, MAX > | Helper structure for templated load iteration (inductive case) |
Ccub::IterateThreadLoad< MAX, MAX > | Helper structure for templated load iteration (termination case) |
Ccub::IterateThreadStore< COUNT, MAX > | Helper structure for templated store iteration (inductive case) |
Ccub::IterateThreadStore< MAX, MAX > | Helper structure for templated store iteration (termination case) |
►Cboost::iterator_facade | |
Copenfpm::detail::multi_array::array_iterator_openfpm< T, TPtr, NumDims, vector, Reference, IteratorCategory > | |
CIterator_g_const | |
Cpetsc_solver< double >::itError | Contain the infinity norm of the residual at each iteration |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::KernelConfig | |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::KernelConfig | |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::KernelConfig | |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::KernelConfig | |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::KernelConfig | |
Ccub::DispatchSpmv< ValueT, OffsetT >::KernelConfig | |
Ccub::KernelConfig | |
CFD_scheme< Sys_eqs, grid_type >::key_and_eq | Equation id + space position |
CFDScheme< Sys_eqs >::key_and_eq | Equation id + space position |
Ckey_int< dim > | |
Ckey_shift< dim, chunk > | |
Ckey_shift< 1, chunk > | |
Ckey_shift< 2, chunk > | |
Ckey_shift< 3, chunk > | |
Ckey_shift< 4, chunk > | |
Ckey_shift< 5, chunk > | |
Ckey_shift< 6, chunk > | |
Ckey_shift< 7, chunk > | |
Ckey_shift< 8, chunk > | |
►CKeyEqual | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy, OverflowContainer > | |
Ctsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect | |
Ctsl::hopscotch_sc_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect | |
Ctsl::hopscotch_sc_set< Key, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect | |
Ctsl::hopscotch_set< Key, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::KeySelect | |
Ccub::KeyValuePair< _Key, _Value > | A key identifier paired with a corresponding value |
Ccub::KeyValuePair< OffsetT, LengthT > | |
CKillParticle | Out of bound policy it detect out of bound particles and decide what to do |
CKillParticleWithWarning | Out-of-bound policy kill the particle but print a warning |
Ckl_selector_impl< kl_type, cl_type, impl > | |
Ckl_selector_impl< kl_type, cl_type, 1 > | |
Ckl_selector_impl< kl_type, cl_type, 2 > | |
CFD::L2Error | |
CL_norms | |
ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, is_ok_cuda > | |
ClabelParticlesGhost_impl< dim, St, prop, Memory, layout_base, Decomposition, true > | |
Clambda2_2kernel< st > | |
Clambda4_4kernel< st > | |
CLap< arg, Sys_eqs, impl > | Laplacian second order on h (spacing) |
CLap< arg, Sys_eqs, CENTRAL > | Laplacian second order approximation CENTRAL Scheme |
CLap< arg, Sys_eqs, CENTRAL_SYM > | Laplacian second order approximation CENTRAL Scheme (with central derivative in the single) |
CLap_PSE< dim, T, ord, impl > | Implementation of the Laplacian kernels for PSE |
CLap_PSE< 1, T, 2, KER_GAUSSIAN > | |
CLap_PSE< 1, T, 4, KER_GAUSSIAN > | |
CLap_PSE< 1, T, 6, KER_GAUSSIAN > | |
CLap_PSE< 1, T, 8, KER_GAUSSIAN > | |
CFD::Laplacian< dim, impl > | |
CLaplacianStencil< dim, p > | |
Clast_variadic< T1, T > | |
Clast_variadic< T1 > | |
CLastPOf< AggregateT > | |
Claunch_call_impl< impl > | |
Claunch_call_impl< 1 > | |
Claunch_insert_sparse | |
Claunch_insert_sparse_lambda_call< dim > | |
Claunch_insert_sparse_lambda_call< 2 > | |
Claunch_insert_sparse_lambda_call< 3 > | |
Claunch_set_dense< dim > | |
Claunch_set_dense< 2 > | |
Claunch_set_dense< 3 > | |
Copenfpm::vector< T, Memory, layout_base, grow_p, OPENFPM_NATIVE >::layout_base__< Tobj > | |
Cvector< T, CudaMemory, memory_traits_inte, grow_policy_double, STD_VECTOR >::layout_base__< Tobj > | |
Cvector< T, HeapMemory, memory_traits_lin, grow_p, STD_VECTOR >::layout_base__< Tobj > | |
ClBox_dom< dim, T > | Case for local ghost box |
CCartDecomposition< dim, T, Memory, layout_base, Distribution >::lc_processor_id | Class to select the returned id by ghost_processorID |
Clid | |
Clid_nn | [Definition of the system] |
Clid_nn_3d_eigen | Specify the general caratteristic of system to solve |
Clid_nn_3d_petsc | |
Climit_max_t< type_t > | |
CFD::LInfError | |
Cln_force | |
Cln_potential | |
CLNorms< lnorm_type > | Class for computing the l2/l_infinity norm for distributed grids and vectors based on given errors |
Cload_mask_impl< N > | |
Cload_mask_impl< 1 > | |
Cload_mask_impl< 16 > | |
Cload_mask_impl< 2 > | |
Cload_mask_impl< 4 > | |
Cload_mask_impl< 8 > | |
CloadGhostBlock_impl< nLoop, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize > | |
CloadGhostBlock_impl< 1, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize > | |
CloadGhostBlock_impl< 2, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize > | |
CloadGhostBlock_impl< 3, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize > | |
CloadGhostBlock_impl< 7, dim, AggregateBlockT, pMask, p, ct_params, blockEdgeSize > | |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< _POLICY, DUMMY > | Load helper |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_DIRECT, DUMMY > | |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_TRANSPOSE, DUMMY > | |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_VECTORIZE, DUMMY > | |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_WARP_TRANSPOSE, DUMMY > | |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED, DUMMY > | |
Clocal_ghost_from_dec_impl< dim, St, prop, Memory, layout_base, is_ok_cuda > | |
Clocal_ghost_from_dec_impl< dim, St, prop, Memory, layout_base, true > | |
Clocal_ghost_from_opart_impl< with_pos, dim, St, prop, Memory, layout_base, is_ok_cuda > | |
Clocal_ghost_from_opart_impl< with_pos, dim, St, prop, Memory, layout_base, true > | |
Ccub::Log2< N, CURRENT_VAL, COUNT > | Statically determine log2(N), rounded up |
Ccub::Log2< N, 0, COUNT > | |
Ctsl::detail_hopscotch_hash::make_void< T > | |
CMatLabWriter< dim, T > | This class is able to save grid into tiff files |
CMatrix< dim, T > | This class implement an NxN (dense) matrix |
Ccub::Max | Default max functor |
Cmax_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
Cmax_prop_nn< T, has_max_prop > | |
Cmax_prop_nn< T, false > | |
Cboost::numeric::odeint::ofp_operations::maximum< Value > | |
CMem_bal< local_index > | Class for BALANCED cell list implementation |
►CMem_fast< Memory, local_index > | It is a class that work like a vector of vector |
CCellList< vector::dims, typename vector::stype, Mem_fast<>, shift< vector::dims, typename vector::stype > > | |
CVerletList< dim, T, Mem_type, transform, vector_pos_type, CellListImpl > | Class for Verlet list implementation |
►CMem_fast< HeapMemory, int > | |
CCellList< dim, T, Mem_fast< HeapMemory, int >, shift< dim, T > > | |
CMem_fast< HeapMemory, local_index_ > | |
►CMem_fast< HeapMemory, typename Mem_type::local_index_type > | |
CCellList< dim, T, Mem_fast< HeapMemory, typename Mem_type::local_index_type >, no_transform< dim, T >, openfpm::vector< Point< dim, T > > > | |
►CMem_fast< Memory, int > | |
CCellList< dim, St, Mem_fast< Memory, int >, shift< dim, St > > | |
CCellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > | |
CCellList< dim, typename grid_in_type::stype, Mem_fast< Memory, int >, shift< dim, typename grid_in_type::stype > > | |
CMem_fast_ker< Memory, layout_base, local_index > | |
►CMem_fast_ker< Memory, memory_traits_lin, int > | |
CCellList_cpu_ker< dim, T, Mem_fast_ker< Memory, memory_traits_lin, int >, shift< dim, T > > | |
Cmem_geto< dim, T, layout, data_type, g1_type, key_type, sel > | Case memory_traits_lin |
Cmem_geto< dim, T, layout, data_type, g1_type, key_type, 1 > | Case memory_traits_inte |
Cmem_getpointer< data_type, layout, sel > | |
Cmem_getpointer< data_type, layout, 1 > | |
CMem_mw< local_index > | Class for MEMORY-WISE cell list implementation |
Cmem_reference< T > | Metafunction take T and return a reference |
Cmem_setarray< grid_type, Memory > | This class is a functor for "for_each" algorithm |
Cmem_setext< grid_type, S, layout, data_type, sel > | Case memory_traits_lin |
Cmem_setext< grid_type, S, layout, data_type, 1 > | Case memory_traits_inte |
Cmem_setext_prp< grid_type, data_type, S > | This class is a functor for "for_each" algorithm |
Cmem_setm< S, layout, data_type, g1_type, sel > | Case memory_traits_lin |
Cmem_setm< S, layout, data_type, g1_type, 1 > | Case memory_traits_inte |
Cmem_setmemory< data_type, Mem_type, layout, sel > | |
Cmem_setmemory< data_type, Mem_type, layout, 1 > | |
Cmem_swap< T, layout, data_type, grid_type, sel > | Case memory_traits_lin |
Cmem_swap< T, layout, data_type, grid_type, 1 > | Case memory_traits_inte |
►CMem_type | |
CCellList< dim, T, Mem_type, transform, vector_pos_type > | Class for FAST cell list implementation |
CCellList_cpu_ker< dim, T, Mem_type, transform > | |
►CMemory | |
CBMemory< Memory > | It override the behavior if size() |
►Cmemory | |
CExtPreAlloc< HeapMemory > | |
CExtPreAlloc< CudaMemory > | |
CCudaMemory | |
CExtPreAlloc< Mem > | |
CHeapMemory | This class allocate, and destroy CPU memory |
CPtrMemory | This class give memory from a preallocated memory, memory destruction is not performed |
Cmemory_array< T > | This class give a representation to a chunk or memory |
Cmemory_c< T, impl, D > | |
Cmemory_c< multi_array< T >, MEMORY_C_STANDARD, D > | Specialization of memory_c for multi_array |
Cmemory_c< T, MEMORY_C_STANDARD, D > | This class is a container for the memory interface like HeapMemory CudaMemory |
Cmemory_thrust_c< T > | This class is a container for the memory interface |
Cmemory_traits_inte< T > | Transform the boost::fusion::vector into memory specification (memory_traits) |
Cmemory_traits_inte< T_ > | |
Cmemory_traits_inte< T_type > | |
Cmemory_traits_lin< T > | Transform the boost::fusion::vector into memory specification (memory_traits) |
Cmemory_traits_lin< T_ > | |
Cmemory_traits_lin_type< T, is_agg > | Transform the boost::fusion::vector into memory specification (memory_traits) |
Cmemory_traits_lin_type< T, false > | Small meta-function to get the type of the memory |
Cmerge_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
Copenfpm::merge_prp_device_impl< is_ok_cuda, T, Memory, layout_base, grow_p > | |
Copenfpm::merge_prp_device_impl< true, T, Memory, layout_base, grow_p > | |
Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::MergeItem | Merge item type (either a non-zero value or a row-end offset) |
Cmet_sub_w | Sub-domain list and weight |
Cmeta_compare< T > | This class compare general objects |
Cmeta_compare< T[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_compare< T[N1][N2]> | Partial specialization for N=2 2D-Array |
Cmeta_compare< T[N1][N2][N3]> | Partial specialization for N=3 |
Cmeta_copy< T > | This class copy general objects |
Cmeta_copy< T[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_copy< T[N1][N2]> | Partial specialization for N=2 2D-Array |
Cmeta_copy< T[N1][N2][N3]> | Partial specialization for N=3 |
Cmeta_copy< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
Cmeta_copy< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
Cmeta_copy< T[N1][N2][N3][N4][N5][N6]> | Partial specialization for N=6 |
Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7]> | Partial specialization for N=7 |
Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8]> | Partial specialization for N=8 |
Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]> | Partial specialization for N=9 |
Cmeta_copy< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]> | Partial specialization for N=10 |
Cmeta_copy_block< copy_type, nprp, prp_val, prp_id > | |
Cmeta_copy_block< copy_type[N1], nprp, prp_val, prp_id > | |
Cmeta_copy_block< copy_type[N1][N2], nprp, prp_val, prp_id > | |
Cmeta_copy_d< Tsrc, Tdst > | Copy for a source object to a destination |
Cmeta_copy_d< Tsrc, Tdst[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_copy_d< Tsrc, Tdst[N1][N2]> | Partial specialization for N=2 2D-Array |
Cmeta_copy_d< Tsrc[N1], Tdst > | Partial specialization for N=1 1D-Array |
Cmeta_copy_d< Tsrc[N1], Tdst[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_copy_d< Tsrc[N1][N2], Tdst > | Partial specialization for N=2 2D-Array |
Cmeta_copy_d< Tsrc[N1][N2], Tdst[N1][N2]> | Partial specialization for N=1 1D-Array |
Cmeta_copy_op< op, T > | This class copy general objects applying an operation |
Cmeta_copy_op< op, openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > > | Partial specialization for N=1 1D-Array |
Cmeta_copy_op< op, openfpm::detail::multi_array::sub_array_openfpm< T, 2, vmpl > > | Partial specialization for N=2 2D-Array |
Cmeta_copy_op< op, T[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_copy_op< op, T[N1][N2]> | Partial specialization for N=2 2D-Array |
Cmeta_copy_op< op, T[N1][N2][N3]> | Partial specialization for N=3 |
Cmeta_copy_op_d< op, Tsrc, Tdst > | |
Cmeta_copy_op_d< op, openfpm::detail::multi_array::sub_array_openfpm< Tsrc, 1, vmpl >, openfpm::detail::multi_array::sub_array_openfpm< Tdst, 1, vmpl > > | Partial specialization for N=2 2D-Array |
Cmeta_copy_op_d< op, openfpm::detail::multi_array::sub_array_openfpm< Tsrc, 2, vmpl >, openfpm::detail::multi_array::sub_array_openfpm< Tdst, 2, vmpl > > | Partial specialization for N=2 2D-Array |
Cmeta_copy_op_d< op, Tsrc, Tdst[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_copy_op_d< op, Tsrc[N1], Tdst > | Partial specialization for N=1 1D-Array |
Cmeta_copy_op_d< op, Tsrc[N1], Tdst[N1]> | Partial specialization for N=1 1D-Array |
Cmeta_copy_op_d< op, Tsrc[N1][N2], Tdst[N1][N2]> | Partial specialization for N=2 2D-Array |
Cmeta_copy_set_bck< T > | |
Cmeta_copy_set_bck< T[N]> | |
Cmeta_prop< I, ele_g, St, T, is_writable > | This class is an helper to create properties output from scalar and compile-time array elements |
Cmeta_prop< I, ele_g, St, T, false > | Specialication when is not writable |
Cmeta_prop< I, ele_g, St, T[N1], is_writable > | Partial specialization for N=1 1D-Array |
Cmeta_prop< I, ele_g, St, T[N1][N2], is_writable > | Partial specialization for N=2 2D-Array |
Cmeta_prop< I, ele_g, St, T[N1][N2][N3], is_writable > | Partial specialization for N=3 3D-Array |
Cmeta_prop_new< I, ele_g, St, T, is_writable > | This class is an helper to create properties output from scalar and compile-time array elements |
Cmeta_prop_new< I, ele_g, St, T, false > | Specialication when is not writable |
Cmeta_prop_new< I, ele_g, St, T[N1], is_writable > | Partial specialization for N=1 1D-Array |
Cmeta_prop_new< I, ele_g, St, T[N1][N2], is_writable > | Partial specialization for N=2 2D-Array |
Cmeta_prop_new< I, ele_g, St, T[N1][N2][N3], is_writable > | Partial specialization for N=3 3D-Array |
Cmeta_raw_read< dim, Tg, Tr, i > | This is the scalar case |
Cmeta_raw_read< dim, Tg, Tr[nv], i > | This is the vector case |
CMetaFunc< index, N > | [Metafunction definition] |
CMetaFuncOrd< index, N > | |
CVcluster< InternalMemory >::MetaFuncOrd< index, N > | Metafunction |
CMetaParser | |
CMethodOfImages< SurfaceNormal, vd_type > | Class for getting mirror particles to impose Neumann BCs |
CMetis< Graph > | Helper class to define Metis graph |
CMetis< Graph_CSR< nm_v< dim >, nm_e > > | |
CMetis_graph | Metis graph structure |
CMetisDistribution< dim, T > | Class that distribute sub-sub-domains across processors using Metis Library |
Cmheader< n_ele > | This structure contain the information of a chunk |
Ccub::Min | Default min functor |
Cmin_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
Cminus< arg, Sys_eqs > | It ancapsulate the minus operation |
Ctsl::mod_growth_policy< GrowthFactor > | |
CModelCustom | Model for Dynamic load balancing |
CModelCustom2 | Second model for dynamic load balancing |
CModelLin | Linear model |
CModelSquare | Linear model |
CMonomial< dim > | |
CMonomial_gpu< dim > | |
CMonomialBasis< dim, T, vector_type, Args > | |
CMonomialBasis< dim > | |
Cmove_impl< impl, grid_key_base, dim > | |
Cmove_impl< false, grid_key_base, dim > | |
►Cmp4_kernel< st > | |
Cz_kernel< st, 2 > | |
Cmp_funct< grid, ginfo > | |
Cmp_funct_impl< dim, T > | |
Cmp_funct_impl< dim, T[N1]> | |
Cmp_funct_impl< dim, T[N1][N2]> | |
CMPI_IAllGatherW< T > | General recv for vector of |
CMPI_IAllGatherW< char > | Specialization for vector of char |
CMPI_IAllGatherW< double > | Specialization for vector of double |
CMPI_IAllGatherW< float > | Specialization for vector of float |
CMPI_IAllGatherW< int > | Specialization for vector of integer |
CMPI_IAllGatherW< long int > | Specialization for vector of long int |
CMPI_IAllGatherW< short > | Specialization for vector of short |
CMPI_IAllGatherW< size_t > | Specialization for vector of size_t |
CMPI_IAllGatherW< unsigned char > | Specialization for vector of unsigned char |
CMPI_IAllGatherW< unsigned int > | Specialization for vector of unsigned integer |
CMPI_IAllGatherW< unsigned short > | Specialization for vector of short |
CMPI_IAllGatherWB | Set 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_IBcastWB | Set 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_IrecvWB | Set 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_IsendWB | Set of wrapping classing for MPI_Isend |
CFD::mul | |
Cmul< expr > | It model an expression expr1 * expr2 |
Cmul_inte< T > | Multiply the src by coeff for several types T |
Cmul_inte< T[N1]> | Multiply the src by coeff for several types T |
Cmul_inte< T[N1][N2]> | Multiply the src by coeff for several types T |
Cmult< T, N > | This class multiply all the elements in a boost::mpl::vector excluding the first element |
Cmult< T, 1 > | |
Cmulti_array< T > | This class is a trick to indicate the compiler a specific specialization pattern |
►Copenfpm::detail::multi_array::multi_array_base_openfpm | |
Copenfpm::detail::multi_array::value_accessor_n_openfpm< T, NumDims, vector > | |
Copenfpm::detail::multi_array::value_accessor_one_openfpm< T, vector > | |
Cmulti_mask< i > | |
Cmulti_mask< 1 > | |
Cmulti_mask< 16 > | |
Cmulti_mask< 2 > | |
Cmulti_mask< 4 > | |
Cmulti_mask< 8 > | |
CMultiArrayViewGpu< BaseT, Nup, N > | |
CMultiArrayViewGpu< BaseT, Nup, 0 > | |
Cmutable_or_not< T, mm > | |
Cmutable_or_not< Kernel, is_gpu_celllist< NN >::type::value||is_gpu_ker_celllist< NN >::type::value > | |
Cmutable_or_not< NN, is_gpu_celllist< NN >::type::value||is_gpu_ker_celllist< NN >::type::value > | |
Cmutable_or_not< T, true > | |
Ccub::Mutex | |
Cmy_particle | |
Cmy_struct | |
CN_box< dim, T > | |
CN_operation | |
CNarrowBand< grid_in_type, phi_type > | Class for getting the narrow band around the interface |
Cnative_encapsulated_type< T > | |
Cnb_f | |
Cne_cp | |
Cnm_e | Sub-domain edge graph node |
Cnm_part_e | Reduced edge graph node |
Cnm_part_v | Reduced sub-domain vertex graph node |
Cnm_v< dim > | |
►CNN_gpu_int_base_hr_impl< dim, r_int, pr_int, ids_type, cnt_type > | |
►CNN_gpu_int_base< dim, r_int, openfpm::math::pow(2 *r_int+1, dim), ids_type, cnt_type > | |
CNN_gpu_it< dim, cnt_type, ids_type, r_int, is_sparse > | |
CNN_gpu_int_base< dim, r_int, pr_int, ids_type, cnt_type > | |
CNN_gpu_it< dim, cnt_type, ids_type, r_int, true > | |
CNN_gpu_it_radius< dim, cnt_type, ids_type > | |
CNN_gpu_selector< dim, cnt_type, ids_type, is_sparse > | |
CNN_gpu_selector< dim, cnt_type, ids_type, true > | |
CNN_index< impl > | |
CNN_index< NN_index_sort > | |
►Cnn_prcs< dim, T, layout_base, Memory > | This class store the adjacent processors and the adjacent sub_domains |
CCartDecomposition< dim, T, HeapMemory, memory_traits_lin, ParMetisDistribution< dim, T > > | |
CCartDecomposition< dim, St > | |
CCartDecomposition< dim, typename grid_in_type::stype > | |
CCartDecomposition< dim, T, Memory, layout_base, Distribution > | This class decompose a space into sub-sub-domains and distribute them across processors |
Cnn_prcs< dim, St, layout_base, Memory > | |
Cnn_prcs< dim, T, memory_traits_lin, HeapMemory > | |
Cnn_prcs< dim, typename grid_in_type::stype, layout_base, Memory > | |
Cnn_type_result< NN1_type, NN2_type > | |
Cnn_type_result< void, NN2_type > | |
CNNc_array< dim, size, thr > | |
CNNc_array< dim, NNc_size > | |
CNNc_array< dim, openfpm::math::pow(3, dim)/2+1 > | |
CNNc_array< dim, size, false > | |
CNNc_array< dim,(unsigned int) openfpm::math::pow(3, dim)/2+1 > | |
CNNc_array< dim,(unsigned int) openfpm::math::pow(3, dim)> | |
CNNFull< dim > | |
CNNfull_is_padding_impl< dim > | Check if is padding |
CNNfull_is_padding_impl< 2 > | Check if is padding |
CNNfull_is_padding_impl< 3 > | Check if is padding |
CNNStar< dim > | |
CNNStar_c< dim > | |
CNNType< dim, T, CellListImpl, PartIt, type, local_index > | Get the neighborhood iterator based on type |
CNNType< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC, local_index > | Get the neighborhood iterator based on type |
CNNType< dim, T, CellListImpl, PartIt, VL_SYMMETRIC, local_index > | Get the neighborhood iterator based on type |
CNNType< dim, T, CellListImpl, PartIt, WITH_RADIUS, local_index > | Get the neighborhood iterator based on type |
CNNTypeM< dim, T, CellListImpl, PartIt, type > | Get the neighborhood iterator based on type |
CNNTypeM< dim, T, CellListImpl, PartIt, VL_CRS_SYMMETRIC > | Get the neighborhood iterator based on type |
CNNTypeM< dim, T, CellListImpl, PartIt, VL_SYMMETRIC > | Get the neighborhood iterator based on type |
CNo_check | |
Cno_edge | Class with no edge |
Cno_equation | Specify the general characteristic of system to solve |
Cno_field | Stub field |
Cno_stencil | No stencil |
Cno_transform< dim, T > | No transformation |
Cno_transform_only< dim, T > | No transformation |
CNoCheck | Class 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_test | Not on testing mode |
CNothing | Out-of-bound policy do nothing |
Ccub::NullType | A simple "NULL" marker type |
Cnumber_prop< T, np > | |
Cnumber_prop< T, 0 > | Return the number of properties the type T has |
Cobject< v > | This is a container to create a general object |
Cobject_creator< v, prp > | It create a boost::fusion vector with the selected properties |
Cobject_creator< v > | Specialization when no properties are passed |
Cobject_creator_chunking< v, prp > | |
Cobject_creator_chunking< v > | Specialization when no properties are passed |
Cobject_creator_chunking_encapsulator< T > | |
Cobject_creator_chunking_impl< v, vc, prp > | Implementation of object creator |
Cobject_creator_chunking_impl< v, vc, p1, prp... > | Implementation of object creator |
Cobject_creator_chunking_impl< v, vc, prp > | Implementation of object creator |
Cobject_creator_impl< v, vc, prp > | Implementation of object creator |
Cobject_creator_impl< v, vc, p1, prp... > | Implementation of object creator |
Cobject_creator_impl< v, vc, prp > | Implementation of object creator |
Cobject_s_di< v_src, v_dst, type_copy, prp > | It copy the properties from one object to another |
Cobject_s_di< v_src, v_dst, OBJ_ENCAP, prp... > | It copy the properties from one object to another |
Cobject_s_di< v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... > | |
Cobject_s_di< v_src, v_dst, OBJ_NORMAL, prp... > | Given a set of properties for the destination (0,1,3,5) it copy the source properties (0,1,2,3) |
Cobject_s_di_e< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_s_di_e_cnk< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_s_di_e_cnk_meta_copy_selector< T > | |
Cobject_s_di_e_cnk_meta_copy_selector< T[N1]> | |
Cobject_s_di_e_op< op, v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_s_di_e_op_cnk< op, v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_s_di_f< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_s_di_f_op< op, v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_s_di_op< op, v_src, v_dst, type_copy, prp > | It copy the properties from one object to another applying an operation |
Cobject_s_di_op< op, v_src, v_dst, OBJ_ENCAP, prp... > | It copy the properties from one object to another applying an operation |
Cobject_s_di_op< op, v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... > | It copy the properties from one object to another applying an operation |
Cobject_s_di_op< op, v_src, v_dst, OBJ_NORMAL, prp... > | Given a set of properties for the destination (0,1,3,5) it copy the source properties (0,1,2,3) applying an operation |
Cobject_si_d< v_src, v_dst, type_copy, prp > | It copy the properties from one object to another |
Cobject_si_d< v_src, v_dst, OBJ_ENCAP > | |
Cobject_si_d< v_src, v_dst, OBJ_ENCAP, prp... > | It copy the properties from one object to another |
Cobject_si_d< v_src, v_dst, OBJ_ENCAP_CHUNKING, prp... > | It copy the properties from one object to another |
Cobject_si_d< v_src, v_dst, OBJ_NORMAL, prp... > | It copy the properties from one object to another |
Cobject_si_d_e< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_si_d_e_cnk< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_si_d_e_cnk_meta_copy_selector< T > | |
Cobject_si_d_e_cnk_meta_copy_selector< T[N1]> | |
Cobject_si_d_f< v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_si_di< v_src, v_dst, type_copy, prp > | It copy the properties from one object to another applying an operation |
Cobject_si_di< v_src, v_dst, OBJ_ENCAP, prp... > | It copy the properties from one object to another applying an operation |
Cobject_si_di_e< v_src, v_dst, prp > | |
Cobject_si_di_e_op< op, v_src, v_dst, prp > | This class is a functor for "for_each" algorithm |
Cobject_si_di_op< op, v_src, v_dst, type_copy, prp > | It copy the properties from one object to another applying an operation |
Cobject_si_di_op< op, v_src, v_dst, OBJ_ENCAP, prp... > | It copy the properties from one object to another applying an operation |
CObserverFunctor< DXX, DYY > | |
Coffset_mv< dim > | It contain the offset necessary to move to coarser and finer level grids |
Cgpu::ofp_context_t | |
Cboost::numeric::odeint::ofp_operations | |
Copenfpm::ofp_storage_order | |
Con_test | [Constant fields struct definition] |
Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::OobInequalityOp< LAST_TILE > | |
Cop_ssend_gg_recv_merge | Helper 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_device | Helper class to merge data |
Cop_ssend_recv_add< op > | Helper class to add data |
Cop_ssend_recv_add_sr< sr > | Helper class to add data without serialization |
Cop_ssend_recv_add_sr< true > | Helper class to add data with serialization |
Cop_ssend_recv_merge< op, vector_type_opart > | Helper class to merge data |
Cop_ssend_recv_merge_gpu< op, vector_type_opart, vector_type_prc_offset > | Helper class to merge data |
Cop_ssend_recv_merge_gpu_impl< sr, op, vector_type_opart, vector_type_prc_offset > | Helper class to merge data without serialization |
Cop_ssend_recv_merge_gpu_impl< true, op, vector_type_opart, vector_type_prc_offset > | Helper class to merge data with serialization |
Cop_ssend_recv_merge_impl< sr, op, vector_type_opart > | Helper class to merge data without serialization |
Cop_ssend_recv_merge_impl< true, op, vector_type_opart > | Helper class to merge data with serialization |
Copenfpm::detail::multi_array::operator_arrow_proxy_openfpm< T > | |
CORB< dim, T, loc_wg, loc_pos, Box, Tree > | This class implement orthogonal recursive bisection |
Cp_box< dim, T > | It store all the boxes of the near processors in a linear array |
Cpack_pack_op< inte_layout, obj_type, Mem > | |
Cpack_request_op< inte_layout, obj_type, Mem > | |
Cpack_request_op< true, obj_type, Mem > | |
CPack_selector< T > | Pack selector |
CPack_selector_array_prim< T, impl > | |
CPack_selector_array_prim< T, true > | |
CPack_selector_impl< T, is_foundamental > | It is not a fundamental type |
CPack_selector_impl< T, true > | Select the primitive packing |
CPack_selector_known_type_impl< T, known_type > | Pack selector for unknown type |
CPack_selector_known_type_impl< T, HAS_PACKER > | |
CPack_selector_known_type_impl< T, IS_ENCAP > | |
CPack_selector_known_type_impl< T, IS_GRID > | |
CPack_selector_unknown_type_impl< T, has_noPointers > | Pack selector for unknown type |
CPack_selector_unknown_type_impl< T, 0 > | |
CPack_selector_unknown_type_impl< T, 2 > | Pack selector for unknown type |
CPack_selector_unknown_type_impl< T, 3 > | |
CPack_stat | Packing status object |
Cpack_unpack_cond_with_prp< cond, op, T, S, layout_base, prp > | There is max_prop inside |
Cpack_unpack_cond_with_prp_inte_lin< T, impl > | |
Cpack_unpack_cond_with_prp_inte_lin< T, true > | |
Cpack_with_iterator< is_complex, dim, grid, encap_src, encap_dst, boost_vct, it, dtype, prp > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Cpack_with_iterator< false, dim, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Cpack_with_iterator< true, 1, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Cpack_with_iterator< true, 2, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Cpack_with_iterator< true, 3, grid, encap_src, encap_dst, boost_vct, it, dtype, prp... > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Cpack_with_iterator_longx< dim, obj_byte, git, grid > | |
Cpack_with_iterator_longx< 2, obj_byte, git, grid > | |
Cpack_with_iterator_longx< 3, obj_byte, git, grid > | |
Cpack_with_iterator_shortx< dim, n_cpy, obj_byte, git, grid > | |
Cpack_with_iterator_shortx< 2, n_cpy, obj_byte, git, grid > | |
Cpack_with_iterator_shortx< 3, n_cpy, obj_byte, git, grid > | |
CPacker< T, Mem, pack_type > | Packing class |
CPacker< T, Mem, PACKER_ARRAY_CP_PRIMITIVE > | |
CPacker< T, Mem, PACKER_ARRAY_PRIMITIVE > | Packer for primitives |
CPacker< T, Mem, PACKER_ENCAP_OBJECTS > | |
CPacker< T, Mem, PACKER_ENCAP_OBJECTS_CHUNKING > | |
CPacker< T, Mem, PACKER_GENERAL > | Packer class for vectors |
CPacker< T, Mem, PACKER_GRID > | Packer for grids and sub-grids |
CPacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK > | Packer class for objects |
CPacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS > | Packer for objects, with impossibility to check for internal pointers |
CPacker< T, Mem, PACKER_PRIMITIVE > | Packer for primitives |
Ccub::AlignBytes< T >::Pad | |
Cpar_struct | |
CParmetis< Graph > | Helper class to define Metis graph |
CParmetis< Graph_CSR< nm_v< dim >, nm_e > > | |
CParmetis_dist_graph | Metis graph structure |
CParmetis_graph | Metis 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_report | Class to test AMG solvers |
Cpetsc_solver< T > | In case T does not match the PETSC precision compilation create a stub structure |
Cpetsc_solver< double > | This class is able to do Matrix inversion in parallel with PETSC solvers |
CPoint< dim, T > | This class implement the point shape in an N-dimensional space |
CPoint2D_test< T > | Test structure used for several test |
CPoint< 2, double > | |
CPoint< 3, float > | |
CPoint< dim, long int > | |
CPoint< dim, unsigned int > | |
CPoint< Grid::dims, St > | |
CPoint< vector_type::dims, unsigned int > | |
Cpoint_and_gid | |
Cpoint_expression< T > | Main class that encapsulate a constant number used in a point expression |
Cpoint_expression< const T[dim]> | Specialization for a const array of dimension dim |
Cpoint_expression< openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > > | Specialization for views |
Cpoint_expression< T[dim]> | Specialization for an array of dimension dim as expression |
Cpoint_expression_op< orig, exp1, exp2, op > | Unknown operation specialization |
Cpoint_expression_op< orig, exp1, exp2, POINT_DIV > | Division operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_MUL > | Multiplication operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_MUL_POINT > | Multiplication operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_NORM > | Point norm operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_NORM2 > | Point square norm operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_NORM_INF > | Point norm Infinity operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_SUB > | Subtraction operation |
Cpoint_expression_op< orig, exp1, exp2, POINT_SUB_UNI > | Expression that subtract two points |
Cpoint_expression_op< orig, exp1, exp2, POINT_SUM > | Sum operation |
CPoint_orig< T > | Definition of a class Point in plain C++ and boost::vector for testing purpose |
Cpoint_scalar_process< val_type, is_sort, is_scalar > | |
Cpoint_scalar_process< val_type, is_sort, true > | |
CPoint_test< T > | Test structure used for several test |
CPoint_test_prp< T > | Test structure used for several test |
CPoint_test_scal< T > | Point test with only scalar properties |
Cpointer_check | |
Cpoisson_nn_helm | |
CPolarEv< DX, DY, DXX, DXY, DYY > | |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy100 | SM10 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy100 | SM10 |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy100 | SM10 |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy110 | SM11 |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy110 | SM11 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy110 | SM11 |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy130 | SM13 |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy130 | SM13 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy130 | SM13 |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy130 | SM13 |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy200 | SM20 |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy200 | SM20 |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy200 | SM20 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy200 | SM20 |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy200 | SM20 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy200 | SM20 |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy300 | SM30 |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy300 | SM30 |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy300 | SM30 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy300 | SM30 |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy300 | SM30 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy300 | SM30 |
Ccub::DeviceRleDispatch< InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, OffsetT >::Policy350 | SM35 |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy350 | SM35 |
Ccub::DispatchReduceByKey< KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::Policy350 | SM35 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy350 | SM35 |
Ccub::DispatchSelectIf< InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, NumSelectedIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::Policy350 | SM35 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy350 | SM35 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy370 | SM37 |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::Policy500 | SM50 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy500 | SM50 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy520 | SM520 |
Ccub::DispatchScan< InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::Policy600 | SM600 |
Ccub::DispatchSpmv< ValueT, OffsetT >::Policy600 | SM60 |
Cpopulate_cell_list_no_sym_impl< is_gpu > | |
Cpopulate_cell_list_no_sym_impl< true > | |
Cpopulate_cell_list_sym_impl< is_gpu > | |
Cpopulate_cell_list_sym_impl< true > | |
CFD::pos_or_propL< grid_type, prp > | Selector for position or properties left side expression |
Cpos_or_propL< vector, prp > | Selector for position or properties left side expression |
Cpos_or_propL< vector, PROP_POS > | Selector for position or properties left side |
Cpos_or_propL_ker< vector, prp > | Selector for position or properties left side expression |
Cpos_or_propL_ker< vector, PROP_POS > | Selector for position or properties left side |
Cpos_or_propR< vector, prp > | Selector for position or properties right side position |
Cpos_or_propR< vector, PROP_POS > | Selector for position or properties right side |
Cpos_pc | |
Cpos_v< vector_pos_type > | Structure that contain a reference to a vector of particles |
Cpos_val< dim, T > | |
Cpost_increment_sub_impl< dim, stl_type, linearizer > | |
►Ctsl::power_of_two_growth_policy | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< size_t, size_t >, KeySelect, ValueSelect, std::hash< size_t >, std::equal_to< size_t >, std::allocator< std::pair< size_t, size_t > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< Key, T >, KeySelect, ValueSelect, std::hash< Key >, std::equal_to< Key >, std::allocator< std::pair< Key, T > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< std::pair< const Key, T >, KeySelect, ValueSelect, std::hash< Key >, std::equal_to< Key >, std::allocator< std::pair< const Key, T > >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ctsl::detail_hopscotch_hash::hopscotch_hash< Key, KeySelect, void, std::hash< Key >, std::equal_to< Key >, std::allocator< Key >, 62, false, tsl::power_of_two_growth_policy, overflow_container_type > | |
Ccub::PowerOfTwo< N > | Statically determine if N is a power-of-two |
CPPInterpolation< particlesFrom_type, particlesTo_type > | Class for Creating the DCPSE Operator For the function approximation objects and computes DCPSE Kernels |
Ccub::BlockRadixRank< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, MEMOIZE_OUTER_SCAN, INNER_SCAN_ALGORITHM, SMEM_CONFIG, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::PrefixCallBack | |
Ctsl::prime_growth_policy | |
Cprint_warning_on_adjustment< dim, linearizer > | Declaration print_warning_on_adjustment |
Cproc_box_id | Processor 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_prp | Process the particle without properties |
Cproc_without_prp_device | Process the particle without properties |
Cprocess_data_block< T, dim, blockEdgeSize > | |
Cprocess_data_block< T[N1], dim, blockEdgeSize > | |
CProcess_keys_grid< dim, CellList > | Class for an hilbert order processing of cell keys for CellList_gen implementation |
CProcess_keys_hilb< dim, CellList > | Class for an hilbert order processing of cell keys for CellList_gen implementation |
CProcess_keys_lin< dim, CellList > | |
Cprocess_receive_mem_traits_inte< sT, layout_base, Memory > | This class is a functor for "for_each" algorithm |
CCartDecomposition< dim, T, Memory, layout_base, Distribution >::processor_id | Class to select the returned id by ghost_processorID |
Cprop_id< prp_id > | |
Cprop_out_edge< Graph > | This class is a functor for "for_each" algorithm |
Cprop_out_g< ele_g, St > | This class is a functor for "for_each" algorithm |
Cprop_out_v< ele_v, St > | This class is a functor for "for_each" algorithm |
Cprop_out_v_pvtp< ele_v, St > | This class is a functor for "for_each" algorithm |
Cprop_out_vertex< Graph > | This class is a functor for "for_each" algorithm |
Cprop_output< has_attributes, Graph, i > | This class specialize functions in the case the type T has or not defined attributes |
Cprop_output< false, Graph, i > | This class specialize functions in the case the type T has not defined attributes |
Cprop_output_array_scalar_selector_edge< is_array > | Property writer for scalar and vector |
Cprop_output_array_scalar_selector_edge< true > | Property writer for vector |
Cprop_output_array_scalar_selector_edge_fill_vertex< is_array > | Property writer for scalar and vector, it fill the vertex data (needed for edge representation in vtk) |
Cprop_output_array_scalar_selector_edge_fill_vertex< true > | Property writer for vector |
Cprop_output_array_scalar_selector_vertex< is_array > | Property writer for scalar and vector |
Cprop_output_array_scalar_selector_vertex< true > | Property writer for vector |
Cprop_write_out< dim, T > | Write the vectror property |
Cprop_write_out< 1, T > | Write the scalar property |
Cprop_write_out_new< dim, T > | Write the vectror property |
Cprop_write_out_new< 1, T > | Write the scalar property |
CpropCheckINF< vector > | This class is a functor for "for_each" algorithm |
CpropCheckNAN< vector > | This class is a functor for "for_each" algorithm |
Cprp_all_zero< T, is_zero, prp > | Structure to convert a variadic template into boost::mpl::vector |
Cprp_all_zero< T, true, prp ... > | |
CPSEError | |
Cptr_info | |
Cpush_back_op< is_t, is_s, T, S > | |
Cpush_back_op< false, false, T, S > | |
Cpush_back_op< false, true, T, S > | |
Cpush_back_op< true, true, T, S > | |
Cpush_back_op_neste< bool, T, S > | Pack/add function selector |
Cpush_back_op_neste< true, T, S > | Pack/add function selector |
Cpush_back_std_op_neste< bool, T, S > | Pack/add function selector |
Cpush_back_std_op_neste< true, T, S > | |
CPV_cl | |
Cr_type_dim< op1_dim, op2_dim, op > | It return the dimansionality of the operation given the dimensionality of the 2 operators |
Cr_type_dim< 1, 1, POINT_DIV > | Scalar / scalar = scalar |
Cr_type_dim< 1, 1, POINT_MUL > | Scalar * scalar = scalar |
Cr_type_dim< 1, 1, POINT_SUB > | Scalar - scalar = scalar |
Cr_type_dim< 1, 1, POINT_SUM > | Scalar + scalar = scalar |
Cr_type_dim< op1_dim, op2_dim, POINT_MUL_POINT > | Point * Point = scalar |
Cr_type_p< r, orig > | Return type of the expression |
Cr_type_p< 1, orig > | Return type of the expression |
Crank_gen< T, is_point > | Like std::rank but it also work for openfpm structures like Point where it return 1 |
Crank_gen< T, true > | |
Craw_read< dim, Tg > | This class is a functor for "for_each" algorithm |
Crcv_rm | |
Cred | Temporal buffer for reductions |
Cred_max< prp > | Get the reference of the selected element |
Cred_min< prp > | |
Cred_sum< prp > | |
CRedist_options< phi_type > | Structure to bundle options for redistancing |
CRedist_options< double > | |
CRedistancingSussman< grid_in_type, phi_type > | Class for reinitializing a level-set function into a signed distance function using Sussman redistancing |
Creduce_op< aggr_vect, reduction_vectors > | This class is a functor for "for_each" algorithm |
Creduce_op_final< aggr_vect, red_type, reduction_vectors > | This class is a functor for "for_each" algorithm |
Creduce_type< T > | In general a reduction of a type T produce a type T |
Creduce_type< double[]> | A reduction operation on an array of double is a double |
Creduce_type< float[]> | A reduction operation on an array of float is a float |
Creduce_type< int[]> | A reduction operation on an array of int is an int |
Ccub::ReduceByKeyOp< ReductionOpT > | < Binary reduction operator to apply to values |
Ccub::ReduceByKeyOp< cub::Sum > | |
Ccub::ReduceByKeyScanTileState< ValueT, KeyT, SINGLE_WORD > | |
Ccub::ReduceByKeyScanTileState< ValueT, KeyT, true > | |
Ccub::ReduceBySegmentOp< ReductionOpT > | Reduce-by-segment functor |
Ccub::ReduceBySegmentOp< cub::Sum > | |
Cref_wrap< T > | |
Ccub::CacheModifiedOutputIterator< MODIFIER, ValueType, OffsetT >::Reference | |
Cboost::numeric::odeint::ofp_operations::rel_error< Fac1 > | |
Cboost::numeric::odeint::ofp_operations::rel_error_l2< Fac1 > | |
Cboost::numeric::odeint::ofp_operations::rel_error_l2_2< Fac1 > | |
Cboost::numeric::odeint::ofp_operations::rel_error_max< Fac1 > | |
Cboost::numeric::odeint::ofp_operations::rel_error_max2< Fac1 > | |
Cremove_attributes_const_ref< T > | T_to_memory_c is a metafunction that given T it convert it into |
Ccub::RemoveQualifiers< Tp, Up > | Removes const and volatile qualifiers from type Tp |
Ccub::RemoveQualifiers< Tp, const Up > | |
Ccub::RemoveQualifiers< Tp, const volatile Up > | |
Ccub::RemoveQualifiers< Tp, volatile Up > | |
Copenfpm::reorder< Ti > | |
Creplace_< Tdst, Tsrc > | This structure define the operation add to use with copy general |
Creport_cell_list_func_tests | |
Creport_cell_list_preord_tests | |
Creport_grid_copy_func_tests | |
Creport_grid_iterator_test | |
Creport_sparse_grid_tests | |
Creport_vector_func_tests | |
Creport_vector_gg_map_tests | |
Creport_verlet_tests | |
Cresult_box< dim > | Result of the itersection of a box with an array of boxes |
CRGB | RGB color struct |
CRhsBlockWrapper< BlockT > | |
CRhsBlockWrapper< BlockT[N1][N2]> | |
CRhsBlockWrapper< BlockT[N]> | |
CRHSFunctor< DXX, DYY > | |
Crid | |
Cgrid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid >::rp_id | |
Crval< T, impl > | It store one row value of a vector |
Crval< T, EIGEN_RVAL > | It store one row value of a vector |
Crval< T, PETSC_RVAL > | It store one row value of a vector |
Csadd_< prp > | |
Csadd_block_< prp, blockLength > | |
Copenfpm::scalar_block_implementation_switch< impl, block_functor > | Functor switch to select the vector sparse for standars scalar and blocked implementation |
Copenfpm::scalar_block_implementation_switch< 2, block_functor > | |
Cboost::numeric::odeint::ofp_operations::scale< Fac1 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum1< Fac1 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum10< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum11< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum12< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11, Fac12 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum13< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11, Fac12, Fac13 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum14< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9, Fac10, Fac11, Fac12, Fac13, Fac14 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum2< Fac1, Fac2 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum3< Fac1, Fac2, Fac3 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum4< Fac1, Fac2, Fac3, Fac4 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum5< Fac1, Fac2, Fac3, Fac4, Fac5 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum6< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum7< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum8< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum9< Fac1, Fac2, Fac3, Fac4, Fac5, Fac6, Fac7, Fac8, Fac9 > | |
Cboost::numeric::odeint::ofp_operations::scale_sum_swap2< Fac1, Fac2 > | |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::ScaleTransform | |
Ccub::ScanTileState< T, SINGLE_WORD > | |
►Ccub::ScanTileState< KeyValuePair< KeyT, ValueT > > | |
Ccub::ReduceByKeyScanTileState< ValueT, KeyT, false > | |
Ccub::ScanTileState< T, false > | |
Ccub::ScanTileState< T, true > | |
Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::_TempStorage::Aliasable::ScatterAliasable | |
Cse_class3_vector< Np, dim, T, Decomposition, vector > | This class check for inconsistency access |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::SearchTransform< LevelIteratorT > | |
Cselector_chunking_prp_has_zero_size< is_not_zero, T, T_nc, prp > | |
Cselector_chunking_prp_has_zero_size< true, T, T_nc, prp... > | |
Cselvg< is_free > | |
Cselvg< false > | |
CDistGraph_CSR< V, E, Memory, layout_v, layout_e, layout_v_base, layout_e_base, grow_p >::SendGraphPack | Struct containing the (sub)graph to send |
Cseq_traits_impl< Seq > | Implementation of seq_traits |
Cset_buf_pointer_for_each_prop< sT > | This class is a functor for "for_each" algorithm |
Cset_buf_size_for_each_prop< sT > | This class is a functor for "for_each" algorithm |
Cset_compile_condition< to_set > | |
Cset_compile_condition< false > | |
Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::set_mem_retained_buffers< inte_or_lin, send_vector, v_mpl > | |
Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::set_mem_retained_buffers< true, send_vector, v_mpl > | |
Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base >::set_mem_retained_buffers_inte< send_vector, v_mpl > | Set the buffer for each property |
Cset_zero< rtype > | Meta-function to return a compatible zero-element |
Cset_zero< Point< dim, T > > | Create a point with all compunent set to zero |
CsetBackground_impl< aggrT_src, local_grids_type > | This class is a functor for "for_each" algorithm |
Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE5< BinaryOpT, const > | |
Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE6< BinaryOpT, > | |
Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE7< BinaryOpT, const > | |
Ccub::BinaryOpHasIdxParam< T, BinaryOp >::SFINAE8< BinaryOpT, > | |
Csgrid_cpu< dim, T, S, grid_lin, layout, layout_base, chunking > | |
Cshift< dim, T > | |
CCartDecomposition< dim, T, Memory, layout_base, Distribution >::shift_id | Class to select the returned id by ghost_processorID |
Cshift_only< dim, T > | |
Cshift_ph< bit_phases, cnt_type > | |
Cshift_vect_converter< dim, T, Memory, layout_base > | In case of high dimensions shift vector converter |
Cshift_vect_converter< dim, St, Memory, layout_base > | |
Cshift_vect_converter< dim, T, HeapMemory, memory_traits_lin > | |
Cshift_vect_converter< dim, typename grid_in_type::stype, Memory, layout_base > | |
CSimpleRNG | SimpleRNG is a simple random number generator based on George Marsaglia's MWC (multiply with carry) generator. Although it is very simple, it passes Marsaglia's DIEHARD series of random number generator tests |
CSkeletonStencil< dim, p_src, p_dst > | |
Cskip_init< np, T > | |
Cskip_init< true, T > | |
CsLeft_< prp > | |
Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, Enable > | |
Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 0) &&(MinBits<=8)>::type > | |
Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 16) &&(MinBits<=32)>::type > | |
Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 32) &&(MinBits<=64)>::type > | |
Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< MinBits, typename std::enable_if<(MinBits > 8) &&(MinBits<=16)>::type > | |
Ctsl::detail_hopscotch_hash::smallest_type_for_min_bits< NeighborhoodSize+NB_RESERVED_BITS_IN_NEIGHBORHOOD > | |
Csmax_< prp > | |
Csmax_block_< prp, blockLength > | |
Csmin_< prp > | |
Csmin_block_< prp, blockLength > | |
CsolError | It contain statistic of the error of the calculated solution |
Cpetsc_solver< double >::solv_bench_info | It contain the benchmark information for each solver |
Cspace_key_dx< dim, T > | Grid_key_dx is the key to access any element in the grid |
CSpaceDistribution< dim, T > | Class that distribute sub-sub-domains across processors using an hilbert curve to divide the space |
Csparse_grid_bck_value< chunk_def > | |
Csparse_grid_bck_wrapper_impl< base > | |
Csparse_grid_bck_wrapper_impl< openfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > > | |
Csparse_grid_gpu_index< SparseGridGpu_type > | Element index contain a data chunk index and a point index |
Csparse_grid_section< SparseGridType > | |
Copenfpm::sparse_index< index_type > | |
Copenfpm::sparse_vector_reduction< vector_data_type, vector_index_type, vector_index_type2, vector_reduction, block_functor, impl2, pSegment > | This class is a functor for "for_each" algorithm |
Copenfpm::sparse_vector_reduction_cpu< vector_data_type, vector_index_type, vector_index_type_reo, vector_reduction, impl > | This class is a functor for "for_each" algorithm |
Copenfpm::sparse_vector_reduction_cpu_impl< reduction_type, vector_reduction, T, impl, red_type > | |
Copenfpm::sparse_vector_reduction_cpu_impl< reduction_type, vector_reduction, T, impl, red_type[N1]> | |
Copenfpm::sparse_vector_reduction_solve_conflict_assign_cpu< encap_src, encap_dst, vector_reduction > | This class is a functor for "for_each" algorithm |
Copenfpm::sparse_vector_reduction_solve_conflict_reduce_cpu< encap_src, encap_dst, vector_reduction, impl > | This class is a functor for "for_each" algorithm |
Copenfpm::sparse_vector_reduction_solve_conflict_reduce_cpu_impl< impl, vector_reduction, T, red_type > | |
Copenfpm::sparse_vector_reduction_solve_conflict_reduce_cpu_impl< impl, vector_reduction, T, red_type[N1]> | |
Copenfpm::sparse_vector_special< vector_data_type, vector_index_type, vector_reduction > | This class is a functor for "for_each" algorithm |
CSparseGridGpu_iterator< dim, SparseGridType > | |
CSparseGridGpu_iterator_sub< dim, SparseGridType > | |
Csparsegridgpu_pack_impl< AggregateT, dataBuffer_type, prp > | This class is a functor for "for_each" algorithm |
Csparsegridgpu_pack_request< AggregateT, prp > | This class is a functor for "for_each" algorithm |
Csparsegridgpu_unpack_impl< AggregateT, dataBuffer_type, prp > | This class is a functor for "for_each" algorithm |
CSparseMatrix< T, id_t, DEFAULT_MATRIX > | Sparse Matrix implementation |
CSparseMatrix< T, id_t, EIGEN_BASE > | |
CSparseMatrix< T, id_t, PETSC_BASE > | Sparse Matrix implementation, that map over Eigen |
CSphere< dim, T > | This class implement the Sphere concept in an N-dimensional space |
Ccub::SpmvParams< ValueT, OffsetT > | < Signed integer type for sequence offsets |
CsRight_< prp > | |
Cstag_create_and_add_grid< dim, st_grid, St > | It create separated grid for each properties to write them into a file |
Cstag_set_position< dim, v, has_pM > | This class is a functor for "for_each" algorithm |
Cstag_set_position< dim, v, false > | This class is a functor for "for_each" algorithm |
Cstate_type_1d_ofp | A 1d Odeint and Openfpm compatible structure |
Cstate_type_2d_ofp | A 2d Odeint and Openfpm compatible structure |
Cstate_type_3d_ofp | A 3d Odeint and Openfpm compatible structure |
Cstate_type_4d_ofp | A 4d Odeint and Openfpm compatible structure |
Cstate_type_5d_ofp | A 5d Odeint and Openfpm compatible structure |
Cstate_type_ofpm_add_elements< counter, state_type, list > | |
Cstate_type_ofpm_add_elements< 0, state_type, list ... > | |
Cstate_type_ofpm_add_elements< n_state-1, state_type, state_type > | |
Cstate_type_ofpm_impl< n_state, state_type > | |
Cstatic_array< N, T > | |
Cstd_array_copy_chunks< prop, T > | |
Cstd_array_copy_chunks< prop, T[N1]> | |
Cstd_array_vector_view< ArrTypeView > | |
CSparseGridGpuKernels::stencil_conv_func_impl< dim > | |
CSparseGridGpuKernels::stencil_conv_func_impl< 2 > | |
CSparseGridGpuKernels::stencil_conv_func_impl< 3 > | |
CSparseGridGpuKernels::stencil_cross_func< dim, p_src, p_dst, stencil_size > | |
CSparseGridGpuKernels::stencil_cross_func_conv< dim, n_loop, p_src, p_dst, stencil_size > | |
CSparseGridGpuKernels::stencil_cross_func_conv_block_read< dim, n_loop, p_src, p_dst, stencil_size > | |
CSparseGridGpuKernels::stencil_cross_func_impl< dim > | |
CSparseGridGpuKernels::stencil_func_conv2< dim, n_loop, p_src1, p_src2, p_dst1, p_dst2, stencil_size > | |
CSparseGridGpuKernels::stencil_func_conv2_b< dim, n_loop, p_src1, p_src2, p_dst1, p_dst2, stencil_size > | |
CSparseGridGpuKernels::stencil_func_conv3_b< dim, n_loop, p_src1, p_src2, p_src3, p_dst1, p_dst2, p_dst3, stencil_size > | |
Cstencil_offset_compute< dim, Np > | Structure for stencil iterator |
Cstore_reduce_op_final< red_type, encap_type, reduction_vectors > | This class is a functor for "for_each" algorithm |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< _POLICY, DUMMY > | Store helper |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_DIRECT, DUMMY > | |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_TRANSPOSE, DUMMY > | |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_VECTORIZE, DUMMY > | |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_WARP_TRANSPOSE, DUMMY > | |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED, DUMMY > | |
Cstriding< dim > | |
Copenfpm::stub_block_functor | |
Cstub_or_real< T, dims, stype, decomposition, stub > | In case of testing return a stub grid |
Cstub_or_real< last, last::dims, typenamelast::stype, typenamelast::b_grid::decomposition::extended_type > | |
Cstub_or_real< T, dims, stype, decomposition, false > | Case when we are not on testing |
CFD::sub | |
Cgrid_dist_iterator_sub< dim, device_grid >::sub_set | |
Csubar_dim< vmpl > | Return the dimension of the sub_array |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector >::subarray< NDims > | |
Copenfpm::subarray_gen_openfpm< Array, N, vector > | |
Csublin< dim, chunk > | |
Csublin< 1, chunk > | |
Csublin< 2, chunk > | |
Csublin< 3, chunk > | |
Csublin< 4, chunk > | |
Csublin< 5, chunk > | |
Csublin< 6, chunk > | |
Csublin< 7, chunk > | |
Csublin< 8, chunk > | |
Csubsub< dim > | Sub-sub-domain |
Csubsub_lin< dim > | Linearized version of subsub |
CFD::subuni | |
Ccub::Sum | Default sum functor |
CFD::sum | |
Csum< expr > | It model an expression expr1 + ... exprn |
Csum_ele< bint, ele > | |
Csum_ele< boost::mpl::int_< op1 >, ele > | |
Csum_ele< boost::mpl::na, ele > | |
Csum_functor_value< v_expr > | Sum functor value |
CSupport | |
CSupportBuilder< vector_type, vector_type2 > | |
CSupportBuilderGPU< vector_type > | |
Cswitch_copy_host_to_device< T_type, prp > | This class is a functor for "for_each" algorithm |
Cswitcher_get_v< vector, impl > | |
Cswitcher_get_v< vector, comp_dev > | |
Ccub::SwizzleScanOp< ScanOp > | Binary operator wrapper for switching non-commutative scan arguments |
Csys_nn | |
Csys_pp | |
Csyss_nn | |
Csyss_pp | |
CSystem< dim, nvf, ncf, eqs > | System of equations |
Ct_to_memory_c< T > | Meta-function t_to_memory_c |
Ct_to_memory_c_impl< T > | Partial specialization for scalar N=0 |
Ct_to_memory_c_impl< T[N1]> | Partial specialization for N=1 |
Ct_to_memory_c_impl< T[N1][N2]> | Partial specialization for N=2 |
Ct_to_memory_c_impl< T[N1][N2][N3]> | Partial specialization for N=3 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6]> | Partial specialization for N=6 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7]> | Partial specialization for N=7 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8]> | Partial specialization for N=8 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9]> | Partial specialization for N=9 |
Ct_to_memory_c_impl< T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]> | Partial specialization for N=10 |
Ct_to_memory_c_red< T > | Meta-function t_to_memory_c_red |
Ct_to_memory_c_red_impl< T > | Partial specialization for scalar N=0 |
Ct_to_memory_c_red_impl< T[N1]> | Partial specialization for N=1 |
Ct_to_memory_c_red_impl< T[N1][N2]> | Partial specialization for N=2 |
Ct_to_memory_c_red_impl< T[N1][N2][N3]> | Partial specialization for N=3 |
Ct_to_memory_c_red_impl< T[N1][N2][N3][N4]> | Partial specialization for N=4 |
Ct_to_memory_c_red_impl< T[N1][N2][N3][N4][N5]> | Partial specialization for N=5 |
Ccub::BlockHistogramAtomic< BINS >::TempStorage | Shared memory storage layout type |
Ccub::TempStorage | |
Ccub::WarpScanShfl< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorage | Shared memory storage layout type |
Ctensor< T, s1, s2, s3 > | |
Ctensor< int, s1, s2, s3 > | |
Ctest_box_vpack | |
Ctest_chunking3 | |
Ctest_grid_type_no_def | |
Ctest_grid_type_normal | |
Ctest_grid_type_staggered | [Define structures] |
Ctest_has_attributes | [Check has_posMask struct definition] |
Ctest_has_max_prop | Test type for has_max_prop |
Ctest_has_no_max_prop | Test type for has_max_prop |
Ctest_has_posMask | [Check has_posMask struct definition] |
Ctest_no_attributes | |
Ctest_no_has_posMask | Test 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 > | |
Ctimer | Class for cpu time benchmarking |
CTimes | Time structure for statistical purposes |
Cto_boost_vmpl< id > | |
Cto_int_sequence< N, M > | |
Cto_memory_multi_array_ref_view< T > | OpenFPM use memory_c<multi_array<T> ..... > to implement the structure of array layout |
Cto_variadic_const_impl< c, end, ele, exit, vars > | Recursive specialization of to_variadic |
Cto_variadic_const_impl< c, end, ele, true, vars ... > | Terminator of to_variadic |
Cto_variadic_impl< c, end, exit, vars > | Recursive specialization of to_variadic |
Cto_variadic_impl< c, end, true, vars ... > | Terminator of to_variadic |
CtoKernel_transform< layout_base, T, int > | |
CtoKernel_transform< layout_base, T, 0 > | |
CtoKernel_transform< layout_base, T, 1 > | |
CtoPoint< dim, St > | |
Ccub::CachingDeviceAllocator::TotalBytes | |
Ctransform_if_temporal< v_exp > | |
Ctransform_if_temporal< vector_dist_expression< 0, openfpm::vector_gpu< aggregate< T > > > > | |
Ccub::TransformInputIterator< ValueType, ConversionOp, InputIteratorT, OffsetT > | A random-access input wrapper for transforming dereferenced values |
Ctriplet< T, impl > | It store the non zero elements of the matrix |
Ctriplet< T, EIGEN_TRIPLET > | It store one non-zero element in the sparse matrix |
Ctriplet< T, PETSC_BASE > | It store one non-zero element in the sparse matrix |
►Cstd::true_type | |
Chas_attributes< T, typename Void< decltype(T::attributes::name[0])>::type > | Has_attributes check if a type has defined an internal structure with attributes |
Chas_base_to_copy< T, typename Void< typename T::base_to_copy >::type > | Has_data check if a type has defined a member data |
Chas_check_device_pointer< T, typename Void_dev< typename T::yes_has_check_device_pointer >::type > | Has_check_device_pointer check if a type has defined a member yes_has_check_device_pointer |
Chas_coordtype< T, typename Void< typename T::coord_type >::type > | Has_data check if a type has defined a member data |
Chas_data< T, typename Void< decltype(T::data)>::type > | Has_data check if a type has defined a member data |
Chas_getGrid< T, typename Void< decltype(std::declval< T >().getGrid())>::type > | |
Chas_grid_type< T, typename Void< decltype(T::grid_type)>::type > | Has_grid_type check if T has defined the member grid_type |
Chas_init< ObjType, typename Void< typename ObjType::has_init >::type > | |
Chas_max_prop_nn< T, typename Void< decltype(T::max_prop)>::type > | Has_max_prop check if a type has defined a member max_prop |
Chas_noPointers< T, typename Void< decltype(T::noPointers())>::type > | Has_noPointers check if a type has defined a method called noPointers |
Chas_pack< ObjType, typename Void< decltype(ObjType::pack())>::type > | |
Chas_packMem< ObjType, typename Void< decltype(ObjType::packMem())>::type > | Has_PackMem check if a type has packMem() member function |
Chas_packRequest< ObjType, typename Void< decltype(ObjType::packRequest())>::type > | |
Chas_posMask< T, typename Void< decltype(T::stag_mask)>::type > | Has_posMask check if a type has defined a member stag_mask |
Chas_set_d< T, typename Void< decltype(std::declval< T >().set_d(0, 0))>::type > | Has_move check if a type has defined a method function move |
Chas_state_vector< T, typename Void< typename T::is_state_vector >::type > | |
Chas_toKernel< ObjType, typename Void< decltype(std::declval< ObjType >().toKernel())>::type > | |
Chas_typedef_type< T, typename Void< typename T::type >::type > | Has_typedef_type check if a typedef ... type inside the structure is defined |
Chas_val_pos< T, typename Void< typename T::with_position >::type > | Has_attributes check if a type has defined an internal structure with attributes |
Chas_value_type_ofp< T, typename Void< typename T::value_type >::type > | Has_value_type_ofp check if a type has defined a member value_type |
Chas_vector_kernel< T, typename Void< typename T::vector_kernel >::type > | Has_vector_kernel check if a type has defined a member data |
Chas_vtype< T, typename Void< typename T::vtype >::type > | Has_data check if a type has defined a member data |
CisDynStruct< ObjType, typename Void< decltype(ObjType::isCompressed())>::type > | |
Cis_Box< T, typename Void< typename T::yes_is_box >::type > | Check if a type T is an aggregate |
Cis_Point< T, typename Void< typename T::yes_is_point >::type > | Check if a type T is an aggregate |
Cis_aggregate< T, typename Void< typename T::yes_is_aggregate >::type > | Check if a type T is an aggregate |
Cis_const_field< T, typename Void< typename T::const_field >::type > | Is_constant check if a type define a constant field |
Cis_custom_vtk_writable< ObjType, typename Void< typename ObjType::is_vtk_writable >::type > | It check if the type is vtk writable |
Cis_encap< T, typename Void< typename T::yes_i_am_encap >::type > | Is_encap check if the type is an encap type |
Cis_expression< ObjType, typename Void< typename ObjType::is_expression >::type > | |
Cis_gpu_celllist< T, typename Void< typename T::yes_is_gpu_celllist >::type > | |
Cis_gpu_ker_celllist< T, typename Void< typename T::yes_is_gpu_ker_celllist >::type > | |
Cis_grid< T, typename Void< typename T::yes_i_am_grid >::type > | Is_grid check if the type is a grid |
Cis_layout_inte< T, typename Void< typename T::yes_is_inte >::type > | Is_layout_inte |
Cis_layout_mlin< T, typename Void< typename T::yes_is_tlin >::type > | Is_layout_mlin |
Cis_openfpm_native< T, true > | |
Cis_testing< T, typename Void< typename T::testing >::type > | Is_testing check if a struct T has testing member defined |
Cis_vector< T, typename Void< typename T::yes_i_am_vector >::type > | Is_grid check if the type is a vector |
Cis_vector_dist< T, typename Void< typename T::yes_i_am_vector_dist >::type > | Is_grid check if the type is a vector |
Cis_vector_native< T, typename Void< typename std::remove_reference< T >::type::yes_i_am_vector_native >::type > | Is_grid check if the type is a vector |
Cis_vtk_vector_dims< ObjType, typename Void< decltype(ObjType::dims) >::type > | It check if the type is vtk writable |
Copenfpm::is_multi_array< T, typename Void< typename T::yes_is_multi_array >::type > | Has_noPointers check if a type has defined a method called noPointers |
Ctsl::detail_hopscotch_hash::has_is_transparent< T, typename make_void< typename T::is_transparent >::type > | |
Ctsl::detail_hopscotch_hash::has_key_compare< T, typename make_void< typename T::key_compare >::type > | |
Ccub::DipatchHistogram< NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, LevelT, OffsetT >::TScale< NOMINAL_ITEMS_PER_THREAD > | |
►Cvalue_accessor_generator_openfpm::type | |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< base, NumDims, Tv > | |
►Cvalue_accessor_generator_openfpm::type | |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, T * > | |
►Cvalue_accessor_generator_openfpm::type | |
►Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vector > | |
►Copenfpm::const_multi_array_ref_openfpm< T, NumDims, vector, T * > | |
Copenfpm::multi_array_ref_openfpm< T, NumDims, vector > | |
Copenfpm::const_multi_array_ref_openfpm< base, NumDims, Tv, base * > | |
►Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, T * > | |
Copenfpm::detail::multi_array::multi_array_view_openfpm< T, NumDims > | |
►Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vector, T * > | |
Copenfpm::detail::multi_array::sub_array_openfpm< T, NumDims, vector > | |
Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vmpl, T * > | |
►Copenfpm::const_multi_array_ref_openfpm< T, NumDims, vector, TPtr > | |
Copenfpm::multi_array_ref_openfpm< base, boost::mpl::size< T >::value, Tv > | |
Copenfpm::detail::multi_array::const_multi_array_view_openfpm< T, NumDims, vector > | |
►Copenfpm::detail::multi_array::const_sub_array_openfpm< T, NumDims, vector, TPtr > | |
Copenfpm::detail::multi_array::sub_array_openfpm< T, 1, vmpl > | |
►Cvalue_accessor_generator_openfpm::type | |
Copenfpm::detail::multi_array::multi_array_impl_base_openfpm< T, NumDims, vmpl > | |
►Cvalue_accessor_generator_openfpm::type | |
Copenfpm::detail::multi_array::array_iterator_openfpm< T, TPtr, NumDims, vector, Reference, IteratorCategory > | |
Copenfpm::detail::multi_array::associated_types_openfpm< T, NumDims, vector > | |
Ctype_identity< T > | |
Ctype_is_one | |
CtypeCheck< tcheck, foundamental > | Type check in case of unknown type |
CtypeCheck< tcheck, true > | Type check in case of supported type |
CtypeCheck< tcheck[N1], foundamental > | Type check in case of supported array type |
CtypeCheck< tcheck[N1][N2], foundamental > | Type check in case of supported 2D array type |
CUIntDivCeil< numerator, denominator > | |
Cumfpack_solver< T > | Stub when library compiled without eigen |
Cumfpack_solver< double > | Stub when library compiled without eigen |
►Cstd::unary_function | |
Ckey_hash | Structure required for the Sph Harmonic amplitude dictionary arguments |
Ccub::Uninitialized< T > | A storage-backing wrapper that allows types with non-trivial constructors to be aliased in unions |
►Ccub::Uninitialized< _TempStorage > | |
Ccub::AgentHistogram< AgentHistogramPolicyT, PRIVATIZED_SMEM_BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, PrivatizedDecodeOpT, OutputDecodeOpT, OffsetT, PTX_ARCH >::TempStorage | Temporary storage type (unionable) |
Ccub::AgentRadixSortDownsweep< AgentRadixSortDownsweepPolicy, IS_DESCENDING, KeyT, ValueT, OffsetT >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::AgentRadixSortUpsweep< AgentRadixSortUpsweepPolicy, KeyT, OffsetT >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::AgentReduce< AgentReducePolicy, InputIteratorT, OutputIteratorT, OffsetT, ReductionOp >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::AgentReduceByKey< AgentReduceByKeyPolicyT, KeysInputIteratorT, UniqueOutputIteratorT, ValuesInputIteratorT, AggregatesOutputIteratorT, NumRunsOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::TempStorage | |
Ccub::AgentRle< AgentRlePolicyT, InputIteratorT, OffsetsOutputIteratorT, LengthsOutputIteratorT, EqualityOpT, OffsetT >::TempStorage | |
Ccub::AgentScan< AgentScanPolicyT, InputIteratorT, OutputIteratorT, ScanOpT, InitValueT, OffsetT >::TempStorage | |
Ccub::AgentSegmentFixup< AgentSegmentFixupPolicyT, PairsInputIteratorT, AggregatesOutputIteratorT, EqualityOpT, ReductionOpT, OffsetT >::TempStorage | |
Ccub::AgentSelectIf< AgentSelectIfPolicyT, InputIteratorT, FlagsInputIteratorT, SelectedOutputIteratorT, SelectOpT, EqualityOpT, OffsetT, KEEP_REJECTS >::TempStorage | |
Ccub::AgentSpmv< AgentSpmvPolicyT, ValueT, OffsetT, HAS_ALPHA, HAS_BETA, PTX_ARCH >::TempStorage | Temporary storage type (unionable) |
Ccub::BlockAdjacentDifference< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockDiscontinuity} |
Ccub::BlockDiscontinuity< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockDiscontinuity} |
►Ccub::BlockExchange< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, WARP_TIME_SLICING, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockExchange} |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_TRANSPOSE, DUMMY >::_TempStorage | Shared memory storage layout type |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_WARP_TRANSPOSE, DUMMY >::_TempStorage | Shared memory storage layout type |
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 >::_TempStorage | Shared memory storage layout type |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_TRANSPOSE, DUMMY >::_TempStorage | Shared memory storage layout type |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_WARP_TRANSPOSE, DUMMY >::_TempStorage | Shared memory storage layout type |
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 >::_TempStorage | Shared memory storage layout type |
Ccub::BlockHistogram< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockHistogram} |
Ccub::BlockHistogramSort< T, BLOCK_DIM_X, ITEMS_PER_THREAD, BINS, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_TRANSPOSE, DUMMY >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::LoadInternal< BLOCK_LOAD_WARP_TRANSPOSE, DUMMY >::TempStorage | Alias wrapper allowing storage to be unioned |
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 >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockLoad< InputT, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockLoad} |
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 >::TempStorage | \smemstorage{BlockScan} |
Ccub::BlockRadixRankMatch< BLOCK_DIM_X, RADIX_BITS, IS_DESCENDING, INNER_SCAN_ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockScan} |
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 >::TempStorage | \smemstorage{BlockRadixSort} |
Ccub::BlockRakingLayout< T, BLOCK_THREADS, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockReduce< T, BLOCK_DIM_X, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockReduce} |
Ccub::BlockReduceRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockReduceRakingCommutativeOnly< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockReduceWarpReductions< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockScan< T, BLOCK_DIM_X, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockScan} |
Ccub::BlockScanRaking< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, MEMOIZE, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockScanWarpScans< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockShuffle< T, BLOCK_DIM_X, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockShuffle} |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_TRANSPOSE, DUMMY >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::StoreInternal< BLOCK_STORE_WARP_TRANSPOSE, DUMMY >::TempStorage | Alias wrapper allowing storage to be unioned |
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 >::TempStorage | Alias wrapper allowing storage to be unioned |
Ccub::BlockStore< T, BLOCK_DIM_X, ITEMS_PER_THREAD, ALGORITHM, BLOCK_DIM_Y, BLOCK_DIM_Z, PTX_ARCH >::TempStorage | \smemstorage{BlockStore} |
Ccub::TilePrefixCallbackOp< T, ScanOpT, ScanTileStateT, PTX_ARCH >::TempStorage | |
Ccub::WarpExchange< T, ITEMS_PER_THREAD, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorage | \smemstorage{WarpExchange} |
Ccub::WarpReduce< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorage | \smemstorage{WarpReduce} |
Ccub::WarpReduceSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorage | |
Ccub::WarpScan< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorage | \smemstorage{WarpScan} |
Ccub::WarpScanSmem< T, LOGICAL_WARP_THREADS, PTX_ARCH >::TempStorage | |
Ccub::Uninitialized< cub::KeyValuePair[TILE_ITEMS+1]> | |
Ccub::Uninitialized< ItemExchangeT > | |
Ccub::Uninitialized< KeyValuePair< OffsetT, LengthT >[WARPS]> | |
Ccub::Uninitialized< OuterScanArray > | |
►Ccub::UnitWord< T > | Unit-words of data movement |
Ccub::UnitWord< const T > | |
Ccub::UnitWord< const volatile T > | |
Ccub::UnitWord< volatile T > | |
Ccub::UnitWord< _TempStorage > | |
Ccub::UnitWord< char2 > | |
Ccub::UnitWord< cub::KeyValuePair > | |
Ccub::UnitWord< float2 > | |
Ccub::UnitWord< float4 > | |
Ccub::UnitWord< ItemExchangeT > | |
Ccub::UnitWord< KeyValuePair< OffsetT, LengthT > > | |
Ccub::UnitWord< OuterScanArray > | |
►Cstd::unordered_map | |
Cwrap_unordered_map< T, openfpm::vector< long int > > | |
Cwrap_unordered_map< St, openfpm::vector< long int > > | |
Cwrap_unordered_map< typename grid_in_type::stype, openfpm::vector< long int > > | |
Cwrap_unordered_map< typename vector::stype, openfpm::vector< long int > > | |
Cwrap_unordered_map< key, val > | Wrapper of the unordered map |
Cunpack_each_prop_buffer< op, Vt, S, layout_base, v_mpl > | |
Cunpack_selector_with_prp< result, T, S, layout_base, Memory > | |
Cunpack_selector_with_prp< true, T, S, layout_base, Memory > | |
Cunpack_selector_with_prp_lin< inte_or_lin, T, S, layout_base, Memory > | |
Cunpack_selector_with_prp_lin< true, T, S, layout_base, Memory > | |
CUnpack_stat | Unpacking status object |
Cunpack_with_iterator< dim, grid, encap_src, encap_dst, boost_vct, it, stype, prp > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
Cunpack_with_iterator< 3, grid, encap_src, encap_dst, boost_vct, it, stype, prp ... > | Pack an N-dimensional grid into a vector like structure B given an iterator of the grid |
CUnpacker< T, Mem, pack_type > | Unpacker class |
CUnpacker< T, Mem, PACKER_ARRAY_CP_PRIMITIVE > | |
CUnpacker< T, Mem, PACKER_ARRAY_PRIMITIVE > | |
CUnpacker< T, Mem, PACKER_ENCAP_OBJECTS_CHUNKING > | Unpacker for encapsulated objects |
CUnpacker< T, Mem, PACKER_GENERAL > | Unpacker for vectors |
CUnpacker< T, Mem, PACKER_GRID > | Unpacker for grids |
CUnpacker< T, Mem, PACKER_OBJECTS_WITH_POINTER_CHECK > | Unpacker class for objects |
CUnpacker< T, Mem, PACKER_OBJECTS_WITH_WARNING_POINTERS > | Unpacker for objects with no possibility to check for internal pointers |
CUnpacker< T, Mem, PACKER_PRIMITIVE > | Unpacker for primitives |
Cunroll_with_to_kernel< is_sorted, uwk, T > | |
Cunroll_with_to_kernel< false, true, T > | |
Cunroll_with_to_kernel< true, true, T > | |
Cut_start | Boost unit test fixation (start procedure to call before testing) |
Cv_box< vector > | |
Cv_info | |
Cv_mem_mutable< vector > | |
Cv_mem_mutable< typename vector_expression_transform< vector >::type > | |
CV_p< T > | Vertex class that encapsulate an object T |
Cv_transform< H, L > | |
Cv_transform_impl< H, F, L, exit, Args > | Recursive specialization of v_transform |
Cv_transform_impl< H, F, L, true, Args... > | Terminator of to_variadic |
Cv_transform_two< H, arg0, L > | |
Cv_transform_two_impl< H, arg0, F, L, exit, Args > | Recursive specialization of v_transform in case of metafunction with 2 argument |
Cv_transform_two_impl< H, arg0, F, L, true, Args... > | Terminator of to_variadic |
Cv_transform_two_v2< H, arg0, L > | |
Cv_transform_two_v2_impl< H, arg0, F, L, exit, Args > | Recursive specialization of v_transform in case of metafunction with 2 argument |
Cv_transform_two_v2_impl< H, arg0, F, L, true, Args... > | Terminator of to_variadic |
Copenfpm::detail::multi_array::value_accessor_generator_openfpm< T, NumDims, vector > | |
Cvalue_function< integer > | |
Ctsl::hopscotch_map< Key, T, Hash, KeyEqual, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::ValueSelect | |
Ctsl::hopscotch_sc_map< Key, T, Hash, KeyEqual, Compare, Allocator, NeighborhoodSize, StoreHash, GrowthPolicy >::ValueSelect | |
CVandermonde< dim, T, MatrixType > | |
CVandermondeRowBuilder< dim, T, MonomialBasis_type > | |
CFD_scheme< Sys_eqs, grid_type >::variable_b< prp_id > | Encapsulation of the b term as constant |
Cvariadic_caller< T > | |
Cvariadic_caller< index_tuple_sq< prp ... > > | |
►CVcluster_base< InternalMemory > | This class virtualize the cluster of PC as a set of processes that communicate |
CVcluster< HeapMemory > | |
CVcluster< InternalMemory > | Implementation of VCluster class |
CVcluster_base< HeapMemory > | |
CVcluster_log | Vcluster log |
Cvect_dist_key_dx | Grid key for a distributed grid |
Copenfpm::vect_isel< T > | It analyze the type given and it select correctly the implementation for vector |
Copenfpm::vector< T, Memory, layout_base, grow_p, impl > | Implementation of 1-D std::vector like structure |
►Cvector | |
Cvector_fr< T > | 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, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< 128 > >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< 128 >, BlockMapGpuFunctors::BlockFunctor< 128 > >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< 128 >, BlockMapGpuFunctors::BlockFunctor< 128 >, BlockMapGpuFunctors::BlockFunctor< 128 > >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< threadBlockSize > >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, BlockMapGpuFunctors::BlockFunctor< threadBlockSize > >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, BlockMapGpuFunctors::BlockFunctor< threadBlockSize >, BlockMapGpuFunctors::BlockFunctor< threadBlockSize > >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< dim, St >, Memory, layout_base > | |
Copenfpm::vector< aggregate< dim, T >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< dim, T >, Memory, layout_base > | |
Copenfpm::vector< aggregate< dim, typename grid_in_type::stype >, Memory, layout_base > | |
Copenfpm::vector< aggregate< ids_type >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< ids_type >, Memory, layout_base > | |
Copenfpm::vector< aggregate< int > > | |
Copenfpm::vector< aggregate< int >, HeapMemory > | |
Copenfpm::vector< aggregate< int >, Memory > | |
Copenfpm::vector< aggregate< int, int >, HeapMemory, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< int, int >, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< int, int, int >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< int, short int > > | |
Copenfpm::vector< aggregate< int[dim]> > | |
Copenfpm::vector< aggregate< local_index_ >, HeapMemory > | |
Copenfpm::vector< aggregate< long int > > | |
Copenfpm::vector< aggregate< long int >, HeapMemory, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< long int, long int >, HeapMemory, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< long int, long int, long int >, HeapMemory, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< aggregate< long int, unsigned int > > | |
Copenfpm::vector< aggregate< short int, short int > > | |
Copenfpm::vector< aggregate< size_t > > | |
Copenfpm::vector< aggregate< size_t >, HeapMemory > | |
Copenfpm::vector< aggregate< size_t, size_t, unsigned int > > | |
Copenfpm::vector< aggregate< T > > | |
Copenfpm::vector< aggregate< T >, memory, layout_base > | |
Copenfpm::vector< aggregate< typename Mem_type::local_index_type >, HeapMemory > | |
Copenfpm::vector< aggregate< unsigned int > > | |
Copenfpm::vector< aggregate< unsigned int >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< unsigned int, unsigned int >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, Memory, layout_base > | |
Copenfpm::vector< aggregate< unsigned int, unsigned long int >, CudaMemory, memory_traits_inte > | |
Copenfpm::vector< aggregate< void *, void *, int > > | |
Copenfpm::vector< aggregate_bfv< chunk_def >, S, layout_base > | |
Copenfpm::vector< AggregateAppend< int, prop >::type, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< AggregateInternalT, long int, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< AggregateInternalT, long int, memory_traits_lin, grow_policy_double, vect_isel< AggregateInternalT >::value > | |
Copenfpm::vector< AMG_time_err_coars > | |
Copenfpm::vector< Box< dim, int > > | |
Copenfpm::vector< Box< dim, long int > > | |
Copenfpm::vector< Box< dim, size_t > > | |
Copenfpm::vector< Box< dim, St >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< Box< dim, St >, Memory, layout_base > | |
Copenfpm::vector< Box< dim, T > > | |
Copenfpm::vector< Box< dim, T >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< Box< dim, T >, Memory, layout_base > | |
Copenfpm::vector< Box< dim, typename grid_in_type::stype >, Memory, layout_base > | |
Copenfpm::vector< Box< dim, unsigned int > > | |
Copenfpm::vector< Box_dom< dim, St > > | |
Copenfpm::vector< Box_dom< dim, T > > | |
Copenfpm::vector< Box_dom< dim, typename grid_in_type::stype > > | |
Copenfpm::vector< Box_loc_sub< dim, St > > | |
Copenfpm::vector< Box_loc_sub< dim, T > > | |
Copenfpm::vector< Box_loc_sub< dim, typename grid_in_type::stype > > | |
Copenfpm::vector< Box_sub< dim, T > > | |
Copenfpm::vector< Box_sub_k< dim, T > > | |
Copenfpm::vector< cell_grid< Grid > > | |
Copenfpm::vector< cheader< dim > > | |
Copenfpm::vector< cheader< dim >, S > | |
Cstd::vector< comb< 0 > > | Stub vector specialization |
Copenfpm::vector< comb< dim > > | |
Copenfpm::vector< const Grid * > | |
Copenfpm::vector< const void * > | |
Copenfpm::vector< convertAggr > | |
Copenfpm::vector< device_grid > | |
Copenfpm::vector< DistGraph_CSR::EdgeReq > | |
Copenfpm::vector< DistGraph_CSR::SendGraphPack > | |
Copenfpm::vector< E > | |
Copenfpm::vector< E, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< E >::value > | |
Copenfpm::vector< e_box_id< dim > > | |
Copenfpm::vector< e_box_multi< dim > > | |
Copenfpm::vector< e_info > | |
Copenfpm::vector< e_info, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< e_info >::value > | |
Copenfpm::vector< e_lbox_grid< dim > > | |
Copenfpm::vector< e_lbox_id< dim > > | |
Copenfpm::vector< e_map, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< e_map >::value > | |
Copenfpm::vector< ele_g > | |
Copenfpm::vector< ele_g< typename pair::first, typename pair::second > > | |
Copenfpm::vector< ele_g_st< typename pair::first, typename pair::second > > | |
Copenfpm::vector< ele_v > | |
Copenfpm::vector< ele_vpp< typename pair::second > > | |
Copenfpm::vector< ele_vps< typename pair::first > > | |
Copenfpm::vector< ep_box_grid< dim > > | |
Copenfpm::vector< GBoxes< Decomposition::dims > > | |
Copenfpm::vector< GBoxes< device_grid::dims > > | |
Copenfpm::vector< GBoxes< dim > > | |
Copenfpm::vector< GGraph > | |
Copenfpm::vector< grid_base< dim, aggregate< double > > > | |
Copenfpm::vector< grid_cpu< dim, aggregate< size_t > > > | |
Copenfpm::vector< grid_cpu< dim, props_temp > > | |
Copenfpm::vector< grid_cpu< dim, T > > | |
Copenfpm::vector< grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >, HeapMemory, memory_traits_lin, openfpm::grow_policy_identity, STD_VECTOR > | |
Copenfpm::vector< grid_dist_id_comm::rp_id > | |
Copenfpm::vector< grid_dist_id_iterator_dec_skin::gp_sub > | |
Copenfpm::vector< grid_dist_iterator< dim, device_grid, device_it, FIXED > > | |
Copenfpm::vector< grid_dist_iterator< dim, device_grid, device_sub_it, FREE > > | |
Copenfpm::vector< grid_dist_iterator_sub< dim, device_grid > > | |
Copenfpm::vector< grid_key_dx< dim > > | |
Copenfpm::vector< HeapMemory > | |
Copenfpm::vector< i_box_id< dim > > | |
Copenfpm::vector< i_lbox_grid< dim > > | |
Copenfpm::vector< i_lbox_id< dim > > | |
Copenfpm::vector< idx_t > | |
Copenfpm::vector< int > | |
Copenfpm::vector< ip_box_grid< dim > > | |
Copenfpm::vector< itError > | |
Copenfpm::vector< lBox_dom< dim, St > > | |
Copenfpm::vector< lBox_dom< dim, T > > | |
Copenfpm::vector< lBox_dom< dim, typename grid_in_type::stype > > | |
Copenfpm::vector< lid > | |
Copenfpm::vector< long > | |
Copenfpm::vector< long int > | |
Copenfpm::vector< met_sub_w > | |
Copenfpm::vector< mheader< chunking::size::value >, S > | |
Copenfpm::vector< mheader< n_ele > > | |
Copenfpm::vector< Monomial< dim >, Args... > | |
Copenfpm::vector< MPI_Request > | |
Copenfpm::vector< MPI_Status > | |
Copenfpm::vector< nm_e, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< nm_e >::value > | |
Copenfpm::vector< nm_v< dim >, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< nm_v< dim > >::value > | |
Copenfpm::vector< no_edge, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< no_edge >::value > | |
Copenfpm::vector< openfpm::reorder< BlockMapGpuFunctors::BlockFunctor< 128 > > > | |
Copenfpm::vector< openfpm::reorder< BlockMapGpuFunctors::BlockFunctor< threadBlockSize > > > | |
Copenfpm::vector< openfpm::reorder< long int > > | |
Copenfpm::vector< openfpm::vector > | |
Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, aggregate< size_t > >, SpaceBox< dim, long int > > > > | |
Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, props_temp >, SpaceBox< dim, long int > > > > | |
Copenfpm::vector< openfpm::vector< aggregate< grid_cpu< dim, T >, SpaceBox< dim, long int > > > > | |
Copenfpm::vector< openfpm::vector< aggregate< size_t, size_t > > > | |
Copenfpm::vector< openfpm::vector< Box< dim, St > > > | |
Copenfpm::vector< openfpm::vector< Box_proc< dim, St > > > | |
Copenfpm::vector< openfpm::vector< Box_proc< dim, T > > > | |
Copenfpm::vector< openfpm::vector< Box_proc< dim, typename grid_in_type::stype > > > | |
Copenfpm::vector< openfpm::vector< gid > > | |
Copenfpm::vector< openfpm::vector< idx_t > > | |
Copenfpm::vector< openfpm::vector< long unsigned int > > | |
Copenfpm::vector< openfpm::vector< offset_mv< dim > > > | |
Copenfpm::vector< openfpm::vector< size_t > > | |
Copenfpm::vector< openfpm::vector< SpaceBox< dim, St > > > | |
Copenfpm::vector< openfpm::vector< SpaceBox< dim, T > > > | |
Copenfpm::vector< openfpm::vector< SpaceBox< dim, typename grid_in_type::stype > > > | |
Copenfpm::vector< openfpm::vector< unsigned char > > | |
Copenfpm::vector< ORB_node< T >, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< ORB_node< T > >::value > | |
Copenfpm::vector< p_box< dim, St > > | |
Copenfpm::vector< p_box< dim, T > > | |
Copenfpm::vector< p_box< dim, typename grid_in_type::stype > > | |
Copenfpm::vector< patches > | |
Copenfpm::vector< PetscInt > | |
Copenfpm::vector< PetscScalar > | |
Copenfpm::vector< Point< dim, St >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< Point< dim, St >, Memory, layout_base > | |
Copenfpm::vector< Point< dim, T > > | |
Copenfpm::vector< Point< dim, T >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< Point< dim, T >, Memory, layout_base > | |
Copenfpm::vector< Point< dim, typename grid_in_type::stype >, Memory, layout_base > | |
Copenfpm::vector< pos_v< typename Cell::internal_vector_pos_type > > | |
Copenfpm::vector< prop, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< ref_wrap< int > > | |
Copenfpm::vector< ref_wrap< vector > > | |
Copenfpm::vector< ref_wrap< vector_dist_ker_type > > | |
Copenfpm::vector< rid > | |
Copenfpm::vector< rval< PetscScalar, PETSC_RVAL >, HeapMemory, memory_traits_inte > | |
Copenfpm::vector< rval< T, EIGEN_RVAL > > | |
Copenfpm::vector< send_vector > | |
Copenfpm::vector< size_t > | |
Copenfpm::vector< size_t, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< size_t >::value > | |
Copenfpm::vector< solv_bench_info > | |
Copenfpm::vector< SpaceBox< dim, St >, Memory, layout_base > | |
Copenfpm::vector< SpaceBox< dim, T >, HeapMemory, memory_traits_lin > | |
Copenfpm::vector< SpaceBox< dim, T >, Memory, layout_base > | |
Copenfpm::vector< SpaceBox< dim, typename grid_in_type::stype >, Memory, layout_base > | |
Copenfpm::vector< sparse_grid_section< SparseGridGpu > > | |
Copenfpm::vector< std::pair< size_t, size_t > > | |
Copenfpm::vector< std::string > | |
Copenfpm::vector< std::unordered_map< size_t, size_t > > | |
Copenfpm::vector< subsub< dim > > | |
Copenfpm::vector< subsub_lin< dim > > | |
Copenfpm::vector< T > | |
Cvector< T, CudaMemory, memory_traits_inte, grow_policy_double, STD_VECTOR > | Implementation of 1-D std::vector like structure |
CVector< T, EIGEN_BASE > | |
Cvector< T, HeapMemory, memory_traits_lin, grow_p, STD_VECTOR > | Implementation of 1-D std::vector like structure |
Copenfpm::vector< T, HeapMemory, memory_traits_lin, grow_policy_double > | |
Copenfpm::vector< T, HeapMemory, memory_traits_lin, grow_policy_double, vect_isel< T >::value > | |
Copenfpm::vector< T, Memory, layout_base, grow_p, OPENFPM_NATIVE > | Implementation of 1-D std::vector like structure |
CVector< T, PETSC_BASE > | PETSC vector for linear algebra |
Cvector< T, PtrMemory, memory_traits_lin, gp, STD_VECTOR > | |
Copenfpm::vector< triplet > | |
Copenfpm::vector< triplet< T, PETSC_BASE > > | |
Copenfpm::vector< typename Mem_type::local_index_type > | |
Copenfpm::vector< typename sT::value_type, PtrMemory, layout_base, openfpm::grow_policy_identity > | |
Copenfpm::vector< V > | |
Copenfpm::vector< V, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< V >::value > | |
Copenfpm::vector< v_box< vector > > | |
Copenfpm::vector< v_info > | |
Copenfpm::vector< v_info, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, openfpm::vect_isel< v_info >::value > | |
Copenfpm::vector< void * > | |
Cvector_custd_ker< T, layout_base > | Grid interface available when on gpu |
►Cvector_dist_comm< dim, St, prop, Decomposition, Memory, layout_base > | This class is an helper for the communication of vector_dist |
Cvector_dist< dim, St, AggregateAppend< int, prop >::type, CartDecomposition< dim, St >, HeapMemory, memory_traits_lin > | |
►Cvector_dist< dim, St, prop, Decomposition, Memory, layout_base, vector_dist_pos, vector_dist_prop > | Distributed vector |
Cvector_dist_ws< dim, St, prop, Decomposition, Memory, layout_base > | |
Cvector_dist_comm< dim, St, AggregateAppend< int, prop >::type, CartDecomposition< dim, St >, HeapMemory, memory_traits_lin > | |
Cvector_dist_comm< dim, St, prop, CartDecomposition< dim, St >, HeapMemory, memory_traits_lin > | |
Cvector_dist_expression< prp, vector > | Main class that encapsulate a vector properties operand to be used for expressions construction |
Cvector_dist_expression< 16384, point > | This class represent a constant parameter in a vector expression |
Cvector_dist_expression< prp, double > | Main class that encapsulate a double constant |
Cvector_dist_expression< prp, float > | Main class that encapsulate a float constant |
Cvector_dist_expression_comp_proxy_sel< cond > | Expression implementation computation selector |
Cvector_dist_expression_comp_proxy_sel< false > | |
Cvector_dist_expression_comp_sel< impl, vect_ker > | Expression implementation computation selector |
Cvector_dist_expression_comp_sel< comp_dev, false > | |
Cvector_dist_expression_comp_sel< comp_host, true > | |
Cvector_dist_expression_impl< vector_type > | Main class that encapsulate a vector properties operand to be used for expressions construction Temporal Expressions |
►Cvector_dist_expression_impl< openfpm::vector< aggregate< T >, memory, layout_base > > | |
Cvector_dist_expression< 0, openfpm::vector< aggregate< T >, memory, layout_base > > | Sub class that encapsulate a vector properties operand to be used for expressions construction Temporal Expressions |
►Cvector_dist_expression_impl< openfpm::vector_gpu< aggregate< T > > > | |
Cvector_dist_expression< 0, openfpm::vector_gpu< aggregate< T > > > | Sub class that encapsulate a GPU vector properties operand to be used for expressions construction Temporal Expressions |
Cvector_dist_expression_op< exp1, exp2, op > | Unknown operation specialization |
Cvector_dist_expression_op< exp1, boost::mpl::int_< n >, VECT_COMP > | It take an expression and take the component |
Cvector_dist_expression_op< exp1, exp2, VECT_DIV > | Division operation |
Cvector_dist_expression_op< exp1, exp2, VECT_MUL > | Multiplication operation |
Cvector_dist_expression_op< exp1, exp2, VECT_SUB > | Subtraction operation |
Cvector_dist_expression_op< exp1, exp2, VECT_SUM > | Sum operation |
Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN > | Apply kernel operation |
Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN > | Apply kernel operation |
Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_GEN_SORT > | Apply kernel operation |
Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM > | Apply kernel operation |
Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SIM_SORT > | Apply kernel operation |
Cvector_dist_expression_op< exp1, vector_type, VECT_APPLYKER_IN_SORT > | Apply kernel operation |
Cvector_dist_expression_op< exp1, void, VECT_NORM_INF > | Expression that encapsulate a vector Norm INF expression |
Cvector_dist_expression_op< exp1, void, VECT_SUB_UNI > | It take an expression and create the negatove of this expression |
Cvector_dist_expression_op< exp1, void, VECT_SUM_REDUCE > | Expression that encapsulate a vector reduction expression |
Cvector_dist_iterator | Iterator that Iterate across particle indexes |
Cvector_dist_iterator_subset | Iterator that Iterate across particle indexes |
Cvector_dist_ker_list< vector_dist_ker_type > | This class contain a list of all tracked vector_dist_ker around |
►Cvector_dist_ker_list< int > | |
Cvector_dist< dim, St, AggregateAppend< int, prop >::type, CartDecomposition< dim, St >, HeapMemory, memory_traits_lin > | |
Cvector_dist< dim, St, prop, Decomposition, Memory, layout_base, vector_dist_pos, vector_dist_prop > | Distributed vector |
Cvector_dist_ker_list< vector > | |
Cvector_dist_op_compute_op< prp, is_sort, impl > | |
Cvector_dist_op_compute_op< prp, false, comp_host > | |
Cvector_dist_subset< dim, St, prop, Decomposition, Memory, layout_base > | |
Cvector_dist_subset< vd_type::dims, typename vd_type::stype, typename vd_type::value_type > | |
Cvector_expression_transform< vector, is_ker > | |
Cvector_expression_transform< vector, true > | |
Copenfpm::vector_gpu_ker< T, layout_base > | Grid interface available when on gpu |
Copenfpm::vector_gpu_ker< aggregate< cnt_type >, memory_traits_inte > | |
Copenfpm::vector_gpu_ker< aggregate< cnt_type, cnt_type >, memory_traits_inte > | |
Copenfpm::vector_gpu_ker< aggregate< DataBlock< float, 64 > >, memory_traits_inte > | |
Copenfpm::vector_gpu_ker< aggregate< dim, T >, layout_base > | |
Copenfpm::vector_gpu_ker< aggregate< indexT >, layout_base > | |
Copenfpm::vector_gpu_ker< aggregate< indexT >, memory_traits_inte > | |
Copenfpm::vector_gpu_ker< aggregate< int >, memory_traits_inte > | |
Copenfpm::vector_gpu_ker< aggregate< int >, memory_traits_lin > | |
Copenfpm::vector_gpu_ker< aggregate< local_index >, layout_base > | |
Copenfpm::vector_gpu_ker< aggregate< short int, short int >, memory_traits_inte > | |
Copenfpm::vector_gpu_ker< aggregate< Ti >, layout_base > | |
Copenfpm::vector_gpu_ker< aggregate< unsigned int, unsigned int, unsigned int >, layout_base > | |
Copenfpm::vector_gpu_ker< AggregateBlockT, layout_base > | |
Copenfpm::vector_gpu_ker< Box< dim, T >, layout_base > | |
Copenfpm::vector_gpu_ker< typename apply_transform< memory_traits_inte, aggregate >::type, memory_traits_inte > | |
Copenfpm::vector_gpu_ker_ref< T, layout_base > | Grid interface available when on gpu |
C |