Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

Nheffte	Namespace containing all HeFFTe methods and classes
Ncuda	Cuda specific methods
Ccos_pre_pos_processor	Implementation of Cosine Transform pre-post processing methods using CUDA
Csin_pre_pos_processor	Implementation of Sine Transform pre-post processing methods using CUDA
Ccos1_pre_pos_processor
Nbackend	Contains type tags and templates metadata for the various backends
Cis_enabled< cufft >	Indicate that the cuFFT backend has been enabled
Cis_enabled< cufft_cos >	Indicate that the cuFFT backend has been enabled for Cosine Transform
Cis_enabled< cufft_sin >	Indicate that the cuFFT backend has been enabled for Sine Transform
Cis_enabled< cufft_cos1 >
Cdevice_instance< tag::gpu >	The CUDA backend uses a CUDA stream
Cdefault_backend< tag::gpu >	In CUDA mode, the default GPU backend is cufft
Cdata_manipulator< tag::gpu >	Specialization for the data operations in CUDA mode
Cbuffer_traits< cufft >	Defines the location type-tag and the cuda container
Cbuffer_traits< cufft_cos >	Defines the location type-tag and the cuda container
Cbuffer_traits< cufft_sin >	Defines the location type-tag and the cuda container
Cbuffer_traits< cufft_cos1 >
Cis_enabled< fftw >	Indicate that the FFTW backend has been enabled
Cis_enabled< fftw_cos >	Indicate that the cos() transform using the FFTW backend has been enabled
Cis_enabled< fftw_sin >	Indicate that the cos() transform using the FFTW backend has been enabled
Cis_enabled< fftw_cos1 >	Indicate that the cos() transform type II using the FFTW backend has been enabled
Cis_enabled< fftw_sin1 >	Indicate that the cos() transform type II using the FFTW backend has been enabled
Cis_enabled< mkl >	Indicate that the MKL backend has been enabled
Cis_enabled< mkl_cos >	Indicate that the MKL Cosine Transform backend has been enabled
Cis_enabled< mkl_sin >	Indicate that the MKL Sine Transform backend has been enabled
Cdefault_backend< tag::cpu >	Make MKL the default CPU backend
Cis_enabled< onemkl >	Indicate that the oneMKL backend has been enabled
Cis_enabled< onemkl_cos >	Indicate that the oneMKL backend has been enabled
Cis_enabled< onemkl_sin >	Indicate that the oneMKL backend has been enabled
Cbuffer_traits< onemkl >	Defines the location type-tag and the oneAPI container
Cbuffer_traits< onemkl_cos >	Defines the location type-tag and the oneAPI container
Cbuffer_traits< onemkl_sin >	Defines the location type-tag and the oneAPI container
Cis_enabled< rocfft >	Indicate that the rocFFT backend has been enabled
Cis_enabled< rocfft_cos >	Indicate that the rocFFT backend has been enabled
Cis_enabled< rocfft_sin >	Indicate that the rocFFT backend has been enabled
Cis_enabled< rocfft_cos1 >	Indicate that the rocFFT backend has been enabled
Cbuffer_traits< rocfft >	Defines the location type-tag and the cuda container
Cbuffer_traits< rocfft_cos >	Defines the location type-tag and the cuda container
Cbuffer_traits< rocfft_sin >	Defines the location type-tag and the cuda container
Cbuffer_traits< rocfft_cos1 >	Defines the location type-tag and the cuda container
Cis_enabled< stock >	Indicate that the stock backend has been enabled
Cis_enabled< stock_cos >	Indicate that the stock backend has been enabled
Cis_enabled< stock_sin >	Indicate that the stock backend has been enabled
Cis_enabled< stock_cos1 >	Indicate that the stock backend has been enabled
Cdata_manipulator	Common data-transfer operations, must be specializes for each location (cpu/gpu)
Cdata_manipulator< tag::cpu >	Common data-transfer operations on the cpu
Cfftw	Type-tag for the FFTW backend
Cfftw_cos	Type-tag for the Cosine Transform using the FFTW backend
Cfftw_sin	Type-tag for the Sine Transform using the FFTW backend
Cfftw_cos1	Type-tag for the Cosine Transform type 1 using the FFTW backend
Cfftw_sin1	Type-tag for the Sine Transform type 1 using the FFTW backend
Cstock	Type-tag for the stock FFT backend
Cstock_cos	Type-tag for the Cosine Transform using the stock FFT backend
Cstock_sin	Type-tag for the Sine Transform using the stock FFT backend
Cstock_cos1	Type-tag for the Cosine Transform type 1 using the stock FFT backend
Cmkl	Type-tag for the MKL backend
Cmkl_cos	Type-tag for the Cosine Transform using the MKL FFT backend
Cmkl_sin	Type-tag for the Sine Transform using the MKL FFT backend
Ccufft	Type-tag for the cuFFT backend
Ccufft_cos	Type-tag for the Cosine Transform using the cuFFT backend
Ccufft_sin	Type-tag for the Sine Transform using the cuFFT backend
Ccufft_cos1	Type-tag for the Cosine Transform type 1 using the cuFFT backend
Crocfft	Type-tag for the rocFFT backend
Crocfft_cos	Type-tag for the Cosine Transform using the rocFFT backend
Crocfft_sin	Type-tag for the Sine Transform using the rocFFT backend
Crocfft_cos1	Type-tag for the Cosine Transform of type 1 using the rocFFT backend
Conemkl	Type-tag for the oneMKL backend
Conemkl_cos	Type-tag for the Cosine Transform using the oneMKL backend
Conemkl_sin	Type-tag for the Sine Transform using the oneMKL backend
Cis_enabled	Allows to define whether a specific backend interface has been enabled
Cbuffer_traits	Defines the container for the temporary buffers
Cuses_gpu	Struct that specializes to true type if the location of the backend is on the gpu (false type otherwise)
Cuses_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
Cdevice_instance	Holds the auxiliary variables needed by each backend
Cdefault_backend	Defines inverse mapping from the location tag to a default backend tag
Cuses_fft_types	Defines whether the backend accepts the standard FFT real-complex or complex-complex transform
Ccheck_types	Set to true/false type depending whether the types are compatible with the backend transform
Ccheck_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
Cuses_fft_types< fftw_cos >	Sets the cos() transform C++ types
Cuses_fft_types< fftw_sin >	Sets the sin() transform C++ types
Cuses_fft_types< fftw_cos1 >	Sets the cos() transform C++ types
Cuses_fft_types< fftw_sin1 >	Sets the sin() transform C++ types
Cuses_fft_types< stock_cos >	Sets the cos() transform types
Cuses_fft_types< stock_sin >	Sets the sin() transform types
Cuses_fft_types< stock_cos1 >	Sets the cos() transform types
Cuses_fft_types< mkl_cos >	Sets the cos() transform types
Cuses_fft_types< mkl_sin >	Sets the sin() transform types
Cuses_fft_types< cufft_cos >	Sets the cos() transform types
Cuses_fft_types< cufft_sin >	Sets the sin() transform types
Cuses_fft_types< cufft_cos1 >	Sets the cos1() transform types
Cuses_fft_types< rocfft_cos >	Sets the cos() transform types
Cuses_fft_types< rocfft_sin >	Sets the sin() transform types
Cuses_fft_types< rocfft_cos1 >	Sets the cos1() transform types
Cuses_fft_types< onemkl_cos >	Sets the cos() transform types
Cuses_fft_types< onemkl_sin >	Sets the sin() transform types
Ccheck_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
Noapi	SYCL/DPC++ specific methods, vector-like container, error checking, etc
Ccos_pre_pos_processor	Implementation of Cosine Transform pre-post processing methods using CUDA
Csin_pre_pos_processor	Implementation of Cosine Transform pre-post processing methods using CUDA
Nrocm	ROCM specific methods, vector-like container, error checking, etc
Ccos_pre_pos_processor	Implementation of Cosine Transform pre-post processing methods using CUDA
Csin_pre_pos_processor	Implementation of Sine Transform pre-post processing methods using CUDA
Ccos1_pre_pos_processor	Implementation of Cosine Transform of type 1 pre-post processing methods using CUDA
Cinitialize	Indicates whether the rocfft_setup() method has been called
Ntag	Contains internal type-tags
Ccpu	Indicates the use of cpu backend and that all input/output data and arrays will be bound to the cpu
Cgpu	Indicates the use of gpu backend and that all input/output data and arrays will be bound to the gpu device
Ngpu
Cmagma_handle	Wrapper around a MAGMA handle
Cmagma_handle< tag::gpu >	Wrapper around a MAGMA handle in a GPU context
Nstock
CbiFuncNode	Class to represent the call-graph nodes
Comega	Create a stock Complex representation of a twiddle factor
CFourier_Transform	Functor class to represent any Fourier Transform A class to use lambdas to switch between what FFT should be called
Ccomplex_allocator_t	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
Crebind	Defining rebind for the allocator
CComplex	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
Cis_real	Struct determining whether a type is a real number
Cis_complex	Struct determining whether a type is a complex number
Cpack	Struct to retrieve the vector type associated with the number of elements stored "per unit"
Cpack< float, 1 >	Alias for default float type
Cpack< double, 1 >	Alias for default double type
Cis_ccomplex< cufftComplex >	Recognize the cuFFT single precision complex type
Cis_zcomplex< cufftDoubleComplex >	Recognize the cuFFT double precision complex type
Cplan_cufft	Wrapper around cufftHandle plans, set for float or double complex
Ccufft_executor	Wrapper around the cuFFT API
Cplan_cufft_r2c	Plan for the r2c single and double precision transform
Ccufft_executor_r2c	Wrapper to cuFFT API for real-to-complex transform with shortening of the data
Cone_dim_backend< backend::cufft >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::cufft_cos >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::cufft_sin >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::cufft_cos1 >
Cdirect_packer< tag::gpu >	Simple packer that copies sub-boxes without transposing the order of the indexes
Ctranspose_packer< tag::gpu >	GPU version of the transpose packer
Cdefault_plan_options< backend::cufft >	Sets the default options for the cufft backend
Cdefault_plan_options< backend::cufft_cos >	Sets the default options for the cufft backend
Cdefault_plan_options< backend::cufft_cos1 >
Cdefault_plan_options< backend::cufft_sin >	Sets the default options for the cufft backend
Cis_ccomplex< fftwf_complex >	Recognize the FFTW single precision complex type
Cis_zcomplex< fftw_complex >	Recognize the FFTW double precision complex type
Cplan_fftw	Base plan for fftw, using only the specialization for float and double complex
Cplan_fftw< std::complex< float >, dir >	Plan for the single precision complex transform
Cplan_fftw< std::complex< double >, dir >	Specialization for double complex
Cfftw_executor	Wrapper around the FFTW3 API
Cplan_fftw< float, dir >	Specialization for r2c single precision
Cplan_fftw< double, dir >	Specialization for r2c double precision
Cfftw_executor_r2c	Wrapper to fftw3 API for real-to-complex transform with shortening of the data
Cfftw_r2r_types
Cfftw_r2r_types< float >
Cplan_fftw_r2r	Wrapper for the r2r plan to allow for RAII style of management
Creal2real_executor< backend::fftw, prepost_processor >
Cone_dim_backend< backend::fftw >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::fftw_cos >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::fftw_sin >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::fftw_cos1 >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::fftw_sin1 >	Helper struct that defines the types and creates instances of one-dimensional executors
Cdefault_plan_options< backend::fftw >	Sets the default options for the fftw backend
Cdefault_plan_options< backend::fftw_cos >	Sets the default options for the fftw backend
Cdefault_plan_options< backend::fftw_sin >	Sets the default options for the fftw backend
Cdefault_plan_options< backend::fftw_cos1 >	Sets the default options for the fftw backend
Cdefault_plan_options< backend::fftw_sin1 >	Sets the default options for the fftw backend
Cis_ccomplex< float _Complex >	Recognize the MKL single precision complex type
Cis_zcomplex< double _Complex >	Recognize the MKL double precision complex type
Cplan_mkl	Base plan for backend::mkl, works only for float and double complex
Cmkl_executor	Wrapper around the MKL API
Cplan_mkl_r2c	Unlike the C2C plan R2C is non-symmetric and it requires that the direction is built into the plan
Cmkl_executor_r2c	Wrapper to mkl API for real-to-complex transform with shortening of the data
Cone_dim_backend< backend::mkl >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::mkl_cos >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::mkl_sin >	Helper struct that defines the types and creates instances of one-dimensional executors
Cdefault_plan_options< backend::mkl >	Sets the default options for the mkl backend
Cdefault_plan_options< backend::mkl_cos >	Sets the default options for the mkl backend
Cdefault_plan_options< backend::mkl_sin >	Sets the default options for the mkl backend
Cevent_chainer	Helper class to chain a series of compute calls with sycl::event
Conemkl_executor	Wrapper around the oneMKL API
Conemkl_executor_r2c	Wrapper to oneMKL API for real-to-complex transform with shortening of the data
Cone_dim_backend< backend::onemkl >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::onemkl_cos >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::onemkl_sin >	Helper struct that defines the types and creates instances of one-dimensional executors
Cdefault_plan_options< backend::onemkl >	Sets the default options for the oneMKL backend
Cdefault_plan_options< backend::onemkl_cos >	Sets the default options for the oneMKL backend
Cdefault_plan_options< backend::onemkl_sin >	Sets the default options for the oneMKL backend
Cplan_rocfft	Plan for the r2c single precision transform
Cplan_rocfft< std::complex< precision_type >, dir >	Plan for the single precision complex transform
Crocfft_executor	Wrapper around the rocFFT API
Crocfft_executor_r2c	Wrapper to rocFFT API for real-to-complex transform with shortening of the data
Cone_dim_backend< backend::rocfft >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::rocfft_cos >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::rocfft_sin >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::rocfft_cos1 >	Helper struct that defines the types and creates instances of one-dimensional executors
Cdefault_plan_options< backend::rocfft >	Sets the default options for the cufft backend
Cdefault_plan_options< backend::rocfft_cos >	Sets the default options for the cufft backend
Cdefault_plan_options< backend::rocfft_sin >	Sets the default options for the cufft backend
Cdefault_plan_options< backend::rocfft_cos1 >	Sets the default options for the cufft backend
Cis_ccomplex< stock::Complex< float, 1 > >	Recognize stock FFT single complex (which are std::complex) types
Cis_zcomplex< stock::Complex< double, 1 > >
Cplan_stock_fft	Specialization for r2c single precision
Cplan_stock_fft< std::complex< F >, dir >	Plan for the single precision complex transform
Cstock_fft_executor	Wrapper around the Stock FFT API
Cstock_fft_executor_r2c	Wrapper to stock API for real-to-complex transform with shortening of the data
Cone_dim_backend< backend::stock >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::stock_cos >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::stock_sin >	Helper struct that defines the types and creates instances of one-dimensional executors
Cone_dim_backend< backend::stock_cos1 >	Helper struct that defines the types and creates instances of one-dimensional executors
Cdefault_plan_options< backend::stock >	Sets the default options for the stock fft backend
Cdefault_plan_options< backend::stock_cos >	Sets the default options for the stock fft backend
Cdefault_plan_options< backend::stock_sin >	Sets the default options for the stock fft backend
Cdefault_plan_options< backend::stock_cos1 >	Sets the default options for the stock fft backend
Cexecutor_base	Base class for all backend executors
Calign	CuFFT requires that the input and output in R2C transforms are aligned to the complex type
Cone_dim_backend	Indicates the structure that will be used by the fft backend
Cdefault_plan_options	Defines a set of default plan options for a given backend
Cfft_output	Defines the relationship between pairs of input-output types in the FFT algorithms
Cfft_output< float >	Specialization mapping float to std::complex<float>
Cfft_output< double >	Specialization mapping double to std::complex<double>
Ctransform_output	Defines the relationship between pairs of input-output types in a general transform algorithm
Ctransform_output< scalar_type, backend_tag, typename std::enable_if< backend::uses_fft_types< backend_tag >::value >::type >	Specialization for standard FFT
Ctransform_output< scalar_type, backend_tag, typename std::enable_if< not backend::uses_fft_types< backend_tag >::value >::type >	Specialization for Cosine Transform
Ctransform_real_type	Defines the relationship between pairs of input-output types in a general transform algorithm
Ctransform_real_type< scalar_type, backend_tag, typename std::enable_if< backend::uses_fft_types< backend_tag >::value >::type >	Specialization for standard FFT
Ctransform_real_type< scalar_type, backend_tag, typename std::enable_if< not backend::uses_fft_types< backend_tag >::value >::type >	Specialization for Cosine Transform
Cfft3d	Defines the plan for a 3-dimensional discrete Fourier transform performed on a MPI distributed data
Cfft3d_r2c	Similar to heffte::fft3d, but computed fewer redundant coefficients when the input is real
Cbox3d	A generic container that describes a 3d box of indexes
Crank_remap	Keeps the local rank and the map from the global rank to the sub-ranks used in the work
Cioboxes	Pair of lists of input-output boxes as used by the heffte::fft3d
Cpack_plan_3d	Holds the plan for a pack/unpack operation
Cpacker_backend	The packer needs to know whether the data will be on the CPU or GPU devices
Cdirect_packer	Defines the direct packer without implementation, use the specializations to get the CPU or GPU implementation
Cdirect_packer< tag::cpu >	Simple packer that copies sub-boxes without transposing the order of the indexes
Ctranspose_packer	Defines the transpose packer without implementation, use the specializations to get the CPU implementation
Ctranspose_packer< tag::cpu >	Transpose packer that packs sub-boxes without transposing, but unpacks applying a transpose operation
Cplan_options	Defines a set of tweaks and options to use in the plan generation
Clogic_plan3d	The logic plan incorporates the order and types of operations in a transform
Ccpu_cos_pre_pos_processor	Pre/Post processing for the Cosine transform using the CPU
Ccpu_sin_pre_pos_processor	Pre/Post processing for the Sine transform using the CPU
Ccpu_cos1_pre_pos_processor	Pre/Post processing for the Cosine transform type I using the CPU
Ccpu_sin1_pre_pos_processor
Creal2real_executor	Template algorithm for the Sine and Cosine transforms
Creshape3d_base	Base reshape interface
Creshape3d_alltoall	Reshape algorithm based on the MPI_Alltoall() method
Creshape3d_alltoallv	Reshape algorithm based on the MPI_Alltoallv() method
Creshape3d_pointtopoint	Reshape algorithm based on the MPI_Send() and MPI_Irecv() methods
Creshape3d_transpose	Special case of the reshape that does not involve MPI communication but applies a transpose instead
Cevent	A tracing event
Cadd_trace	Hefftetrace
Cis_ccomplex	Struct to specialize to allow HeFFTe to recognize custom single precision complex types
Cis_zcomplex	Struct to specialize to allow HeFFTe to recognize custom double precision complex types
Cis_ccomplex< std::complex< float > >	By default, HeFFTe recognizes std::complex<float>
Cis_zcomplex< std::complex< double > >	By default, HeFFTe recognizes std::complex<double>
Cdefine_standard_type	Struct to specialize that returns the C++ equivalent of each type
Cdefine_standard_type< float, void >	Type float is equivalent to float
Cdefine_standard_type< double, void >	Type double is equivalent to double
Cdefine_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>
Cdefine_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_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