Functions
cxx11_tensor_ifft.cpp File Reference
#include "main.h"
#include <complex>
#include <cmath>
#include <Eigen/CXX11/Tensor>

Functions

template<int DataLayout>
static void test_1D_fft_ifft_invariant (int sequence_length)
 
template<int DataLayout>
static void test_2D_fft_ifft_invariant (int dim0, int dim1)
 
template<int DataLayout>
static void test_3D_fft_ifft_invariant (int dim0, int dim1, int dim2)
 
template<int DataLayout>
static void test_sub_fft_ifft_invariant (int dim0, int dim1, int dim2, int dim3)
 
 EIGEN_DECLARE_TEST (cxx11_tensor_ifft)
 

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( cxx11_tensor_ifft  )
137  {
138  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(4));
139  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(16));
140  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(32));
141  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(1024 * 1024));
142 
143  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(4, 4));
144  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(8, 16));
145  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(16, 32));
146  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(1024, 1024));
147 
148  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(4, 4, 4));
149  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(8, 16, 32));
150  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(16, 4, 8));
151  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(256, 256, 256));
152 
153  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(4, 4, 4, 4));
154  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(8, 16, 32, 64));
155  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(16, 4, 8, 12));
156  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(64, 64, 64, 64));
157 }
CALL_SUBTEST
#define CALL_SUBTEST(FUNC)
Definition: main.h:382

References CALL_SUBTEST.

◆ test_1D_fft_ifft_invariant()

template<int DataLayout>
static void test_1D_fft_ifft_invariant ( int  sequence_length)
static
18  {
19  Tensor<double, 1, DataLayout> tensor(sequence_length);
20  tensor.setRandom();
21 
22  array<int, 1> fft;
23  fft[0] = 0;
24 
25  Tensor<std::complex<double>, 1, DataLayout> tensor_after_fft;
26  Tensor<std::complex<double>, 1, DataLayout> tensor_after_fft_ifft;
27 
28  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
29  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
30 
31  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), sequence_length);
32  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), sequence_length);
33 
34  for (int i = 0; i < sequence_length; ++i) {
35  VERIFY_IS_APPROX(static_cast<float>(tensor(i)), static_cast<float>(std::real(tensor_after_fft_ifft(i))));
36  }
37 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::Tensor
The tensor class.
Definition: Tensor.h:68
Eigen::Tensor::dimension
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(std::size_t n) const
Definition: Tensor.h:99
DataLayout
static const int DataLayout
Definition: cxx11_tensor_image_patch_sycl.cpp:24
real
float real
Definition: datatypes.h:10
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:367
Eigen::array
std::array< T, N > array
Definition: EmulateArray.h:231

References DataLayout, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

◆ test_2D_fft_ifft_invariant()

template<int DataLayout>
static void test_2D_fft_ifft_invariant ( int  dim0,
int  dim1 
)
static
40  {
41  Tensor<double, 2, DataLayout> tensor(dim0, dim1);
42  tensor.setRandom();
43 
44  array<int, 2> fft;
45  fft[0] = 0;
46  fft[1] = 1;
47 
48  Tensor<std::complex<double>, 2, DataLayout> tensor_after_fft;
49  Tensor<std::complex<double>, 2, DataLayout> tensor_after_fft_ifft;
50 
51  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
52  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
53 
54  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
55  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
56  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
57  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
58 
59  for (int i = 0; i < dim0; ++i) {
60  for (int j = 0; j < dim1; ++j) {
61  // std::cout << "[" << i << "][" << j << "]" << " Original data: " << tensor(i,j) << " Transformed data:" <<
62  // tensor_after_fft_ifft(i,j) << std::endl;
63  VERIFY_IS_APPROX(static_cast<float>(tensor(i, j)), static_cast<float>(std::real(tensor_after_fft_ifft(i, j))));
64  }
65  }
66 }
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References DataLayout, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

◆ test_3D_fft_ifft_invariant()

template<int DataLayout>
static void test_3D_fft_ifft_invariant ( int  dim0,
int  dim1,
int  dim2 
)
static
69  {
70  Tensor<double, 3, DataLayout> tensor(dim0, dim1, dim2);
71  tensor.setRandom();
72 
73  array<int, 3> fft;
74  fft[0] = 0;
75  fft[1] = 1;
76  fft[2] = 2;
77 
78  Tensor<std::complex<double>, 3, DataLayout> tensor_after_fft;
79  Tensor<std::complex<double>, 3, DataLayout> tensor_after_fft_ifft;
80 
81  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
82  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
83 
84  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
85  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
86  VERIFY_IS_EQUAL(tensor_after_fft.dimension(2), dim2);
87  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
88  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
89  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(2), dim2);
90 
91  for (int i = 0; i < dim0; ++i) {
92  for (int j = 0; j < dim1; ++j) {
93  for (int k = 0; k < dim2; ++k) {
94  VERIFY_IS_APPROX(static_cast<float>(tensor(i, j, k)),
95  static_cast<float>(std::real(tensor_after_fft_ifft(i, j, k))));
96  }
97  }
98  }
99 }
k
char char char int int * k
Definition: level2_impl.h:374

References DataLayout, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, k, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.

◆ test_sub_fft_ifft_invariant()

template<int DataLayout>
static void test_sub_fft_ifft_invariant ( int  dim0,
int  dim1,
int  dim2,
int  dim3 
)
static
102  {
103  Tensor<double, 4, DataLayout> tensor(dim0, dim1, dim2, dim3);
104  tensor.setRandom();
105 
106  array<int, 2> fft;
107  fft[0] = 2;
108  fft[1] = 0;
109 
110  Tensor<std::complex<double>, 4, DataLayout> tensor_after_fft;
111  Tensor<double, 4, DataLayout> tensor_after_fft_ifft;
112 
113  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
114  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::RealPart, Eigen::FFT_REVERSE>(fft);
115 
116  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
117  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
118  VERIFY_IS_EQUAL(tensor_after_fft.dimension(2), dim2);
119  VERIFY_IS_EQUAL(tensor_after_fft.dimension(3), dim3);
120  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
121  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
122  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(2), dim2);
123  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(3), dim3);
124 
125  for (int i = 0; i < dim0; ++i) {
126  for (int j = 0; j < dim1; ++j) {
127  for (int k = 0; k < dim2; ++k) {
128  for (int l = 0; l < dim3; ++l) {
129  VERIFY_IS_APPROX(static_cast<float>(tensor(i, j, k, l)),
130  static_cast<float>(tensor_after_fft_ifft(i, j, k, l)));
131  }
132  }
133  }
134  }
135 }

References DataLayout, Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType_ >::dimension(), i, j, k, Eigen::TensorBase< Derived, AccessLevel >::setRandom(), VERIFY_IS_APPROX, and VERIFY_IS_EQUAL.