| Cheffte::add_trace | Hefftetrace |
| Cheffte::stock::biFuncNode< F, L > | Class to represent the call-graph nodes |
| Cheffte::box3d< index > | A generic container that describes a 3d box of indexes |
| Cheffte::backend::buffer_traits< backend_tag, type > | Defines the container for the temporary buffers |
| Cheffte::backend::buffer_traits< cufft > | Defines the location type-tag and the cuda container |
| Cheffte::backend::buffer_traits< cufft_cos > | Defines the location type-tag and the cuda container |
| Cheffte::backend::buffer_traits< cufft_sin > | Defines the location type-tag and the cuda container |
| Cheffte::backend::buffer_traits< onemkl > | Defines the location type-tag and the oneAPI container |
| Cheffte::backend::buffer_traits< onemkl_cos > | Defines the location type-tag and the oneAPI container |
| Cheffte::backend::buffer_traits< onemkl_sin > | Defines the location type-tag and the oneAPI container |
| Cheffte::backend::buffer_traits< rocfft > | Defines the location type-tag and the cuda container |
| Cheffte::backend::buffer_traits< rocfft_cos > | Defines the location type-tag and the cuda container |
| Cheffte::backend::buffer_traits< rocfft_sin > | Defines the location type-tag and the cuda container |
| Cheffte::stock::Complex< F, L > | Custom complex type taking advantage of vectorization A Complex Type intrinsic to HeFFTe that takes advantage of vectorization. It is currently compatible with AVX2 to create 1 double-precision complex, 2 double-precision complex, 2 single-precision complex, or 4 single-precision complex numbers |
| Cheffte::stock::complex_allocator_t< F > | Allocator to use with heffte::stock::Complex types Class to properly allocate heffte::stock::Complex<F,L> types to ensure proper alignment of the type when using containers like std::vector |
| Cheffte::cuda::cos_pre_pos_processor | Implementation of Cosine Transform pre-post processing methods using CUDA |
| Cheffte::oapi::cos_pre_pos_processor | Implementation of Cosine Transform pre-post processing methods using CUDA |
| Cheffte::rocm::cos_pre_pos_processor | Implementation of Cosine Transform pre-post processing methods using CUDA |
| Cheffte::tag::cpu | Indicates the use of cpu backend and that all input/output data and arrays will be bound to the cpu |
| Cheffte::cpu_cos_pre_pos_processor | Pre/Post processing for the Cosine transform using the CPU |
| Cheffte::cpu_sin_pre_pos_processor | Pre/Post processing for the Sine transform using the CPU |
| Cheffte::backend::cufft | Type-tag for the cuFFT backend |
| Cheffte::backend::cufft_cos | Type-tag for the Cosine Transform using the cuFFT backend |
| Cheffte::backend::cufft_sin | Type-tag for the Sine Transform using the cuFFT backend |
| Cheffte::backend::data_manipulator< location_tag > | Common data-transfer operations, must be specializes for each location (cpu/gpu) |
| Cheffte::backend::data_manipulator< tag::cpu > | Common data-transfer operations on the cpu |
| Cheffte::backend::data_manipulator< tag::gpu > | Specialization for the data operations in CUDA mode |
| Cheffte::backend::default_backend< location_tag > | Defines inverse mapping from the location tag to a default backend tag |
| Cheffte::backend::default_backend< tag::cpu > | Make MKL the default CPU backend |
| Cheffte::backend::default_backend< tag::gpu > | In CUDA mode, the default GPU backend is cufft |
| Cheffte::default_plan_options< typename > | Defines a set of default plan options for a given backend |
| Cheffte::default_plan_options< backend::cufft > | Sets the default options for the cufft backend |
| Cheffte::default_plan_options< backend::cufft_cos > | Sets the default options for the cufft backend |
| Cheffte::default_plan_options< backend::cufft_sin > | Sets the default options for the cufft backend |
| Cheffte::default_plan_options< backend::fftw > | Sets the default options for the fftw backend |
| Cheffte::default_plan_options< backend::fftw_cos > | Sets the default options for the fftw backend |
| Cheffte::default_plan_options< backend::fftw_sin > | Sets the default options for the fftw backend |
| Cheffte::default_plan_options< backend::mkl > | Sets the default options for the mkl backend |
| Cheffte::default_plan_options< backend::mkl_cos > | Sets the default options for the mkl backend |
| Cheffte::default_plan_options< backend::mkl_sin > | Sets the default options for the mkl backend |
| Cheffte::default_plan_options< backend::onemkl > | Sets the default options for the oneMKL backend |
| Cheffte::default_plan_options< backend::onemkl_cos > | Sets the default options for the oneMKL backend |
| Cheffte::default_plan_options< backend::onemkl_sin > | Sets the default options for the oneMKL backend |
| Cheffte::default_plan_options< backend::rocfft > | Sets the default options for the cufft backend |
| Cheffte::default_plan_options< backend::rocfft_cos > | Sets the default options for the cufft backend |
| Cheffte::default_plan_options< backend::rocfft_sin > | Sets the default options for the cufft backend |
| Cheffte::default_plan_options< backend::stock > | Sets the default options for the stock fft backend |
| Cheffte::default_plan_options< backend::stock_cos > | Sets the default options for the stock fft backend |
| Cheffte::default_plan_options< backend::stock_sin > | Sets the default options for the stock fft backend |
| Cheffte::define_standard_type< typename, typename > | Struct to specialize that returns the C++ equivalent of each type |
| Cheffte::define_standard_type< double, void > | Type double is equivalent to double |
| Cheffte::define_standard_type< float, void > | Type float is equivalent to float |
| Cheffte::define_standard_type< scalar_type, typename std::enable_if< is_ccomplex< scalar_type >::value >::type > | Every type with specialization of heffte::is_ccomplex to std::true_type is equivalent to std::complex<float> |
| Cheffte::define_standard_type< scalar_type, typename std::enable_if< is_zcomplex< scalar_type >::value >::type > | Every type with specialization of heffte::is_zcomplex to std::true_type is equivalent to std::complex<double> |
| Cheffte::backend::device_instance< backend_tag > | Holds the auxiliary variables needed by each backend |
| ►Cheffte::backend::device_instance< backend::buffer_traits< backend_tag >::location > | |
| Cheffte::fft3d< backend_tag, index > | Defines the plan for a 3-dimensional discrete Fourier transform performed on a MPI distributed data |
| Cheffte::fft3d_r2c< backend_tag, index > | Similar to heffte::fft3d, but computed fewer redundant coefficients when the input is real |
| ►Cheffte::backend::device_instance< location_tag > | |
| Cheffte::reshape3d_alltoall< location_tag, packer, index > | Reshape algorithm based on the MPI_Alltoall() method |
| Cheffte::reshape3d_alltoallv< location_tag, packer, index > | Reshape algorithm based on the MPI_Alltoallv() method |
| Cheffte::reshape3d_pointtopoint< location_tag, packer, index > | Reshape algorithm based on the MPI_Send() and MPI_Irecv() methods |
| Cheffte::reshape3d_transpose< location_tag, index > | Special case of the reshape that does not involve MPI communication but applies a transpose instead |
| Cheffte::backend::device_instance< tag::gpu > | The CUDA backend uses a CUDA stream |
| Cheffte::backend::device_instance< typename heffte::backend::buffer_traits< fft_backend_tag >::location > | |
| Cheffte::direct_packer< mode > | Defines the direct packer without implementation, use the specializations to get the CPU or GPU implementation |
| Cheffte::direct_packer< tag::cpu > | Simple packer that copies sub-boxes without transposing the order of the indexes |
| Cheffte::direct_packer< tag::gpu > | Simple packer that copies sub-boxes without transposing the order of the indexes |
| Cheffte::event | A tracing event |
| ►Cheffte::executor_base | Base class for all backend executors |
| Cheffte::cufft_executor | Wrapper around the cuFFT API |
| Cheffte::cufft_executor_r2c | Wrapper to cuFFT API for real-to-complex transform with shortening of the data |
| Cheffte::fftw_executor | Wrapper around the FFTW3 API |
| Cheffte::fftw_executor_r2c | Wrapper to fftw3 API for real-to-complex transform with shortening of the data |
| Cheffte::mkl_executor | Wrapper around the MKL API |
| Cheffte::mkl_executor_r2c | Wrapper to mkl API for real-to-complex transform with shortening of the data |
| Cheffte::onemkl_executor | Wrapper around the oneMKL API |
| Cheffte::onemkl_executor_r2c | Wrapper to oneMKL API for real-to-complex transform with shortening of the data |
| Cheffte::real2real_executor< fft_backend_tag, prepost_processor > | Template algorithm for the Sine and Cosine transforms |
| Cheffte::rocfft_executor | Wrapper around the rocFFT API |
| Cheffte::rocfft_executor_r2c | Wrapper to rocFFT API for real-to-complex transform with shortening of the data |
| Cheffte::stock_fft_executor | Wrapper around the Stock FFT API |
| Cheffte::stock_fft_executor_r2c | Wrapper to stock API for real-to-complex transform with shortening of the data |
| ►Cstd::false_type | |
| Cheffte::backend::check_types< backend_tag, input, output, typename > | Set to true/false type depending whether the types are compatible with the backend transform |
| Cheffte::backend::is_enabled< tag > | Allows to define whether a specific backend interface has been enabled |
| Cheffte::backend::uses_fft_types< cufft_cos > | Sets the cos() transform types |
| Cheffte::backend::uses_fft_types< cufft_sin > | Sets the sin() transform types |
| Cheffte::backend::uses_fft_types< fftw_cos > | Sets the cos() transform types |
| Cheffte::backend::uses_fft_types< fftw_sin > | Sets the sin() transform types |
| Cheffte::backend::uses_fft_types< mkl_cos > | Sets the cos() transform types |
| Cheffte::backend::uses_fft_types< mkl_sin > | Sets the sin() transform types |
| Cheffte::backend::uses_fft_types< onemkl_cos > | Sets the cos() transform types |
| Cheffte::backend::uses_fft_types< onemkl_sin > | Sets the sin() transform types |
| Cheffte::backend::uses_fft_types< rocfft_cos > | Sets the cos() transform types |
| Cheffte::backend::uses_fft_types< rocfft_sin > | Sets the sin() transform types |
| Cheffte::backend::uses_fft_types< stock_cos > | Sets the cos() transform types |
| Cheffte::backend::uses_fft_types< stock_sin > | Sets the sin() transform types |
| Cheffte::backend::uses_gpu< backend_tag, typename > | Struct that specializes to true type if the location of the backend is on the gpu (false type otherwise) |
| Cheffte::is_ccomplex< scalar_type > | Struct to specialize to allow HeFFTe to recognize custom single precision complex types |
| Cheffte::is_zcomplex< scalar_type > | Struct to specialize to allow HeFFTe to recognize custom double precision complex types |
| Cheffte::fft_output< scalar_type > | Defines the relationship between pairs of input-output types in the FFT algorithms |
| Cheffte::fft_output< double > | Specialization mapping double to std::complex<double> |
| Cheffte::fft_output< float > | Specialization mapping float to std::complex<float> |
| Cheffte::backend::fftw | Type-tag for the FFTW backend |
| Cheffte::backend::fftw_cos | Type-tag for the Cosine Transform using the FFTW backend |
| Cheffte::backend::fftw_sin | Type-tag for the Sine Transform using the FFTW backend |
| Cheffte::stock::Fourier_Transform< F, L > | Functor class to represent any Fourier Transform A class to use lambdas to switch between what FFT should be called |
| Cheffte::tag::gpu | Indicates the use of gpu backend and that all input/output data and arrays will be bound to the gpu device |
| Cheffte_fft_plan | Generic wrapper around some fft3d/fft3d_r2c instance, use heffte_plan instead of this |
| Cheffte_plan_options | Equivalent to heffte::plan_options but defined for the C API |
| Cheffte::ioboxes< index > | Pair of lists of input-output boxes as used by the heffte::fft3d |
| Cheffte::stock::is_complex< T > | Struct determining whether a type is a complex number |
| Cheffte::stock::is_real< T > | Struct determining whether a type is a real number |
| Cheffte::logic_plan3d< index > | The logic plan incorporates the order and types of operations in a transform |
| Cheffte::gpu::magma_handle< typename > | Wrapper around a MAGMA handle |
| Cheffte::gpu::magma_handle< tag::gpu > | Wrapper around a MAGMA handle in a GPU context |
| Cheffte::backend::mkl | Type-tag for the MKL backend |
| Cheffte::backend::mkl_cos | Type-tag for the Cosine Transform using the MKL FFT backend |
| Cheffte::backend::mkl_sin | Type-tag for the Sine Transform using the MKL FFT backend |
| Cheffte::stock::omega< F, L > | Create a stock Complex representation of a twiddle factor |
| Cheffte::one_dim_backend< typename > | Indicates the structure that will be used by the fft backend |
| Cheffte::one_dim_backend< backend::cufft > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::cufft_cos > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::cufft_sin > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::fftw > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::fftw_cos > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::fftw_sin > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::mkl > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::mkl_cos > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::mkl_sin > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::onemkl > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::onemkl_cos > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::onemkl_sin > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::rocfft > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::rocfft_cos > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::rocfft_sin > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::stock > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::stock_cos > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::one_dim_backend< backend::stock_sin > | Helper struct that defines the types and creates instances of one-dimensional executors |
| Cheffte::backend::onemkl | Type-tag for the oneMKL backend |
| Cheffte::backend::onemkl_cos | Type-tag for the Cosine Transform using the oneMKL backend |
| Cheffte::backend::onemkl_sin | Type-tag for the Sine Transform using the oneMKL backend |
| Cheffte::stock::pack< T, N > | Struct to retrieve the vector type associated with the number of elements stored "per unit" |
| Cheffte::stock::pack< double, 1 > | Alias for default double type |
| Cheffte::stock::pack< F, L > | |
| Cheffte::stock::pack< float, 1 > | Alias for default float type |
| Cheffte::pack_plan_3d< index > | Holds the plan for a pack/unpack operation |
| Cheffte::packer_backend< backend > | The packer needs to know whether the data will be on the CPU or GPU devices |
| Cheffte::plan_cufft< scalar_type > | Wrapper around cufftHandle plans, set for float or double complex |
| Cheffte::plan_cufft_r2c< scalar_type > | Plan for the r2c single and double precision transform |
| Cheffte::plan_fftw< typename, direction > | Base plan for fftw, using only the specialization for float and double complex |
| Cheffte::plan_fftw< double, dir > | Specialization for r2c double precision |
| Cheffte::plan_fftw< float, dir > | Specialization for r2c single precision |
| Cheffte::plan_fftw< std::complex< double >, dir > | Specialization for double complex |
| Cheffte::plan_fftw< std::complex< float >, dir > | Plan for the single precision complex transform |
| Cheffte::plan_mkl< scalar_type > | Base plan for backend::mkl, works only for float and double complex |
| Cheffte::plan_mkl_r2c< scalar_type, dir > | Unlike the C2C plan R2C is non-symmetric and it requires that the direction is built into the plan |
| Cheffte::plan_options | Defines a set of tweaks and options to use in the plan generation |
| Cheffte::plan_rocfft< precision_type, dir > | Plan for the r2c single precision transform |
| Cheffte::plan_rocfft< std::complex< precision_type >, dir > | Plan for the single precision complex transform |
| Cheffte::plan_stock_fft< F, dir > | Specialization for r2c single precision |
| Cheffte::plan_stock_fft< std::complex< F >, dir > | Plan for the single precision complex transform |
| Cheffte::rank_remap | Keeps the local rank and the map from the global rank to the sub-ranks used in the work |
| Cheffte::stock::complex_allocator_t< F >::rebind< U > | Defining rebind for the allocator |
| ►Cheffte::reshape3d_base< index > | Base reshape interface |
| Cheffte::reshape3d_alltoall< location_tag, packer, index > | Reshape algorithm based on the MPI_Alltoall() method |
| Cheffte::reshape3d_alltoallv< location_tag, packer, index > | Reshape algorithm based on the MPI_Alltoallv() method |
| Cheffte::reshape3d_pointtopoint< location_tag, packer, index > | Reshape algorithm based on the MPI_Send() and MPI_Irecv() methods |
| Cheffte::reshape3d_transpose< location_tag, index > | Special case of the reshape that does not involve MPI communication but applies a transpose instead |
| Cheffte::backend::rocfft | Type-tag for the rocFFT backend |
| Cheffte::backend::rocfft_cos | Type-tag for the Cosine Transform using the rocFFT backend |
| Cheffte::backend::rocfft_sin | Type-tag for the Sine Transform using the rocFFT backend |
| Cheffte::cuda::sin_pre_pos_processor | Implementation of Sine Transform pre-post processing methods using CUDA |
| Cheffte::oapi::sin_pre_pos_processor | Implementation of Cosine Transform pre-post processing methods using CUDA |
| Cheffte::rocm::sin_pre_pos_processor | Implementation of Sine Transform pre-post processing methods using CUDA |
| Cheffte::backend::stock | Type-tag for the stock FFT backend |
| Cheffte::backend::stock_cos | Type-tag for the Cosine Transform using the stock FFT backend |
| Cheffte::backend::stock_sin | Type-tag for the Sine Transform using the stock FFT backend |
| Cheffte::transform_output< scalar_type, backend_tag, typename > | Defines the relationship between pairs of input-output types in a general transform algorithm |
| Cheffte::transform_output< scalar_type, backend_tag, typename std::enable_if< backend::uses_fft_types< backend_tag >::value >::type > | Specialization for standard FFT |
| Cheffte::transform_output< scalar_type, backend_tag, typename std::enable_if< not backend::uses_fft_types< backend_tag >::value >::type > | Specialization for Cosine Transform |
| Cheffte::transpose_packer< mode > | Defines the transpose packer without implementation, use the specializations to get the CPU implementation |
| Cheffte::transpose_packer< tag::cpu > | Transpose packer that packs sub-boxes without transposing, but unpacks applying a transpose operation |
| Cheffte::transpose_packer< tag::gpu > | GPU version of the transpose packer |
| ►Cstd::true_type | |
| Cheffte::backend::check_types< backend_tag, input, output, typename std::enable_if< not uses_fft_types< backend_tag >::value and((std::is_same< input, float >::value and std::is_same< output, float >::value) or(std::is_same< input, double >::value and std::is_same< output, double >::value))>::type > | Defines the types compatible for a cos() transform |
| Cheffte::backend::check_types< backend_tag, input, output, typename std::enable_if< uses_fft_types< backend_tag >::value and((std::is_same< input, float >::value and is_ccomplex< output >::value) or(std::is_same< input, double >::value and is_zcomplex< output >::value) or(is_ccomplex< input >::value and is_ccomplex< output >::value) or(is_zcomplex< input >::value and is_zcomplex< output >::value))>::type > | Defines the types compatible for a standard FFT transform |
| Cheffte::backend::is_enabled< cufft > | Indicate that the cuFFT backend has been enabled |
| Cheffte::backend::is_enabled< cufft_cos > | Indicate that the cuFFT backend has been enabled for Cosine Transform |
| Cheffte::backend::is_enabled< cufft_sin > | Indicate that the cuFFT backend has been enabled for Sine Transform |
| Cheffte::backend::is_enabled< fftw > | Indicate that the FFTW backend has been enabled |
| Cheffte::backend::is_enabled< fftw_cos > | Indicate that the cos() transform using the FFTW backend has been enabled |
| Cheffte::backend::is_enabled< fftw_sin > | Indicate that the cos() transform using the FFTW backend has been enabled |
| Cheffte::backend::is_enabled< mkl > | Indicate that the MKL backend has been enabled |
| Cheffte::backend::is_enabled< mkl_cos > | Indicate that the MKL Cosine Transform backend has been enabled |
| Cheffte::backend::is_enabled< mkl_sin > | Indicate that the MKL Sine Transform backend has been enabled |
| Cheffte::backend::is_enabled< onemkl > | Indicate that the oneMKL backend has been enabled |
| Cheffte::backend::is_enabled< onemkl_cos > | Indicate that the oneMKL backend has been enabled |
| Cheffte::backend::is_enabled< onemkl_sin > | Indicate that the oneMKL backend has been enabled |
| Cheffte::backend::is_enabled< rocfft > | Indicate that the rocFFT backend has been enabled |
| Cheffte::backend::is_enabled< rocfft_cos > | Indicate that the rocFFT backend has been enabled |
| Cheffte::backend::is_enabled< rocfft_sin > | Indicate that the rocFFT backend has been enabled |
| Cheffte::backend::is_enabled< stock > | Indicate that the stock backend has been enabled |
| Cheffte::backend::is_enabled< stock_cos > | Indicate that the stock backend has been enabled |
| Cheffte::backend::is_enabled< stock_sin > | Indicate that the stock backend has been enabled |
| Cheffte::backend::uses_fft_types< backend_tag > | Defines whether the backend accepts the standard FFT real-complex or complex-complex transform |
| Cheffte::backend::uses_gpu< backend_tag, typename std::enable_if< std::is_same< typename buffer_traits< backend_tag >::location, tag::gpu >::value, void >::type > | Specialization for the on-gpu case |
| Cheffte::is_ccomplex< cufftComplex > | Recognize the cuFFT single precision complex type |
| Cheffte::is_ccomplex< fftwf_complex > | Recognize the FFTW single precision complex type |
| Cheffte::is_ccomplex< float _Complex > | Recognize the MKL single precision complex type |
| Cheffte::is_ccomplex< std::complex< float > > | By default, HeFFTe recognizes std::complex<float> |
| Cheffte::is_ccomplex< stock::Complex< float, 1 > > | Recognize stock FFT single complex (which are std::complex) types |
| Cheffte::is_zcomplex< cufftDoubleComplex > | Recognize the cuFFT double precision complex type |
| Cheffte::is_zcomplex< double _Complex > | Recognize the MKL double precision complex type |
| Cheffte::is_zcomplex< fftw_complex > | Recognize the FFTW double precision complex type |
| Cheffte::is_zcomplex< std::complex< double > > | By default, HeFFTe recognizes std::complex<double> |
| Cheffte::is_zcomplex< stock::Complex< double, 1 > > | |
1.9.1