KokkosFFT::irfft2

template<typename ExecutionSpace, typename InViewType, typename OutViewType>
void KokkosFFT::irfft2(const ExecutionSpace &exec_space, const InViewType &in, const OutViewType &out, KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward, axis_type<2> axes = {-2, -1}, shape_type<2> s = {})

Inverse of rfft2.

Template Parameters:

  • ExecutionSpace – The type of Kokkos execution space

  • InViewType – Input View type for the fft

  • OutViewType – Output View type for the fft

Parameters:

  • exec_space – [in] Kokkos execution space

  • in – [in] Input data (complex)

  • out – [out] Output data (real)

  • norm – [in] How the normalization is applied (default, backward)

  • axes – [in] Axes over which FFT is performed (default, {-2, -1})

  • s – [in] Shape of the transformed axis of the output (default, {})

Note

The input must be a complex-valued view, and the output must be a real-valued view. The input length along the transform axis (axes[1]) is n/2 + 1, where n is the output length along that axis. If this condition is not met, the std::runtime_error exception will be thrown.

Examples

In this example, we use the 2D View with LayoutRight to avoid the internal transpose. This allows irfft2 to perform 2D FFT on the outermost dimension without transpose.

 1#include <iostream>
 2#include <Kokkos_Core.hpp>
 3#include <Kokkos_Complex.hpp>
 4#include <KokkosFFT.hpp>
 5
 6/// \brief Example of irfft2 usage in documentation
 7/// x_hat = [[78, -6+6j, -6],
 8///          [-24+13.8564j, 0, 0],
 9///          [-24-13.8564j, 0, 0]]
10/// x = [[1, 2, 3, 4],
11///      [5, 6, 7, 8],
12///      [9, 10, 11, 12]]
13int main(int argc, char* argv[]) {
14  Kokkos::ScopeGuard guard(argc, argv);
15  using ExecutionSpace = Kokkos::DefaultExecutionSpace;
16  using View2D = Kokkos::View<double**, Kokkos::LayoutRight, ExecutionSpace>;
17  using ComplexView2D = Kokkos::View<Kokkos::complex<double>**,
18                                     Kokkos::LayoutRight, ExecutionSpace>;
19
20  const int n0 = 3, n1 = 4;
21
22  ComplexView2D x_hat("x_hat", n0, n1 / 2 + 1);
23  View2D x("x", n0, n1);
24  auto h_x_hat  = Kokkos::create_mirror_view(x_hat);
25  h_x_hat(0, 0) = Kokkos::complex<double>(78, 0);
26  h_x_hat(0, 1) = Kokkos::complex<double>(-6, 6);
27  h_x_hat(0, 2) = Kokkos::complex<double>(-6, 0);
28  h_x_hat(1, 0) = Kokkos::complex<double>(-24, 13.8564);
29  h_x_hat(2, 0) = Kokkos::complex<double>(-24, -13.8564);
30  Kokkos::deep_copy(x_hat, h_x_hat);
31
32  ExecutionSpace exec;
33  KokkosFFT::irfft2(exec, x_hat, x);
34
35  auto h_x = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, x);
36  for (int i = 0; i < n0; ++i) {
37    for (int j = 0; j < n1; ++j) {
38      std::cout << " " << h_x(i, j);
39    }
40    std::cout << std::endl;
41  }
42
43  return 0;
44}

Expected output:

1 2 3 4
5 6 7 8
9 10 11 12