KokkosFFT::fftn

template<typename ExecutionSpace, typename InViewType, typename OutViewType, std::size_t DIM>
void KokkosFFT::fftn(const ExecutionSpace &exec_space, const InViewType &in, const OutViewType &out, axis_type<DIM> axes = KokkosFFT::Impl::index_sequence<int, DIM, -static_cast<int>(DIM)>(), KokkosFFT::Normalization norm = KokkosFFT::Normalization::backward, shape_type<DIM> s = {})

N-dimensional FFT in forward direction.

Template Parameters:

  • ExecutionSpace – The type of Kokkos execution space

  • InViewType – Input View type for the fft

  • OutViewType – Output View type for the fft

  • DIM – The dimensionality of the fft

Parameters:

  • exec_space – [in] Kokkos execution space

  • in – [in] Input data (real or complex)

  • out – [out] Output data (complex)

  • axes – [in] Axes over which FFT is performed (default, all axes)

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

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

Note

For the real input, we internally convert it to complex and perform fftn on it.

Examples

In this example, we use the 3D View with LayoutRight to avoid the internal transpose. This allows fftn to perform 3D 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 fftn usage in documentation
 7/// x = [[[1, 2],
 8///      [3, 4]],
 9///     [[5, 6],
10///      [7, 8]],
11///     [[9, 10],
12///      [11, 12]]]
13/// x_hat = [[[78, -6],
14///           [-12, 0]],
15///          [[-24+13.8564j, 0],
16///           [0, 0]],
17///          [[-24-13.8564j, 0],
18///           [0, 0]]]
19int main(int argc, char* argv[]) {
20  Kokkos::ScopeGuard guard(argc, argv);
21  using ExecutionSpace = Kokkos::DefaultExecutionSpace;
22  using View3D = Kokkos::View<Kokkos::complex<double>***, Kokkos::LayoutRight,
23                              ExecutionSpace>;
24
25  const int n0 = 3, n1 = 2, n2 = 2;
26
27  View3D x("x", n0, n1, n2), x_hat("x_hat", n0, n1, n2);
28  auto h_x = Kokkos::create_mirror_view(x);
29  for (int i = 0; i < n0; ++i) {
30    for (int j = 0; j < n1; ++j) {
31      for (int k = 0; k < n2; ++k) {
32        h_x(i, j, k) = Kokkos::complex<double>(i * n1 * n2 + j * n2 + k + 1);
33      }
34    }
35  }
36  Kokkos::deep_copy(x, h_x);
37
38  ExecutionSpace exec;
39  KokkosFFT::fftn(exec, x, x_hat);
40
41  auto h_x_hat =
42      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, x_hat);
43  for (int i = 0; i < n0; ++i) {
44    for (int j = 0; j < n1; ++j) {
45      for (int k = 0; k < n2; ++k) {
46        std::cout << " " << h_x_hat(i, j, k);
47      }
48      std::cout << "\n";
49    }
50    if (i < n0 - 1) std::cout << "\n";
51  }
52  std::cout << std::endl;
53
54  return 0;
55}

Expected output:

(78,0) (-6,0)
(-12,0) (0,0)

(-24,13.8564) (0,0)
(0,0) (0,0)

(-24,-13.8564) (0,0)
(0,0) (0,0)