Skip to content

Commit

Permalink
Fixed 2D, 3D and nD xarray FFT tests
Browse files Browse the repository at this point in the history 
Regular FFT family now fully functional! #6
  • Loading branch information
@egpbos
egpbos committed Oct 23, 2017
1 parent 092dd7f commit 0648914
Showing 1 changed file with 18 additions and 18 deletions.
36 changes: 18 additions & 18 deletions test/basic_interface.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -93,69 +93,69 @@ TYPED_TEST(TransformAndInvert, FFT_2D_xarray) {
auto a_fourier = xt::fftw::fft2(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifft2(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}

/*
TYPED_TEST(TransformAndInvert, FFT_3D_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 3>(data_size);
auto a_fourier = xt::fftw::fft3(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifft3(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}

TYPED_TEST(TransformAndInvert, FFT_nD_n_equals_4_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 4>(data_size);
auto a_fourier = xt::fftw::fftn<4>(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifftn<4>(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}

TYPED_TEST(TransformAndInvert, FFT_nD_n_equals_1_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 1>(data_size);
auto a_fourier = xt::fftw::fftn<1>(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifftn<1>(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}


////
// Regular FFT: xtensor
////

/*
TYPED_TEST(TransformAndInvert, FFT_1D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 1> a = generate_complex_data<TypeParam, 1>(data_size);
auto a_fourier = xt::fftw::fft(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifft(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, FFT_2D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 2> a = generate_complex_data<TypeParam, 2>(data_size);
auto a_fourier = xt::fftw::fft2(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifft2(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, FFT_3D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 3> a = generate_complex_data<TypeParam, 3>(data_size);
auto a_fourier = xt::fftw::fft3(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifft3(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, FFT_4D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 4> a = generate_complex_data<TypeParam, 4>(data_size);
auto a_fourier = xt::fftw::fftn(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ifftn(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
*/
Expand Down Expand Up @@ -260,39 +260,39 @@ TYPED_TEST(TransformAndInvert, hermFFT_1D_xarray) {
auto a_fourier = xt::fftw::hfft(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfft(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_2D_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 2>(data_size);
auto a_fourier = xt::fftw::hfft2(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfft2(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_3D_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 3>(data_size);
auto a_fourier = xt::fftw::hfft3(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfft3(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_nD_n_equals_4_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 4>(data_size);
auto a_fourier = xt::fftw::hfftn<4>(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfftn<4>(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_nD_n_equals_1_xarray) {
xt::xarray<std::complex<TypeParam>, xt::layout_type::row_major> a = generate_complex_data<TypeParam, 1>(data_size);
auto a_fourier = xt::fftw::hfftn<1>(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfftn<1>(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
////
Expand All @@ -304,30 +304,30 @@ TYPED_TEST(TransformAndInvert, hermFFT_1D_xtensor) {
auto a_fourier = xt::fftw::hfft(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfft(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_2D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 2> a = generate_complex_data<TypeParam, 2>(data_size);
auto a_fourier = xt::fftw::hfft2(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfft2(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_3D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 3> a = generate_complex_data<TypeParam, 3>(data_size);
auto a_fourier = xt::fftw::hfft3(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfft3(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
TYPED_TEST(TransformAndInvert, hermFFT_4D_xtensor) {
xt::xtensor<std::complex<TypeParam>, 4> a = generate_complex_data<TypeParam, 4>(data_size);
auto a_fourier = xt::fftw::hfftn(a);
std::cout << "fourier transform of input before ifft (which is destructive!): " << a_fourier << std::endl;
auto should_be_a = xt::fftw::ihfftn(a_fourier);
assert_results(a, a_fourier, should_be_a);
assert_results_complex(a, a_fourier, should_be_a);
}
*/

0 comments on commit 0648914

Please sign in to comment.